deps/lightning/include/lightning/jit_private.h

   1 /*
   2  * Copyright (C) 2012-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #ifndef _jit_private_h
  21 #define _jit_private_h
  22
  23 #if HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include <assert.h>
  28 #include <limits.h>
  29 #include <stdio.h>
  30
  31 #ifdef STDC_HEADERS
  32 #  include <stddef.h>
  33 #else
  34 #  if !defined(offsetof)
  35 #    define offsetof(type, field) ((char *)&((type *)0)->field - (char *)0)
  36 #  endif
  37 #endif
  38
  39 #if defined(__GNUC__)
  40 #  define maybe_unused          __attribute__ ((unused))
  41 #  define unlikely(exprn)       __builtin_expect(!!(exprn), 0)
  42 #  define likely(exprn)         __builtin_expect(!!(exprn), 1)
  43 #  if (__GNUC__ >= 4)
  44 #    define PUBLIC              __attribute__ ((visibility("default")))
  45 #    define HIDDEN              __attribute__ ((visibility("hidden")))
  46 #  else
  47 #    define PUBLIC              /**/
  48 #    define HIDDEN              /**/
  49 #  endif
  50 #else
  51 #  define maybe_unused          /**/
  52 #  define unlikely(exprn)       exprn
  53 #  define likely(exprn)         exprn
  54 #  define PUBLIC                /**/
  55 #  define HIDDEN                /**/
  56 #endif
  57
  58 #if PACKED_STACK || STRONG_TYPE_CHECKING
  59 #  define assert_arg_type(code, expect)                                 \
  60     do assert((code) == (expect)); while (0)
  61 #  define assert_putarg_type(code, expect)                              \
  62     do                                                                  \
  63         assert((((code) - jit_code_putargr_c) >> 2) ==                  \
  64                ((expect) - jit_code_arg_c));                            \
  65     while (0)
  66 #else
  67 #  define assert_arg_type(code, expect)                                 \
  68     do assert((int)(code) == (int)(expect) ||                           \
  69               (code) == jit_code_arg); while (0)
  70 #  define assert_putarg_type(code, expect)                              \
  71     do                                                                  \
  72         assert(((((code) - jit_code_putargr_c) >> 2) ==                 \
  73                ((expect) - jit_code_arg_c)) ||                          \
  74                ((code) == jit_code_arg));                               \
  75     while (0)
  76 #endif
  77
  78 #define rc(value)               jit_class_##value
  79 #define rn(reg)                 (jit_regno(_rvs[jit_regno(reg)].spec))
  80
  81 #if defined(__i386__) || defined(__x86_64__)
  82 #  define JIT_SP                _RSP
  83 #  define JIT_RET               _RAX
  84 #  if __X32
  85 #    define JIT_FRET            _ST0
  86 typedef jit_uint32_t            jit_regset_t;
  87 #  else
  88 #    if __CYGWIN__ || _WIN32
  89 #      define JIT_RA0           _RCX
  90 #    else
  91 #      define JIT_RA0           _RDI
  92 #    endif
  93 #    define JIT_FA0             _XMM0
  94 #    define JIT_FRET            _XMM0
  95 typedef jit_uint64_t            jit_regset_t;
  96 #  endif
  97 #elif defined(__mips__)
  98 #  define JIT_RA0               _A0
  99 #  define JIT_FA0               _F12
 100 #  define JIT_SP                _SP
 101 #  define JIT_RET               _V0
 102 #  define JIT_FRET              _F0
 103 typedef jit_uint64_t            jit_regset_t;
 104 #elif defined(__arm__)
 105 #  define JIT_RA0               _R0
 106 #  define JIT_FA0               _D0
 107 #  define JIT_SP                _R13
 108 #  define JIT_RET               _R0
 109 #  if defined(__ARM_PCS_VFP)
 110 #    define JIT_FRET            _D0
 111 #  else
 112 #    define JIT_FRET            _R0
 113 #  endif
 114 typedef jit_uint64_t            jit_regset_t;
 115 #elif defined(__powerpc__)
 116 #  define JIT_RA0               _R3
 117 #  define JIT_FA0               _F1
 118 #  define JIT_SP                _R1
 119 #  define JIT_RET               _R3
 120 #  define JIT_FRET              _F1
 121 typedef jit_uint64_t            jit_regset_t;
 122 #elif defined(__sparc__)
 123 #  define JIT_SP                _SP
 124 #  define JIT_RET               _I0
 125 #  define JIT_FRET              _F0
 126 #  if __WORDSIZE == 32
 127 typedef jit_uint64_t            jit_regset_t;
 128 #  else
 129 typedef struct {
 130     jit_uint64_t        rl;
 131     jit_uint64_t        rh;
 132 } jit_regset_t;
 133 #  endif
 134 #elif defined(__ia64__)
 135 #  define JIT_SP                _R12
 136 #  define JIT_RET               _R8
 137 #  define JIT_FRET              _F8
 138 typedef struct {
 139     jit_uint64_t        rl;
 140     jit_uint64_t        rh;
 141     jit_uint64_t        fl;
 142     jit_uint64_t        fh;
 143 } jit_regset_t;
 144 #elif defined(__hppa__)
 145 #  define JIT_SP                _R30
 146 #  define JIT_RET               _R28
 147 #  define JIT_FRET              _F4
 148 typedef jit_uint64_t            jit_regset_t;
 149 #elif defined(__aarch64__)
 150 #  define JIT_RA0               _R0
 151 #  define JIT_FA0               _V0
 152 #  define JIT_SP                _SP
 153 #  define JIT_RET               _R0
 154 #  define JIT_FRET              _V0
 155 typedef jit_uint64_t            jit_regset_t;
 156 #elif defined(__s390__) || defined(__s390x__)
 157 #  define JIT_SP                _R15
 158 #  define JIT_RET               _R2
 159 #  define JIT_FRET              _F0
 160 typedef jit_uint32_t            jit_regset_t;
 161 #elif defined(__alpha__)
 162 #  define JIT_SP                _SP
 163 #  define JIT_RET               _V0
 164 #  define JIT_FRET              _F0
 165 typedef jit_uint64_t            jit_regset_t;
 166 #elif defined(__riscv)
 167 #  define JIT_RA0               _A0
 168 #  define JIT_FA0               _FA0
 169 #  define JIT_SP                _SP
 170 #  define JIT_RET               _A0
 171 #  define JIT_FRET              _FA0
 172 typedef jit_uint64_t            jit_regset_t;
 173 #elif defined(__loongarch__)
 174 #  define JIT_RA0               _A0
 175 #  define JIT_FA0               _FA0
 176 #  define JIT_SP                _SP
 177 #  define JIT_RET               _A0
 178 #  define JIT_FRET              _FA0
 179 typedef jit_uint64_t            jit_regset_t;
 180 #endif
 181
 182 #define jit_data(u,v,w)         _jit_data(_jit,u,v,w)
 183 extern jit_node_t *_jit_data(jit_state_t*, const void*,
 184                              jit_word_t, jit_int32_t);
 185
 186 #define jit_size(vector)        (sizeof(vector) / sizeof((vector)[0]))
 187
 188 #define jit_reg_free_p(regno)                                           \
 189     (!jit_regset_tstbit(&_jitc->reglive, regno) &&                      \
 190      !jit_regset_tstbit(&_jitc->regarg, regno) &&                       \
 191      !jit_regset_tstbit(&_jitc->regsav, regno))
 192
 193 #define jit_reg_free_if_spill_p(regno)                                  \
 194     (!jit_regset_tstbit(&_jitc->regarg, regno) &&                       \
 195      !jit_regset_tstbit(&_jitc->regsav, regno))
 196
 197 #define jit_code_inc_synth(code)                                        \
 198     do {                                                                \
 199         (void)jit_new_node(code);                                       \
 200         jit_synth_inc();                                                \
 201     } while (0)
 202 #define jit_inc_synth(name)                                             \
 203     jit_code_inc_synth(jit_code_##name)
 204 #define jit_code_inc_synth_w(code, u)                                   \
 205     do {                                                                \
 206         (void)jit_new_node_w(code, u);                                  \
 207         jit_synth_inc();                                                \
 208     } while (0)
 209 #define jit_inc_synth_w(name, u)                                        \
 210     jit_code_inc_synth_w(jit_code_##name, u)
 211 #define jit_code_inc_synth_f(code, u)                                   \
 212     do {                                                                \
 213         (void)jit_new_node_f(code, u);                                  \
 214         jit_synth_inc();                                                \
 215     } while (0)
 216 #define jit_inc_synth_f(name, u)                                        \
 217     jit_code_inc_synth_f(jit_code_##name, u)
 218 #define jit_code_inc_synth_d(code, u)                                   \
 219     do {                                                                \
 220         (void)jit_new_node_d(code, u);                                  \
 221         jit_synth_inc();                                                \
 222     } while (0)
 223 #define jit_inc_synth_d(name, u)                                        \
 224     jit_code_inc_synth_d(jit_code_##name, u)
 225 #define jit_code_inc_synth_ww(code, u, v)                               \
 226     do {                                                                \
 227         (void)jit_new_node_ww(code, u, v);                              \
 228         jit_synth_inc();                                                \
 229     } while (0)
 230 #define jit_inc_synth_ww(name, u, v)                                    \
 231     jit_code_inc_synth_ww(jit_code_##name, u, v)
 232 #define jit_code_inc_synth_wp(code, u, v)                               \
 233     do {                                                                \
 234         (void)jit_new_node_wp(code, u, v);                              \
 235         jit_synth_inc();                                                \
 236     } while (0)
 237 #define jit_inc_synth_wp(name, u, v)                                    \
 238     jit_code_inc_synth_wp(jit_code_##name, u, v)
 239 #define jit_code_inc_synth_fp(code, u, v)                               \
 240     do {                                                                \
 241         (void)jit_new_node_fp(code, u, v);                              \
 242         jit_synth_inc();                                                \
 243     } while (0)
 244 #define jit_inc_synth_fp(name, u, v)                                    \
 245     jit_code_inc_synth_fp(jit_code_##name, u, v)
 246 #define jit_code_inc_synth_dp(code, u, v)                               \
 247     do {                                                                \
 248         (void)jit_new_node_dp(code, u, v);                              \
 249         jit_synth_inc();                                                \
 250     } while (0)
 251 #define jit_inc_synth_dp(name, u, v)                                    \
 252     jit_code_inc_synth_dp(jit_code_##name, u, v)
 253 #define jit_inc_synth_wf(name, u, v)                                    \
 254     jit_code_inc_synth_wf(jit_code_##name, u, v)
 255 #define jit_code_inc_synth_wf(code, u, v)                               \
 256     do {                                                                \
 257         (void)jit_new_node_wf(code, u, v);                              \
 258         jit_synth_inc();                                                \
 259     } while (0)
 260 #define jit_inc_synth_wqf(name, u, v, w, x)                             \
 261     do {                                                                \
 262         (void)jit_new_node_wqf(jit_code_##name, u, v, w, x);            \
 263         jit_synth_inc();                                                \
 264     } while (0)
 265 #define jit_inc_synth_wd(name, u, v)                                    \
 266     jit_code_inc_synth_wd(jit_code_##name, u, v)
 267 #define jit_inc_synth_wqd(name, u, v, w, x)                             \
 268     do {                                                                \
 269         (void)jit_new_node_wqd(jit_code_##name, u, v, w, x);            \
 270         jit_synth_inc();                                                \
 271     } while (0)
 272 #define jit_code_inc_synth_wd(code, u, v)                               \
 273     do {                                                                \
 274         (void)jit_new_node_wd(code, u, v);                              \
 275         jit_synth_inc();                                                \
 276     } while (0)
 277 #define jit_dec_synth()         jit_synth_dec()
 278
 279 #define jit_link_alist(node)                                            \
 280     do {                                                                \
 281         node->link = _jitc->function->alist;                            \
 282         _jitc->function->alist = node;                                  \
 283     } while (0)
 284 #define jit_check_frame()                                               \
 285     do {                                                                \
 286         if (!_jitc->function->need_frame) {                             \
 287             _jitc->again = 1;                                           \
 288             _jitc->function->need_frame = 1;                            \
 289         }                                                               \
 290     } while (0)
 291 #define jit_diffsize()  (stack_framesize - _jitc->framesize)
 292 #define jit_framesize() (stack_framesize - jit_diffsize())
 293 #define jit_selfsize()  (_jitc->function->self.size - jit_diffsize())
 294
 295 #define jit_link_prolog()                                               \
 296     do {                                                                \
 297         _jitc->tail->link = _jitc->function->prolog->link;              \
 298         _jitc->function->prolog->link = _jitc->tail;                    \
 299     } while (0)
 300 #define jit_link_prepare()                                              \
 301     do {                                                                \
 302         _jitc->tail->link = _jitc->prepare->link;                       \
 303         _jitc->prepare->link = _jitc->tail;                             \
 304     } while (0)
 305 #define jit_link_reverse(where)                                         \
 306     do {                                                                \
 307         jit_node_t      *tmp, *tail = 0;                                \
 308         while (where) {                                                 \
 309             tmp = (where)->link;                                        \
 310             (where)->link = tail;                                       \
 311             tail = where;                                               \
 312             where = tmp;                                                \
 313         }                                                               \
 314         where = tail;                                                   \
 315     } while (0);
 316
 317 /*
 318  * Private jit_class bitmasks
 319  */
 320 #define jit_class_named         0x00400000      /* hit must be the named reg */
 321 #define jit_class_nospill       0x00800000      /* hint to fail if need spill */
 322 #define jit_class_sft           0x01000000      /* not a hardware register */
 323 #define jit_class_rg8           0x04000000      /* x86 8 bits */
 324 #define jit_class_xpr           0x80000000      /* float / vector */
 325 /* Used on sparc64 where %f0-%f31 can be encode for single float
 326  * but %f32 to %f62 only as double precision */
 327 #define jit_class_sng           0x00010000      /* Single precision float */
 328 #define jit_class_dbl           0x00020000      /* Only double precision float */
 329 #define jit_regno_patch         0x00008000      /* this is a register
 330                                                  * returned by a "user" call
 331                                                  * to jit_get_reg() */
 332
 333 #define jit_call_default        0
 334 #define jit_call_varargs        1
 335
 336 #define jit_kind_register       1
 337 #define jit_kind_code           2
 338 #define jit_kind_word           3
 339 #define jit_kind_float32        4
 340 #define jit_kind_float64        5
 341
 342 #define jit_cc_a0_reg           0x00000001      /* arg0 is a register */
 343 #define jit_cc_a0_chg           0x00000002      /* arg0 is modified */
 344 #define jit_cc_a0_jmp           0x00000004      /* arg0 is a jump target */
 345 #define jit_cc_a0_rlh           0x00000008      /* arg0 is a register pair */
 346 #define jit_cc_a0_int           0x00000010      /* arg0 is immediate word */
 347 #define jit_cc_a0_flt           0x00000020      /* arg0 is immediate float */
 348 #define jit_cc_a0_dbl           0x00000040      /* arg0 is immediate double */
 349 #define jit_cc_a0_arg           0x00000080      /* arg1 is an argument int id */
 350 #define jit_cc_a0_cnd           0x00000100      /* arg1 is a conditinally set register */
 351 #define jit_cc_a1_reg           0x00000200      /* arg1 is a register */
 352 #define jit_cc_a1_chg           0x00000400      /* arg1 is modified */
 353 #define jit_cc_a1_int           0x00000800      /* arg1 is immediate word */
 354 #define jit_cc_a1_flt           0x00001000      /* arg1 is immediate float */
 355 #define jit_cc_a1_dbl           0x00002000      /* arg1 is immediate double */
 356 #define jit_cc_a1_arg           0x00004000      /* arg1 is an argument node */
 357 #define jit_cc_a1_rlh           0x00008000      /* arg1 is a register pair */
 358 #define jit_cc_a2_reg           0x00010000      /* arg2 is a register */
 359 #define jit_cc_a2_chg           0x00020000      /* arg2 is modified */
 360 #define jit_cc_a2_int           0x00100000      /* arg2 is immediate word */
 361 #define jit_cc_a2_flt           0x00200000      /* arg2 is immediate float */
 362 #define jit_cc_a2_dbl           0x00400000      /* arg2 is immediate double */
 363 #define jit_cc_a2_rlh           0x00800000      /* arg2 is a register pair */
 364
 365 #if __ia64__ || (__sparc__ && __WORDSIZE == 64)
 366 extern void
 367 jit_regset_com(jit_regset_t*, jit_regset_t*);
 368
 369 extern void
 370 jit_regset_and(jit_regset_t*, jit_regset_t*, jit_regset_t*);
 371
 372 extern void
 373 jit_regset_ior(jit_regset_t*, jit_regset_t*, jit_regset_t*);
 374
 375 extern void
 376 jit_regset_xor(jit_regset_t*, jit_regset_t*, jit_regset_t*);
 377
 378 extern void
 379 jit_regset_set(jit_regset_t*, jit_regset_t*);
 380
 381 extern void
 382 jit_regset_set_mask(jit_regset_t*, jit_int32_t);
 383
 384 extern jit_bool_t
 385 jit_regset_cmp_ui(jit_regset_t*, jit_word_t);
 386
 387 extern void
 388 jit_regset_set_ui(jit_regset_t*, jit_word_t);
 389
 390 extern jit_bool_t
 391 jit_regset_set_p(jit_regset_t*);
 392
 393 extern void
 394 jit_regset_clrbit(jit_regset_t*, jit_int32_t);
 395
 396 extern void
 397 jit_regset_setbit(jit_regset_t*, jit_int32_t);
 398
 399 extern jit_bool_t
 400 jit_regset_tstbit(jit_regset_t*, jit_int32_t);
 401 #  if __sparc__ && __WORDSIZE == 64
 402 #    define jit_regset_new(set)                                         \
 403     do { (set)->rl = (set)->rh = 0; } while (0)
 404 #    define jit_regset_del(set)                                         \
 405     do { (set)->rl = (set)->rh = 0; } while (0)
 406 #  else
 407 #    define jit_regset_new(set)                                         \
 408     do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
 409 #    define jit_regset_del(set)                                         \
 410     do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
 411 #  endif
 412 #else
 413 #  define jit_regset_com(u, v)          (*(u) = ~*(v))
 414 #  define jit_regset_and(u, v, w)       (*(u) = *(v) & *(w))
 415 #  define jit_regset_ior(u, v, w)       (*(u) = *(v) | *(w))
 416 #  define jit_regset_xor(u, v, w)       (*(u) = *(v) ^ *(w))
 417 #  define jit_regset_set(u, v)          (*(u) = *(v))
 418 #  define jit_regset_set_mask(u, v)     (*(u) = (1LL << (v)) - 1)
 419 #  define jit_regset_cmp_ui(u, v)       (*(u) != (v))
 420 #  define jit_regset_set_ui(u, v)       (*(u) = (v))
 421 #  define jit_regset_set_p(set)         (*set)
 422 #  define jit_regset_clrbit(set, bit)   (*(set) &= ~(1LL << (bit)))
 423 #  define jit_regset_setbit(set, bit)   (*(set) |= 1LL << (bit))
 424 #  define jit_regset_tstbit(set, bit)   (*(set) & (1LL << (bit)))
 425 #  define jit_regset_new(set)           (*(set) = 0)
 426 #  define jit_regset_del(set)           (*(set) = 0)
 427 #endif
 428 extern unsigned long
 429 jit_regset_scan1(jit_regset_t*, jit_int32_t);
 430
 431 #define jit_reglive_setup()                                             \
 432     do {                                                                \
 433         jit_regset_set_ui(&_jitc->reglive, 0);                          \
 434         jit_regset_set_ui(&_jitc->regmask, 0);                          \
 435     } while (0)
 436
 437 /*
 438  * Types
 439  */
 440 typedef union jit_data          jit_data_t;
 441 typedef struct jit_note         jit_note_t;
 442 typedef struct jit_line         jit_line_t;
 443 typedef struct jit_block        jit_block_t;
 444 typedef struct jit_value        jit_value_t;
 445 typedef struct jit_compiler     jit_compiler_t;
 446 typedef struct jit_function     jit_function_t;
 447 typedef struct jit_register     jit_register_t;
 448 #if __arm__
 449 #  if DISASSEMBLER
 450 typedef struct jit_data_info    jit_data_info_t;
 451 #  endif
 452 #elif __riscv
 453 typedef struct jit_const        jit_const_t;
 454 #endif
 455
 456 union jit_data {
 457     struct {
 458 #if __BYTE_ORDER == __LITTLE_ENDIAN
 459         jit_int32_t      l;
 460         jit_int32_t      h;
 461 #else
 462         jit_int32_t      h;
 463         jit_int32_t      l;
 464 #endif
 465     } q;
 466     jit_word_t           w;
 467     jit_float32_t        f;
 468     jit_float64_t        d;
 469     jit_pointer_t        p;
 470     jit_node_t          *n;
 471 };
 472
 473 struct jit_note {
 474     jit_uint8_t         *code;
 475     char                *name;
 476     jit_line_t          *lines;
 477     jit_word_t           length;
 478     jit_word_t           size;          /* of code */
 479 };
 480
 481 struct jit_line {
 482     char                *file;
 483     jit_int32_t         *linenos;
 484     jit_int32_t         *offsets;
 485     jit_word_t           length;
 486 };
 487
 488 struct jit_node {
 489     jit_node_t          *next;
 490     jit_code_t           code;
 491     jit_uint16_t         flag;
 492     jit_uint16_t         offset;        /* Used if DEVEL_DISASSEMBLER */
 493     jit_data_t           u;
 494     jit_data_t           v;
 495     jit_data_t           w;
 496     jit_node_t          *link;
 497 };
 498
 499 struct jit_block {
 500     jit_node_t          *label;
 501     jit_regset_t         reglive;
 502     jit_regset_t         regmask;
 503     jit_bool_t           again;         /* Flag need to rebuild regset masks
 504                                          * due to changes in live and unknown
 505                                          * state. */
 506 };
 507
 508 struct jit_value {
 509     jit_int32_t         kind;
 510     jit_code_t          code;
 511     jit_data_t          base;
 512     jit_data_t          disp;
 513 };
 514
 515 typedef struct {
 516 #if __arm__
 517     jit_word_t           kind;
 518 #endif
 519     jit_word_t           inst;
 520     jit_node_t          *node;
 521 } jit_patch_t;
 522
 523 #if __arm__ && DISASSEMBLER
 524 struct jit_data_info {
 525     jit_uword_t           code;         /* pointer in code buffer */
 526     jit_word_t            length;       /* length of constant vector */
 527 };
 528 #elif __riscv && __WORDSIZE == 64
 529 struct jit_const {
 530     jit_word_t            value;
 531     jit_word_t            address;
 532     jit_const_t          *next;
 533 };
 534 #endif
 535
 536 struct jit_function {
 537     struct {
 538         jit_int32_t      argi;
 539         jit_int32_t      argf;
 540         jit_int32_t      size;
 541         jit_int32_t      aoff;
 542         jit_int32_t      alen;
 543         jit_int32_t      call;
 544         jit_int32_t      argn;          /* for debug output */
 545     } self;
 546     struct {
 547         jit_int32_t      argi;
 548         jit_int32_t      argf;
 549         jit_int32_t      size;
 550         jit_int32_t      call;
 551     } call;
 552     jit_node_t          *prolog;
 553     jit_node_t          *epilog;
 554     jit_node_t          *alist;
 555     jit_int32_t         *regoff;
 556     jit_regset_t         regset;
 557     jit_int32_t          stack;
 558 #if !defined(__arm__)
 559     jit_int32_t          cvt_offset;    /* allocai'd offset for x87<->xmm or
 560                                          * fpr<->gpr transfer using the stack */
 561 #endif
 562
 563     /* Helper for common jit generation pattern, used in GNU Smalltalk
 564      * and possibly others, where a static frame layout is required or
 565      * assumed. */
 566     jit_int32_t          frame;
 567     jit_uint32_t         define_frame : 1;
 568     jit_uint32_t         assume_frame : 1;
 569
 570     jit_uint32_t         need_frame : 1;        /* need frame pointer? */
 571     jit_uint32_t         need_stack : 1;        /* need stack pointer? */
 572     jit_uint32_t         need_return : 1;       /* not a leaf function */
 573
 574     /* alloca offset offset */
 575     jit_int32_t          aoffoff;
 576     /* uses allocar flag */
 577     jit_uint32_t         allocar : 1;
 578
 579 #if __arm__
 580     /* If will, or might use float registers and vfp is not available.
 581      * Use the first 64 bytes always, as the access to the virtual float
 582      * registers use hardcoded instructions that can only reach 64 byte
 583      * displacements, and to keep code simpler, do not use temporaries. */
 584     jit_uint32_t          swf_offset : 1;
 585     /* If need to call C functions for some operation, or variadic function */
 586     jit_uint32_t          save_reg_args : 1;
 587 #endif
 588
 589     /* varargs state offsets */
 590     jit_int32_t          vaoff;         /* offset of jit_va_list */
 591     jit_int32_t          vagp;          /* first gp va argument */
 592     jit_int32_t          vafp;          /* first fp va argument */
 593 };
 594
 595 /* data used only during jit generation */
 596 struct jit_compiler {
 597 #if __ia64__
 598     struct {
 599         jit_uint64_t      i : 41;
 600         jit_uint64_t      t :  4;
 601     } inst[3];
 602     jit_regset_t          regs;         /* changed regs since last stop */
 603     jit_int32_t           pred;         /* changed preds last stop */
 604     jit_int32_t           ioff;         /* offset in inst vector */
 605     jit_int32_t           rout;         /* first output register */
 606     jit_int32_t           breg;         /* base register for prolog/epilog */
 607 #endif
 608 #if __mips__
 609     struct {
 610         jit_int32_t       op;           /* pending instruction, candidate
 611                                          * to be inserted in a delay slot */
 612         jit_bool_t        pend;         /* non zero if need to emit op */
 613     } inst;
 614 #endif
 615 #if __mips__ || __ia64__ || __alpha__ || \
 616         (__sparc__ && __WORDSIZE == 64) || __riscv || __loongarch__
 617     jit_int32_t           carry;
 618 #define jit_carry         _jitc->carry
 619 #endif
 620     jit_node_t           *head;
 621     jit_node_t           *tail;
 622     jit_node_t           *prepare;      /* inside prepare/finish* block */
 623     jit_uint32_t          realize : 1;  /* jit_realize() called? */
 624     jit_uint32_t          dataset : 1;  /* jit_dataset() called? */
 625     jit_uint32_t          done  : 1;    /* emit state finished */
 626     jit_uint32_t          emit  : 1;    /* emit state entered */
 627     jit_uint32_t          again : 1;    /* start over emiting function */
 628     jit_uint32_t          synth : 8;    /* emiting synthesized instructions */
 629 #if DEBUG
 630     jit_uint32_t          getreg : 1;
 631 #endif
 632     jit_uint32_t          no_data : 1;
 633     jit_uint32_t          no_note : 1;
 634     /* FIXME undocumented, might be moved to a jit_cpu field or a better
 635      * configuration api.
 636      * These are switches to a different unld* or unst*.
 637      * Defaults are the algorithms that generate shorter code*/
 638     jit_uint32_t          unld_algorithm : 1;
 639     jit_uint32_t          unst_algorithm : 1;
 640     jit_int32_t           framesize;    /* space for callee save registers,
 641                                          * frame pointer and return address */
 642     jit_int32_t           reglen;       /* number of registers */
 643     jit_regset_t          regarg;       /* cannot allocate */
 644     jit_regset_t          regsav;       /* automatic spill only once */
 645     jit_regset_t          reglive;      /* known live registers at some point */
 646     jit_regset_t          regmask;      /* register mask to update reglive */
 647     jit_regset_t          explive;      /* explicitly marked as live */
 648     struct {
 649         jit_uint8_t      *end;
 650     } code;
 651     struct {
 652         jit_uint8_t      *ptr;
 653         jit_node_t      **table;        /* very simple hash table */
 654         jit_word_t        size;         /* number of vectors in table */
 655         jit_word_t        count;        /* number of hash table entries */
 656         jit_word_t        offset;       /* offset in bytes in ptr */
 657     } data;
 658     jit_node_t          **spill;
 659     jit_int32_t          *gen;          /* ssa like "register version" */
 660     jit_value_t          *values;       /* temporary jit_value_t vector */
 661     struct {
 662         jit_block_t      *ptr;
 663         jit_word_t        offset;
 664         jit_word_t        length;
 665     } blocks;                           /* basic blocks */
 666     struct {
 667         jit_patch_t      *ptr;
 668         jit_word_t        offset;
 669         jit_word_t        length;
 670     } patches;                          /* forward patch information */
 671     jit_function_t       *function;     /* current function */
 672     struct {
 673         jit_function_t   *ptr;
 674         jit_word_t        offset;
 675         jit_word_t        length;
 676     } functions;                        /* prolog/epilogue offsets in code */
 677     struct {
 678         jit_node_t      **ptr;
 679         jit_word_t        offset;
 680         jit_word_t        length;
 681     } pool;
 682     jit_node_t           *list;
 683     struct {
 684         jit_node_t       *head;         /* first note node */
 685         jit_node_t       *tail;         /* linked list insertion */
 686         /* fields to store temporary state information */
 687         jit_word_t        size;
 688         jit_node_t       *name;
 689         jit_node_t       *note;
 690         jit_uint8_t      *base;
 691     } note;
 692 #if __arm__
 693     /* prevent using thumb instructions that set flags? */
 694     jit_uint32_t          no_set_flags : 1;
 695 #  if DISASSEMBLER
 696     struct {
 697         jit_data_info_t  *ptr;
 698         jit_word_t        offset;
 699         jit_word_t        length;
 700     } data_info;                        /* constant pools information */
 701 #  endif
 702     /* Note that this field is somewhat hackish, but required by most
 703      * ways to implement jit, unless implementing a pure one function
 704      * per jit, as most times it needs to start the jit buffer with a
 705      * jump where the "main" prolog starts, and because the initial
 706      * code is in "arm mode", need to make an "arm mode" patch on that
 707      * jump. A good example is the test suite assembler, where most
 708      * test cases start with a "jmpi main" call. */
 709     jit_uword_t           thumb;
 710     struct {
 711         jit_uint8_t      *data;         /* pointer to code */
 712         jit_word_t        size;         /* size data */
 713         jit_word_t        offset;       /* pending patches */
 714         jit_word_t        length;       /* number of pending constants */
 715         jit_int32_t       values[1024]; /* pending constants */
 716         jit_word_t        patches[2048];
 717     } consts;
 718 #elif (__powerpc__ && _CALL_AIXDESC) || __ia64__
 719     /* Keep track of prolog addresses, just for the sake of making
 720      * jit that starts with a jump to a "main" label work like other
 721      * backends. */
 722     struct {
 723         jit_word_t       *ptr;
 724         jit_word_t        offset;
 725         jit_word_t        length;
 726     } prolog;
 727     jit_bool_t            jump;
 728 #elif __riscv && __WORDSIZE == 64
 729     struct {
 730         /* Hash table for constants to be resolved and patched */
 731         struct {
 732             jit_const_t **table;        /* very simple hash table */
 733             jit_word_t    size;         /* number of vectors in table */
 734             jit_word_t    count;        /* number of distinct entries */
 735         } hash;
 736         struct {
 737             jit_const_t **ptr;          /* keep a single pointer */
 738             jit_const_t  *list;         /* free list */
 739             jit_word_t    length;       /* length of pool */
 740         } pool;
 741         /* Linear list for constants that cannot be encoded easily */
 742         struct {
 743             jit_word_t   *instrs;       /* list of direct movi instructions */
 744             jit_word_t   *values;       /* list of direct movi constants */
 745             jit_word_t    offset;       /* offset in instrs/values vector */
 746             jit_word_t    length;       /* length of instrs/values vector */
 747         } vector;
 748     } consts;
 749 #endif
 750 #if GET_JIT_SIZE
 751     /* Temporary storage to calculate instructions length */
 752     jit_word_t            size;
 753     /* Global flag for code buffer heuristic size computation */
 754     jit_word_t            mult;
 755     /* Pointer to code to prevent miscalculation if reallocating buffer */
 756     jit_uint8_t          *cptr;
 757 #endif
 758 };
 759
 760 #define _jitc                           _jit->comp
 761 struct jit_state {
 762     union {
 763         jit_uint8_t      *uc;
 764         jit_uint16_t     *us;
 765         jit_uint32_t     *ui;
 766         jit_uint64_t     *ul;
 767         jit_word_t        w;
 768     } pc;
 769     struct {
 770         jit_uint8_t     *ptr;
 771         jit_word_t       length;
 772         /* PROTECTED bytes starting at PTR are mprotect'd. */
 773         jit_word_t       protect;
 774     } code;
 775     struct {
 776         jit_uint8_t     *ptr;
 777         jit_word_t       length;
 778     } data;
 779     struct {
 780         jit_note_t      *ptr;
 781         jit_word_t       length;
 782     } note;
 783     jit_compiler_t      *comp;
 784     /* Flags to know if user did set the code and data buffers */
 785     jit_uint32_t         user_code      : 1;
 786     jit_uint32_t         user_data      : 1;
 787 };
 788
 789 struct jit_register {
 790     jit_reg_t            spec;
 791     char                *name;
 792 };
 793
 794 /*
 795  * Prototypes
 796  */
 797 extern void jit_get_cpu(void);
 798
 799 #define jit_init()                      _jit_init(_jit)
 800 extern void _jit_init(jit_state_t*);
 801
 802 #define jit_synth_inc()                 _jit_synth_inc(_jit)
 803 extern void _jit_synth_inc(jit_state_t*);
 804
 805 #define jit_new_node_no_link(u)         _jit_new_node_no_link(_jit, u)
 806 extern jit_node_t *_jit_new_node_no_link(jit_state_t*, jit_code_t);
 807
 808 #define jit_link_node(u)                _jit_link_node(_jit, u)
 809 extern void _jit_link_node(jit_state_t*, jit_node_t*);
 810
 811 #define jit_link_label(l)       _jit_link_label(_jit,l)
 812 extern void
 813 _jit_link_label(jit_state_t*,jit_node_t*);
 814
 815 #define jit_synth_dec()                 _jit_synth_dec(_jit)
 816 extern void _jit_synth_dec(jit_state_t*);
 817
 818 #define jit_reglive(node)       _jit_reglive(_jit, node)
 819 extern void
 820 _jit_reglive(jit_state_t*, jit_node_t*);
 821
 822 #define jit_regarg_set(n,v)     _jit_regarg_set(_jit,n,v)
 823 extern void
 824 _jit_regarg_set(jit_state_t*, jit_node_t*, jit_int32_t);
 825
 826 #define jit_regarg_clr(n,v)     _jit_regarg_clr(_jit,n,v)
 827 extern void
 828 _jit_regarg_clr(jit_state_t*, jit_node_t*, jit_int32_t);
 829
 830 #define jit_save(reg)           _jit_save(_jit, reg)
 831 extern void
 832 _jit_save(jit_state_t*, jit_int32_t);
 833
 834 #define jit_load(reg)           _jit_load(_jit, reg)
 835 extern void
 836 _jit_load(jit_state_t*, jit_int32_t);
 837
 838 #define jit_trampoline(u,v)     _jit_trampoline(_jit, u, v)
 839 extern void _jit_trampoline(jit_state_t*, jit_int32_t, jit_bool_t);
 840
 841 #define jit_optimize()          _jit_optimize(_jit)
 842 extern void
 843 _jit_optimize(jit_state_t*);
 844
 845 #define jit_classify(code)      _jit_classify(_jit, code)
 846 extern jit_int32_t
 847 _jit_classify(jit_state_t*, jit_code_t);
 848
 849 #define jit_regarg_p(n, r)      _jit_regarg_p(_jit, n, r)
 850 extern jit_bool_t
 851 _jit_regarg_p(jit_state_t*, jit_node_t*, jit_int32_t);
 852
 853 #define emit_code()             _emit_code(_jit)
 854 extern jit_pointer_t
 855 _emit_code(jit_state_t*);
 856
 857 extern void
 858 jit_flush(void *fptr, void *tptr);
 859
 860 #define emit_ldxi(r0, r1, i0)   _emit_ldxi(_jit, r0, r1, i0)
 861 extern void
 862 _emit_ldxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 863
 864 #define emit_stxi(i0, r0, r1)   _emit_stxi(_jit, i0, r0, r1)
 865 extern void
 866 _emit_stxi(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 867
 868 #define emit_ldxi_d(r0, r1, i0) _emit_ldxi_d(_jit, r0, r1, i0)
 869 extern void
 870 _emit_ldxi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 871
 872 #define emit_stxi_d(i0, r0, r1) _emit_stxi_d(_jit, i0, r0, r1)
 873 extern void
 874 _emit_stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 875
 876 extern void jit_init_print(FILE*);
 877 extern void jit_init_debug(const char*, FILE*);
 878 extern void jit_finish_debug(void);
 879
 880 extern void jit_init_note(void);
 881 extern void jit_finish_note(void);
 882 #define jit_set_note(n,u,v,w)   _jit_set_note(_jit, n, u, v, w)
 883 extern void _jit_set_note(jit_state_t*, jit_note_t*, char*, int, jit_int32_t);
 884 #define jit_annotate()          _jit_annotate(_jit)
 885 extern void _jit_annotate(jit_state_t*);
 886
 887 #define jit_print_node(u)       _jit_print_node(_jit,u)
 888 extern void _jit_print_node(jit_state_t*,jit_node_t*);
 889
 890 extern jit_pointer_t jit_memcpy(jit_pointer_t,const void*,jit_word_t);
 891 extern jit_pointer_t jit_memmove(jit_pointer_t,const void*,jit_word_t);
 892 extern void jit_alloc(jit_pointer_t*, jit_word_t);
 893 extern void jit_realloc(jit_pointer_t*, jit_word_t, jit_word_t);
 894 void jit_free(jit_pointer_t*);
 895
 896 extern void jit_init_size(void);
 897 extern void jit_finish_size(void);
 898
 899 #if GET_JIT_SIZE
 900 #  define jit_size_prepare()            _jit_size_prepare(_jit)
 901 extern void
 902 _jit_size_prepare(jit_state_t*);
 903
 904 #  define jit_size_collect(node)        _jit_size_collect(_jit, node)
 905 extern void
 906 _jit_size_collect(jit_state_t*, jit_node_t*);
 907 #else
 908 #  define jit_get_size()                _jit_get_size(_jit)
 909 extern jit_word_t
 910 _jit_get_size(jit_state_t*);
 911 #endif
 912
 913 extern jit_word_t
 914 jit_get_max_instr(void);
 915
 916 /*
 917  * Externs
 918  */
 919 extern jit_register_t    _rvs[];
 920
 921 #endif /* _jit_private_h */