deps/lightning/include/lightning/jit_private.h

   1 /*
   2  * Copyright (C) 2012-2022  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 #define rc(value)               jit_class_##value
  59 #define rn(reg)                 (jit_regno(_rvs[jit_regno(reg)].spec))
  60
  61 #if defined(__i386__) || defined(__x86_64__)
  62 #  define JIT_SP                _RSP
  63 #  define JIT_RET               _RAX
  64 #  if __X32
  65 #    define JIT_FRET            _ST0
  66 typedef jit_uint32_t            jit_regset_t;
  67 #  else
  68 #    if __CYGWIN__ || _WIN32
  69 #      define JIT_RA0           _RCX
  70 #    else
  71 #      define JIT_RA0           _RDI
  72 #    endif
  73 #    define JIT_FA0             _XMM0
  74 #    define JIT_FRET            _XMM0
  75 typedef jit_uint64_t            jit_regset_t;
  76 #  endif
  77 #elif defined(__mips__)
  78 #  define JIT_RA0               _A0
  79 #  define JIT_FA0               _F12
  80 #  define JIT_SP                _SP
  81 #  define JIT_RET               _V0
  82 #  define JIT_FRET              _F0
  83 typedef jit_uint64_t            jit_regset_t;
  84 #elif defined(__arm__)
  85 #  define JIT_RA0               _R0
  86 #  define JIT_FA0               _D0
  87 #  define JIT_SP                _R13
  88 #  define JIT_RET               _R0
  89 #  if defined(__ARM_PCS_VFP)
  90 #    define JIT_FRET            _D0
  91 #  else
  92 #    define JIT_FRET            _R0
  93 #  endif
  94 typedef jit_uint64_t            jit_regset_t;
  95 #elif defined(__powerpc__)
  96 #  define JIT_RA0               _R3
  97 #  define JIT_FA0               _F1
  98 #  define JIT_SP                _R1
  99 #  define JIT_RET               _R3
 100 #  define JIT_FRET              _F1
 101 typedef jit_uint64_t            jit_regset_t;
 102 #elif defined(__sparc__)
 103 #  define JIT_SP                _SP
 104 #  define JIT_RET               _I0
 105 #  define JIT_FRET              _F0
 106 #  if __WORDSIZE == 32
 107 typedef jit_uint64_t            jit_regset_t;
 108 #  else
 109 typedef struct {
 110     jit_uint64_t        rl;
 111     jit_uint64_t        rh;
 112 } jit_regset_t;
 113 #  endif
 114 #elif defined(__ia64__)
 115 #  define JIT_SP                _R12
 116 #  define JIT_RET               _R8
 117 #  define JIT_FRET              _F8
 118 typedef struct {
 119     jit_uint64_t        rl;
 120     jit_uint64_t        rh;
 121     jit_uint64_t        fl;
 122     jit_uint64_t        fh;
 123 } jit_regset_t;
 124 #elif defined(__hppa__)
 125 #  define JIT_SP                _R30
 126 #  define JIT_RET               _R28
 127 #  define JIT_FRET              _F4
 128 typedef jit_uint64_t            jit_regset_t;
 129 #elif defined(__aarch64__)
 130 #  define JIT_RA0               _R0
 131 #  define JIT_FA0               _V0
 132 #  define JIT_SP                _SP
 133 #  define JIT_RET               _R0
 134 #  define JIT_FRET              _V0
 135 typedef jit_uint64_t            jit_regset_t;
 136 #elif defined(__s390__) || defined(__s390x__)
 137 #  define JIT_SP                _R15
 138 #  define JIT_RET               _R2
 139 #  define JIT_FRET              _F0
 140 typedef jit_uint32_t            jit_regset_t;
 141 #elif defined(__alpha__)
 142 #  define JIT_SP                _SP
 143 #  define JIT_RET               _V0
 144 #  define JIT_FRET              _F0
 145 typedef jit_uint64_t            jit_regset_t;
 146 #elif defined(__riscv)
 147 #  define JIT_RA0               _A0
 148 #  define JIT_FA0               _FA0
 149 #  define JIT_SP                _SP
 150 #  define JIT_RET               _A0
 151 #  define JIT_FRET              _FA0
 152 typedef jit_uint64_t            jit_regset_t;
 153 #endif
 154
 155 #define jit_data(u,v,w)         _jit_data(_jit,u,v,w)
 156 extern jit_node_t *_jit_data(jit_state_t*, const void*,
 157                              jit_word_t, jit_int32_t);
 158
 159 #define jit_size(vector)        (sizeof(vector) / sizeof((vector)[0]))
 160
 161 #define jit_reg_free_p(regno)                                           \
 162     (!jit_regset_tstbit(&_jitc->reglive, regno) &&                      \
 163      !jit_regset_tstbit(&_jitc->regarg, regno) &&                       \
 164      !jit_regset_tstbit(&_jitc->regsav, regno))
 165
 166 #define jit_reg_free_if_spill_p(regno)                                  \
 167     (!jit_regset_tstbit(&_jitc->regarg, regno) &&                       \
 168      !jit_regset_tstbit(&_jitc->regsav, regno))
 169
 170 #define jit_inc_synth(code)                                             \
 171     do {                                                                \
 172         (void)jit_new_node(jit_code_##code);                            \
 173         jit_synth_inc();                                                \
 174     } while (0)
 175 #define jit_inc_synth_w(code, u)                                        \
 176     do {                                                                \
 177         (void)jit_new_node_w(jit_code_##code, u);                       \
 178         jit_synth_inc();                                                \
 179     } while (0)
 180 #define jit_inc_synth_f(code, u)                                        \
 181     do {                                                                \
 182         (void)jit_new_node_f(jit_code_##code, u);                       \
 183         jit_synth_inc();                                                \
 184     } while (0)
 185 #define jit_inc_synth_d(code, u)                                        \
 186     do {                                                                \
 187         (void)jit_new_node_d(jit_code_##code, u);                       \
 188         jit_synth_inc();                                                \
 189     } while (0)
 190 #define jit_inc_synth_ww(code, u, v)                                    \
 191     do {                                                                \
 192         (void)jit_new_node_ww(jit_code_##code, u, v);                   \
 193         jit_synth_inc();                                                \
 194     } while (0)
 195 #define jit_inc_synth_wp(code, u, v)                                    \
 196     do {                                                                \
 197         (void)jit_new_node_wp(jit_code_##code, u, v);                   \
 198         jit_synth_inc();                                                \
 199     } while (0)
 200 #define jit_inc_synth_fp(code, u, v)                                    \
 201     do {                                                                \
 202         (void)jit_new_node_fp(jit_code_##code, u, v);                   \
 203         jit_synth_inc();                                                \
 204     } while (0)
 205 #define jit_inc_synth_dp(code, u, v)                                    \
 206     do {                                                                \
 207         (void)jit_new_node_dp(jit_code_##code, u, v);                   \
 208         jit_synth_inc();                                                \
 209     } while (0)
 210 #define jit_dec_synth()         jit_synth_dec()
 211
 212 #define jit_link_prolog()                                               \
 213     do {                                                                \
 214         _jitc->tail->link = _jitc->function->prolog->link;              \
 215         _jitc->function->prolog->link = _jitc->tail;                    \
 216     } while (0)
 217 #define jit_link_prepare()                                              \
 218     do {                                                                \
 219         _jitc->tail->link = _jitc->prepare->link;                       \
 220         _jitc->prepare->link = _jitc->tail;                             \
 221     } while (0)
 222 #define jit_link_reverse(where)                                         \
 223     do {                                                                \
 224         jit_node_t      *tmp, *tail = 0;                                \
 225         while (where) {                                                 \
 226             tmp = (where)->link;                                        \
 227             (where)->link = tail;                                       \
 228             tail = where;                                               \
 229             where = tmp;                                                \
 230         }                                                               \
 231         where = tail;                                                   \
 232     } while (0);
 233
 234 /*
 235  * Private jit_class bitmasks
 236  */
 237 #define jit_class_named         0x00400000      /* hit must be the named reg */
 238 #define jit_class_nospill       0x00800000      /* hint to fail if need spill */
 239 #define jit_class_sft           0x01000000      /* not a hardware register */
 240 #define jit_class_rg8           0x04000000      /* x86 8 bits */
 241 #define jit_class_xpr           0x80000000      /* float / vector */
 242 /* Used on sparc64 where %f0-%f31 can be encode for single float
 243  * but %f32 to %f62 only as double precision */
 244 #define jit_class_sng           0x10000000      /* Single precision float */
 245 #define jit_class_dbl           0x20000000      /* Only double precision float */
 246 #define jit_regno_patch         0x00008000      /* this is a register
 247                                                  * returned by a "user" call
 248                                                  * to jit_get_reg() */
 249
 250 #define jit_call_default        0
 251 #define jit_call_varargs        1
 252
 253 #define jit_kind_register       1
 254 #define jit_kind_code           2
 255 #define jit_kind_word           3
 256 #define jit_kind_float32        4
 257 #define jit_kind_float64        5
 258
 259 #define jit_cc_a0_reg           0x00000001      /* arg0 is a register */
 260 #define jit_cc_a0_chg           0x00000002      /* arg0 is modified */
 261 #define jit_cc_a0_jmp           0x00000004      /* arg0 is a jump target */
 262 #define jit_cc_a0_rlh           0x00000008      /* arg0 is a register pair */
 263 #define jit_cc_a0_int           0x00000010      /* arg0 is immediate word */
 264 #define jit_cc_a0_flt           0x00000020      /* arg0 is immediate float */
 265 #define jit_cc_a0_dbl           0x00000040      /* arg0 is immediate double */
 266 #define jit_cc_a0_arg           0x00000080      /* arg1 is an argument int id */
 267 #define jit_cc_a0_cnd           0x00000100      /* arg1 is a conditinally set register */
 268 #define jit_cc_a1_reg           0x00000200      /* arg1 is a register */
 269 #define jit_cc_a1_chg           0x00000400      /* arg1 is modified */
 270 #define jit_cc_a1_int           0x00001000      /* arg1 is immediate word */
 271 #define jit_cc_a1_flt           0x00002000      /* arg1 is immediate float */
 272 #define jit_cc_a1_dbl           0x00004000      /* arg1 is immediate double */
 273 #define jit_cc_a1_arg           0x00008000      /* arg1 is an argument node */
 274 #define jit_cc_a2_reg           0x00010000      /* arg2 is a register */
 275 #define jit_cc_a2_chg           0x00020000      /* arg2 is modified */
 276 #define jit_cc_a2_int           0x00100000      /* arg2 is immediate word */
 277 #define jit_cc_a2_flt           0x00200000      /* arg2 is immediate float */
 278 #define jit_cc_a2_dbl           0x00400000      /* arg2 is immediate double */
 279 #define jit_cc_a2_rlh           0x00800000      /* arg2 is a register pair */
 280
 281 #if __ia64__ || (__sparc__ && __WORDSIZE == 64)
 282 extern void
 283 jit_regset_com(jit_regset_t*, jit_regset_t*);
 284
 285 extern void
 286 jit_regset_and(jit_regset_t*, jit_regset_t*, jit_regset_t*);
 287
 288 extern void
 289 jit_regset_ior(jit_regset_t*, jit_regset_t*, jit_regset_t*);
 290
 291 extern void
 292 jit_regset_xor(jit_regset_t*, jit_regset_t*, jit_regset_t*);
 293
 294 extern void
 295 jit_regset_set(jit_regset_t*, jit_regset_t*);
 296
 297 extern void
 298 jit_regset_set_mask(jit_regset_t*, jit_int32_t);
 299
 300 extern jit_bool_t
 301 jit_regset_cmp_ui(jit_regset_t*, jit_word_t);
 302
 303 extern void
 304 jit_regset_set_ui(jit_regset_t*, jit_word_t);
 305
 306 extern jit_bool_t
 307 jit_regset_set_p(jit_regset_t*);
 308
 309 extern void
 310 jit_regset_clrbit(jit_regset_t*, jit_int32_t);
 311
 312 extern void
 313 jit_regset_setbit(jit_regset_t*, jit_int32_t);
 314
 315 extern jit_bool_t
 316 jit_regset_tstbit(jit_regset_t*, jit_int32_t);
 317 #  if __sparc__ && __WORDSIZE == 64
 318 #    define jit_regset_new(set)                                         \
 319     do { (set)->rl = (set)->rh = 0; } while (0)
 320 #    define jit_regset_del(set)                                         \
 321     do { (set)->rl = (set)->rh = 0; } while (0)
 322 #  else
 323 #    define jit_regset_new(set)                                         \
 324     do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
 325 #    define jit_regset_del(set)                                         \
 326     do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
 327 #  endif
 328 #else
 329 #  define jit_regset_com(u, v)          (*(u) = ~*(v))
 330 #  define jit_regset_and(u, v, w)       (*(u) = *(v) & *(w))
 331 #  define jit_regset_ior(u, v, w)       (*(u) = *(v) | *(w))
 332 #  define jit_regset_xor(u, v, w)       (*(u) = *(v) ^ *(w))
 333 #  define jit_regset_set(u, v)          (*(u) = *(v))
 334 #  define jit_regset_set_mask(u, v)     (*(u) = (1LL << (v)) - 1)
 335 #  define jit_regset_cmp_ui(u, v)       (*(u) != (v))
 336 #  define jit_regset_set_ui(u, v)       (*(u) = (v))
 337 #  define jit_regset_set_p(set)         (*set)
 338 #  define jit_regset_clrbit(set, bit)   (*(set) &= ~(1LL << (bit)))
 339 #  define jit_regset_setbit(set, bit)   (*(set) |= 1LL << (bit))
 340 #  define jit_regset_tstbit(set, bit)   (*(set) & (1LL << (bit)))
 341 #  define jit_regset_new(set)           (*(set) = 0)
 342 #  define jit_regset_del(set)           (*(set) = 0)
 343 #endif
 344 extern unsigned long
 345 jit_regset_scan1(jit_regset_t*, jit_int32_t);
 346
 347 #define jit_reglive_setup()                                             \
 348     do {                                                                \
 349         jit_regset_set_ui(&_jitc->reglive, 0);                          \
 350         jit_regset_set_ui(&_jitc->regmask, 0);                          \
 351     } while (0)
 352
 353 /*
 354  * Types
 355  */
 356 typedef union jit_data          jit_data_t;
 357 typedef struct jit_note         jit_note_t;
 358 typedef struct jit_line         jit_line_t;
 359 typedef struct jit_block        jit_block_t;
 360 typedef struct jit_value        jit_value_t;
 361 typedef struct jit_compiler     jit_compiler_t;
 362 typedef struct jit_function     jit_function_t;
 363 typedef struct jit_register     jit_register_t;
 364 #if __arm__
 365 #  if DISASSEMBLER
 366 typedef struct jit_data_info    jit_data_info_t;
 367 #  endif
 368 #elif __riscv
 369 typedef struct jit_const        jit_const_t;
 370 #endif
 371
 372 union jit_data {
 373     struct {
 374 #if __BYTE_ORDER == __LITTLE_ENDIAN
 375         jit_int32_t      l;
 376         jit_int32_t      h;
 377 #else
 378         jit_int32_t      h;
 379         jit_int32_t      l;
 380 #endif
 381     } q;
 382     jit_word_t           w;
 383     jit_float32_t        f;
 384     jit_float64_t        d;
 385     jit_pointer_t        p;
 386     jit_node_t          *n;
 387 };
 388
 389 struct jit_note {
 390     jit_uint8_t         *code;
 391     char                *name;
 392     jit_line_t          *lines;
 393     jit_word_t           length;
 394     jit_word_t           size;          /* of code */
 395 };
 396
 397 struct jit_line {
 398     char                *file;
 399     jit_int32_t         *linenos;
 400     jit_int32_t         *offsets;
 401     jit_word_t           length;
 402 };
 403
 404 struct jit_node {
 405     jit_node_t          *next;
 406     jit_code_t           code;
 407     jit_uint16_t         flag;
 408     jit_uint16_t         offset;        /* Used if DEVEL_DISASSEMBLER */
 409     jit_data_t           u;
 410     jit_data_t           v;
 411     jit_data_t           w;
 412     jit_node_t          *link;
 413 };
 414
 415 struct jit_block {
 416     jit_node_t          *label;
 417     jit_regset_t         reglive;
 418     jit_regset_t         regmask;
 419     jit_bool_t           again;         /* Flag need to rebuild regset masks
 420                                          * due to changes in live and unknown
 421                                          * state. */
 422 };
 423
 424 struct jit_value {
 425     jit_int32_t         kind;
 426     jit_code_t          code;
 427     jit_data_t          base;
 428     jit_data_t          disp;
 429 };
 430
 431 typedef struct {
 432 #if __arm__
 433     jit_word_t           kind;
 434 #endif
 435     jit_word_t           inst;
 436     jit_node_t          *node;
 437 } jit_patch_t;
 438
 439 #if __arm__ && DISASSEMBLER
 440 struct jit_data_info {
 441     jit_uword_t           code;         /* pointer in code buffer */
 442     jit_word_t            length;       /* length of constant vector */
 443 };
 444 #elif __riscv && __WORDSIZE == 64
 445 struct jit_const {
 446     jit_word_t            value;
 447     jit_word_t            address;
 448     jit_const_t          *next;
 449 };
 450 #endif
 451
 452 struct jit_function {
 453     struct {
 454         jit_int32_t      argi;
 455         jit_int32_t      argf;
 456         jit_int32_t      size;
 457         jit_int32_t      aoff;
 458         jit_int32_t      alen;
 459         jit_int32_t      call;
 460         jit_int32_t      argn;          /* for debug output */
 461     } self;
 462     struct {
 463         jit_int32_t      argi;
 464         jit_int32_t      argf;
 465         jit_int32_t      size;
 466         jit_int32_t      call;
 467     } call;
 468     jit_node_t          *prolog;
 469     jit_node_t          *epilog;
 470     jit_int32_t         *regoff;
 471     jit_regset_t         regset;
 472     jit_int32_t          stack;
 473
 474     /* Helper for common jit generation pattern, used in GNU Smalltalk
 475      * and possibly others, where a static frame layout is required or
 476      * assumed. */
 477     jit_int32_t          frame;
 478     jit_uint32_t         define_frame : 1;
 479     jit_uint32_t         assume_frame : 1;
 480
 481     /* alloca offset offset */
 482     jit_int32_t          aoffoff;
 483     /* uses allocar flag */
 484     jit_uint32_t         allocar : 1;
 485
 486     /* varargs state offsets */
 487     jit_int32_t          vaoff;         /* offset of jit_va_list */
 488     jit_int32_t          vagp;          /* first gp va argument */
 489     jit_int32_t          vafp;          /* first fp va argument */
 490 };
 491
 492 /* data used only during jit generation */
 493 struct jit_compiler {
 494 #if __ia64__
 495     struct {
 496         jit_uint64_t      i : 41;
 497         jit_uint64_t      t :  4;
 498     } inst[3];
 499     jit_regset_t          regs;         /* changed regs since last stop */
 500     jit_int32_t           pred;         /* changed preds last stop */
 501     jit_int32_t           ioff;         /* offset in inst vector */
 502     jit_int32_t           rout;         /* first output register */
 503     jit_int32_t           breg;         /* base register for prolog/epilog */
 504 #endif
 505 #if __mips__ || __ia64__ || __alpha__ || \
 506         (__sparc__ && __WORDSIZE == 64) || __riscv
 507     jit_int32_t           carry;
 508 #define jit_carry         _jitc->carry
 509 #endif
 510     jit_node_t           *head;
 511     jit_node_t           *tail;
 512     jit_node_t           *prepare;      /* inside prepare/finish* block */
 513     jit_uint32_t          realize : 1;  /* jit_realize() called? */
 514     jit_uint32_t          dataset : 1;  /* jit_dataset() called? */
 515     jit_uint32_t          done  : 1;    /* emit state finished */
 516     jit_uint32_t          emit  : 1;    /* emit state entered */
 517     jit_uint32_t          again : 1;    /* start over emiting function */
 518     jit_uint32_t          synth : 8;    /* emiting synthesized instructions */
 519 #if DEBUG
 520     jit_uint32_t          getreg : 1;
 521 #endif
 522     jit_uint32_t          no_data : 1;
 523     jit_uint32_t          no_note : 1;
 524     jit_int32_t           reglen;       /* number of registers */
 525     jit_regset_t          regarg;       /* cannot allocate */
 526     jit_regset_t          regsav;       /* automatic spill only once */
 527     jit_regset_t          reglive;      /* known live registers at some point */
 528     jit_regset_t          regmask;      /* register mask to update reglive */
 529     struct {
 530         jit_uint8_t      *end;
 531     } code;
 532     struct {
 533         jit_uint8_t      *ptr;
 534         jit_node_t      **table;        /* very simple hash table */
 535         jit_word_t        size;         /* number of vectors in table */
 536         jit_word_t        count;        /* number of hash table entries */
 537         jit_word_t        offset;       /* offset in bytes in ptr */
 538     } data;
 539     jit_node_t          **spill;
 540     jit_int32_t          *gen;          /* ssa like "register version" */
 541     jit_value_t          *values;       /* temporary jit_value_t vector */
 542     struct {
 543         jit_block_t      *ptr;
 544         jit_word_t        offset;
 545         jit_word_t        length;
 546     } blocks;                           /* basic blocks */
 547     struct {
 548         jit_patch_t      *ptr;
 549         jit_word_t        offset;
 550         jit_word_t        length;
 551     } patches;                          /* forward patch information */
 552     jit_function_t       *function;     /* current function */
 553     struct {
 554         jit_function_t   *ptr;
 555         jit_word_t        offset;
 556         jit_word_t        length;
 557     } functions;                        /* prolog/epilogue offsets in code */
 558     struct {
 559         jit_node_t      **ptr;
 560         jit_word_t        offset;
 561         jit_word_t        length;
 562     } pool;
 563     jit_node_t           *list;
 564     struct {
 565         jit_node_t       *head;         /* first note node */
 566         jit_node_t       *tail;         /* linked list insertion */
 567         /* fields to store temporary state information */
 568         jit_word_t        size;
 569         jit_node_t       *name;
 570         jit_node_t       *note;
 571         jit_uint8_t      *base;
 572     } note;
 573 #if __arm__
 574     /* prevent using thumb instructions that set flags? */
 575     jit_uint32_t          no_set_flags : 1;
 576 #  if DISASSEMBLER
 577     struct {
 578         jit_data_info_t  *ptr;
 579         jit_word_t        offset;
 580         jit_word_t        length;
 581     } data_info;                        /* constant pools information */
 582 #  endif
 583     /* Note that this field is somewhat hackish, but required by most
 584      * ways to implement jit, unless implementing a pure one function
 585      * per jit, as most times it needs to start the jit buffer with a
 586      * jump where the "main" prolog starts, and because the initial
 587      * code is in "arm mode", need to make an "arm mode" patch on that
 588      * jump. A good example is the test suite assembler, where most
 589      * test cases start with a "jmpi main" call. */
 590     jit_uword_t           thumb;
 591     struct {
 592         jit_uint8_t      *data;         /* pointer to code */
 593         jit_word_t        size;         /* size data */
 594         jit_word_t        offset;       /* pending patches */
 595         jit_word_t        length;       /* number of pending constants */
 596         jit_int32_t       values[1024]; /* pending constants */
 597         jit_word_t        patches[2048];
 598     } consts;
 599 #elif (__powerpc__ && _CALL_AIXDESC) || __ia64__
 600     /* Keep track of prolog addresses, just for the sake of making
 601      * jit that starts with a jump to a "main" label work like other
 602      * backends. */
 603     struct {
 604         jit_word_t       *ptr;
 605         jit_word_t        offset;
 606         jit_word_t        length;
 607     } prolog;
 608     jit_bool_t            jump;
 609 #elif __riscv && __WORDSIZE == 64
 610     struct {
 611         /* Hash table for constants to be resolved and patched */
 612         struct {
 613             jit_const_t **table;        /* very simple hash table */
 614             jit_word_t    size;         /* number of vectors in table */
 615             jit_word_t    count;        /* number of distinct entries */
 616         } hash;
 617         struct {
 618             jit_const_t **ptr;          /* keep a single pointer */
 619             jit_const_t  *list;         /* free list */
 620             jit_word_t    length;       /* length of pool */
 621         } pool;
 622         /* Linear list for constants that cannot be encoded easily */
 623         struct {
 624             jit_word_t   *instrs;       /* list of direct movi instructions */
 625             jit_word_t   *values;       /* list of direct movi constants */
 626             jit_word_t    offset;       /* offset in instrs/values vector */
 627             jit_word_t    length;       /* length of instrs/values vector */
 628         } vector;
 629     } consts;
 630 #endif
 631 #if GET_JIT_SIZE
 632     /* Temporary storage to calculate instructions length */
 633     jit_word_t            size;
 634     /* Global flag for code buffer heuristic size computation */
 635     jit_word_t            mult;
 636     /* Pointer to code to prevent miscalculation if reallocating buffer */
 637     jit_uint8_t          *cptr;
 638 #endif
 639 };
 640
 641 #define _jitc                           _jit->comp
 642 struct jit_state {
 643     union {
 644         jit_uint8_t      *uc;
 645         jit_uint16_t     *us;
 646         jit_uint32_t     *ui;
 647         jit_uint64_t     *ul;
 648         jit_word_t        w;
 649     } pc;
 650     struct {
 651         jit_uint8_t     *ptr;
 652         jit_word_t       length;
 653     } code;
 654     struct {
 655         jit_uint8_t     *ptr;
 656         jit_word_t       length;
 657     } data;
 658     struct {
 659         jit_note_t      *ptr;
 660         jit_word_t       length;
 661     } note;
 662     jit_compiler_t      *comp;
 663     /* Flags to know if user did set the code and data buffers */
 664     jit_uint32_t         user_code      : 1;
 665     jit_uint32_t         user_data      : 1;
 666 };
 667
 668 struct jit_register {
 669     jit_reg_t            spec;
 670     char                *name;
 671 };
 672
 673 /*
 674  * Prototypes
 675  */
 676 extern void jit_get_cpu(void);
 677
 678 #define jit_init()                      _jit_init(_jit)
 679 extern void _jit_init(jit_state_t*);
 680
 681 #define jit_synth_inc()                 _jit_synth_inc(_jit)
 682 extern void _jit_synth_inc(jit_state_t*);
 683
 684 #define jit_new_node_no_link(u)         _jit_new_node_no_link(_jit, u)
 685 extern jit_node_t *_jit_new_node_no_link(jit_state_t*, jit_code_t);
 686
 687 #define jit_link_node(u)                _jit_link_node(_jit, u)
 688 extern void _jit_link_node(jit_state_t*, jit_node_t*);
 689
 690 #define jit_link_label(l)       _jit_link_label(_jit,l)
 691 extern void
 692 _jit_link_label(jit_state_t*,jit_node_t*);
 693
 694 #define jit_synth_dec()                 _jit_synth_dec(_jit)
 695 extern void _jit_synth_dec(jit_state_t*);
 696
 697 #define jit_reglive(node)       _jit_reglive(_jit, node)
 698 extern void
 699 _jit_reglive(jit_state_t*, jit_node_t*);
 700
 701 #define jit_regarg_set(n,v)     _jit_regarg_set(_jit,n,v)
 702 extern void
 703 _jit_regarg_set(jit_state_t*, jit_node_t*, jit_int32_t);
 704
 705 #define jit_regarg_clr(n,v)     _jit_regarg_clr(_jit,n,v)
 706 extern void
 707 _jit_regarg_clr(jit_state_t*, jit_node_t*, jit_int32_t);
 708
 709 #define jit_save(reg)           _jit_save(_jit, reg)
 710 extern void
 711 _jit_save(jit_state_t*, jit_int32_t);
 712
 713 #define jit_load(reg)           _jit_load(_jit, reg)
 714 extern void
 715 _jit_load(jit_state_t*, jit_int32_t);
 716
 717 #define jit_trampoline(u,v)     _jit_trampoline(_jit, u, v)
 718 extern void _jit_trampoline(jit_state_t*, jit_int32_t, jit_bool_t);
 719
 720 #define jit_optimize()          _jit_optimize(_jit)
 721 extern void
 722 _jit_optimize(jit_state_t*);
 723
 724 #define jit_classify(code)      _jit_classify(_jit, code)
 725 extern jit_int32_t
 726 _jit_classify(jit_state_t*, jit_code_t);
 727
 728 #define jit_regarg_p(n, r)      _jit_regarg_p(_jit, n, r)
 729 extern jit_bool_t
 730 _jit_regarg_p(jit_state_t*, jit_node_t*, jit_int32_t);
 731
 732 #define emit_code()             _emit_code(_jit)
 733 extern jit_pointer_t
 734 _emit_code(jit_state_t*);
 735
 736 extern void
 737 jit_flush(void *fptr, void *tptr);
 738
 739 #define emit_ldxi(r0, r1, i0)   _emit_ldxi(_jit, r0, r1, i0)
 740 extern void
 741 _emit_ldxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 742
 743 #define emit_stxi(i0, r0, r1)   _emit_stxi(_jit, i0, r0, r1)
 744 extern void
 745 _emit_stxi(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 746
 747 #define emit_ldxi_d(r0, r1, i0) _emit_ldxi_d(_jit, r0, r1, i0)
 748 extern void
 749 _emit_ldxi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 750
 751 #define emit_stxi_d(i0, r0, r1) _emit_stxi_d(_jit, i0, r0, r1)
 752 extern void
 753 _emit_stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 754
 755 extern void jit_init_print(void);
 756 extern void jit_init_debug(const char*);
 757 extern void jit_finish_debug(void);
 758
 759 extern void jit_init_note(void);
 760 extern void jit_finish_note(void);
 761 #define jit_set_note(n,u,v,w)   _jit_set_note(_jit, n, u, v, w)
 762 extern void _jit_set_note(jit_state_t*, jit_note_t*, char*, int, jit_int32_t);
 763 #define jit_annotate()          _jit_annotate(_jit)
 764 extern void _jit_annotate(jit_state_t*);
 765
 766 #define jit_print_node(u)       _jit_print_node(_jit,u)
 767 extern void _jit_print_node(jit_state_t*,jit_node_t*);
 768
 769 extern jit_pointer_t jit_memcpy(jit_pointer_t,const void*,jit_word_t);
 770 extern jit_pointer_t jit_memmove(jit_pointer_t,const void*,jit_word_t);
 771 extern void jit_alloc(jit_pointer_t*, jit_word_t);
 772 extern void jit_realloc(jit_pointer_t*, jit_word_t, jit_word_t);
 773 void jit_free(jit_pointer_t*);
 774
 775 extern void jit_init_size(void);
 776 extern void jit_finish_size(void);
 777
 778 #if GET_JIT_SIZE
 779 #  define jit_size_prepare()            _jit_size_prepare(_jit)
 780 extern void
 781 _jit_size_prepare(jit_state_t*);
 782
 783 #  define jit_size_collect(node)        _jit_size_collect(_jit, node)
 784 extern void
 785 _jit_size_collect(jit_state_t*, jit_node_t*);
 786 #else
 787 #  define jit_get_size()                _jit_get_size(_jit)
 788 extern jit_word_t
 789 _jit_get_size(jit_state_t*);
 790 #endif
 791
 792 extern jit_word_t
 793 jit_get_max_instr(void);
 794
 795 /*
 796  * Externs
 797  */
 798 extern jit_register_t    _rvs[];
 799
 800 #endif /* _jit_private_h */