deps/lightning/include/lightning/jit_private.h

   1 /*
   2  * Copyright (C) 2012-2019  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 #endif
 369
 370 union jit_data {
 371     struct {
 372 #if __BYTE_ORDER == __LITTLE_ENDIAN
 373         jit_int32_t      l;
 374         jit_int32_t      h;
 375 #else
 376         jit_int32_t      h;
 377         jit_int32_t      l;
 378 #endif
 379     } q;
 380     jit_word_t           w;
 381     jit_float32_t        f;
 382     jit_float64_t        d;
 383     jit_pointer_t        p;
 384     jit_node_t          *n;
 385 };
 386
 387 struct jit_note {
 388     jit_uint8_t         *code;
 389     char                *name;
 390     jit_line_t          *lines;
 391     jit_word_t           length;
 392     jit_word_t           size;          /* of code */
 393 };
 394
 395 struct jit_line {
 396     char                *file;
 397     jit_int32_t         *linenos;
 398     jit_int32_t         *offsets;
 399     jit_word_t           length;
 400 };
 401
 402 struct jit_node {
 403     jit_node_t          *next;
 404     jit_code_t           code;
 405     jit_uint16_t         flag;
 406     jit_uint16_t         offset;        /* Used if DEVEL_DISASSEMBLER */
 407     jit_data_t           u;
 408     jit_data_t           v;
 409     jit_data_t           w;
 410     jit_node_t          *link;
 411 };
 412
 413 struct jit_block {
 414     jit_node_t          *label;
 415     jit_regset_t         reglive;
 416     jit_regset_t         regmask;
 417 };
 418
 419 struct jit_value {
 420     jit_int32_t         kind;
 421     jit_code_t          code;
 422     jit_data_t          base;
 423     jit_data_t          disp;
 424 };
 425
 426 typedef struct {
 427 #if __arm__
 428     jit_word_t           kind;
 429 #endif
 430     jit_word_t           inst;
 431     jit_node_t          *node;
 432 } jit_patch_t;
 433
 434 #if __arm__ && DISASSEMBLER
 435 struct jit_data_info {
 436     jit_uword_t           code;         /* pointer in code buffer */
 437     jit_word_t            length;       /* length of constant vector */
 438 };
 439 #endif
 440
 441 struct jit_function {
 442     struct {
 443         jit_int32_t      argi;
 444         jit_int32_t      argf;
 445         jit_int32_t      size;
 446         jit_int32_t      aoff;
 447         jit_int32_t      alen;
 448         jit_int32_t      call;
 449         jit_int32_t      argn;          /* for debug output */
 450     } self;
 451     struct {
 452         jit_int32_t      argi;
 453         jit_int32_t      argf;
 454         jit_int32_t      size;
 455         jit_int32_t      call;
 456     } call;
 457     jit_node_t          *prolog;
 458     jit_node_t          *epilog;
 459     jit_int32_t         *regoff;
 460     jit_regset_t         regset;
 461     jit_int32_t          stack;
 462
 463     /* Helper for common jit generation pattern, used in GNU Smalltalk
 464      * and possibly others, where a static frame layout is required or
 465      * assumed. */
 466     jit_int32_t          frame;
 467     jit_uint32_t         define_frame : 1;
 468     jit_uint32_t         assume_frame : 1;
 469
 470     /* alloca offset offset */
 471     jit_int32_t          aoffoff;
 472     /* uses allocar flag */
 473     jit_uint32_t         allocar : 1;
 474
 475     /* varargs state offsets */
 476     jit_int32_t          vaoff;         /* offset of jit_va_list */
 477     jit_int32_t          vagp;          /* first gp va argument */
 478     jit_int32_t          vafp;          /* first fp va argument */
 479 };
 480
 481 /* data used only during jit generation */
 482 struct jit_compiler {
 483 #if __ia64__
 484     struct {
 485         jit_uint64_t      i : 41;
 486         jit_uint64_t      t :  4;
 487     } inst[3];
 488     jit_regset_t          regs;         /* changed regs since last stop */
 489     jit_int32_t           pred;         /* changed preds last stop */
 490     jit_int32_t           ioff;         /* offset in inst vector */
 491     jit_int32_t           rout;         /* first output register */
 492     jit_int32_t           breg;         /* base register for prolog/epilog */
 493 #endif
 494 #if __mips__ || __ia64__ || __alpha__ || \
 495         (__sparc__ && __WORDSIZE == 64) || __riscv
 496     jit_int32_t           carry;
 497 #define jit_carry         _jitc->carry
 498 #endif
 499     jit_node_t           *head;
 500     jit_node_t           *tail;
 501     jit_node_t           *prepare;      /* inside prepare/finish* block */
 502     jit_uint32_t          realize : 1;  /* jit_realize() called? */
 503     jit_uint32_t          dataset : 1;  /* jit_dataset() called? */
 504     jit_uint32_t          done  : 1;    /* emit state finished */
 505     jit_uint32_t          emit  : 1;    /* emit state entered */
 506     jit_uint32_t          again : 1;    /* start over emiting function */
 507     jit_uint32_t          synth : 8;    /* emiting synthesized instructions */
 508 #if DEBUG
 509     jit_uint32_t          getreg : 1;
 510 #endif
 511     jit_uint32_t          no_data : 1;
 512     jit_uint32_t          no_note : 1;
 513     jit_int32_t           reglen;       /* number of registers */
 514     jit_regset_t          regarg;       /* cannot allocate */
 515     jit_regset_t          regsav;       /* automatic spill only once */
 516     jit_regset_t          reglive;      /* known live registers at some point */
 517     jit_regset_t          regmask;      /* register mask to update reglive */
 518     struct {
 519         jit_uint8_t      *end;
 520     } code;
 521     struct {
 522         jit_uint8_t      *ptr;
 523         jit_node_t      **table;        /* very simple hash table */
 524         jit_word_t        size;         /* number of vectors in table */
 525         jit_word_t        count;        /* number of hash table entries */
 526         jit_word_t        offset;       /* offset in bytes in ptr */
 527     } data;
 528     jit_node_t          **spill;
 529     jit_int32_t          *gen;          /* ssa like "register version" */
 530     jit_value_t          *values;       /* temporary jit_value_t vector */
 531     struct {
 532         jit_block_t      *ptr;
 533         jit_word_t        offset;
 534         jit_word_t        length;
 535     } blocks;                           /* basic blocks */
 536     struct {
 537         jit_patch_t      *ptr;
 538         jit_word_t        offset;
 539         jit_word_t        length;
 540     } patches;                          /* forward patch information */
 541     jit_function_t       *function;     /* current function */
 542     struct {
 543         jit_function_t   *ptr;
 544         jit_word_t        offset;
 545         jit_word_t        length;
 546     } functions;                        /* prolog/epilogue offsets in code */
 547     struct {
 548         jit_node_t      **ptr;
 549         jit_word_t        offset;
 550         jit_word_t        length;
 551     } pool;
 552     jit_node_t           *list;
 553     struct {
 554         jit_node_t       *head;         /* first note node */
 555         jit_node_t       *tail;         /* linked list insertion */
 556         /* fields to store temporary state information */
 557         jit_word_t        size;
 558         jit_node_t       *name;
 559         jit_node_t       *note;
 560         jit_uint8_t      *base;
 561     } note;
 562 #if __arm__
 563     /* prevent using thumb instructions that set flags? */
 564     jit_uint32_t          no_set_flags : 1;
 565 #  if DISASSEMBLER
 566     struct {
 567         jit_data_info_t  *ptr;
 568         jit_word_t        offset;
 569         jit_word_t        length;
 570     } data_info;                        /* constant pools information */
 571 #  endif
 572     /* Note that this field is somewhat hackish, but required by most
 573      * ways to implement jit, unless implementing a pure one function
 574      * per jit, as most times it needs to start the jit buffer with a
 575      * jump where the "main" prolog starts, and because the initial
 576      * code is in "arm mode", need to make an "arm mode" patch on that
 577      * jump. A good example is the test suite assembler, where most
 578      * test cases start with a "jmpi main" call. */
 579     jit_uword_t           thumb;
 580     struct {
 581         jit_uint8_t      *data;         /* pointer to code */
 582         jit_word_t        size;         /* size data */
 583         jit_word_t        offset;       /* pending patches */
 584         jit_word_t        length;       /* number of pending constants */
 585         jit_int32_t       values[1024]; /* pending constants */
 586         jit_word_t        patches[2048];
 587     } consts;
 588 #elif (__powerpc__ && _CALL_AIXDESC) || __ia64__
 589     /* Keep track of prolog addresses, just for the sake of making
 590      * jit that starts with a jump to a "main" label work like other
 591      * backends. */
 592     struct {
 593         jit_word_t       *ptr;
 594         jit_word_t        offset;
 595         jit_word_t        length;
 596     } prolog;
 597     jit_bool_t            jump;
 598 #endif
 599 #if GET_JIT_SIZE
 600     /* Temporary storage to calculate instructions length */
 601     jit_word_t            size;
 602     /* Global flag for code buffer heuristic size computation */
 603     jit_word_t            mult;
 604     /* Pointer to code to prevent miscalculation if reallocating buffer */
 605     jit_uint8_t          *cptr;
 606 #endif
 607 };
 608
 609 #define _jitc                           _jit->comp
 610 struct jit_state {
 611     union {
 612         jit_uint8_t      *uc;
 613         jit_uint16_t     *us;
 614         jit_uint32_t     *ui;
 615         jit_uint64_t     *ul;
 616         jit_word_t        w;
 617     } pc;
 618     struct {
 619         jit_uint8_t     *ptr;
 620         jit_word_t       length;
 621     } code;
 622     struct {
 623         jit_uint8_t     *ptr;
 624         jit_word_t       length;
 625     } data;
 626     struct {
 627         jit_note_t      *ptr;
 628         jit_word_t       length;
 629     } note;
 630     jit_compiler_t      *comp;
 631     /* Flags to know if user did set the code and data buffers */
 632     jit_uint32_t         user_code      : 1;
 633     jit_uint32_t         user_data      : 1;
 634 };
 635
 636 struct jit_register {
 637     jit_reg_t            spec;
 638     char                *name;
 639 };
 640
 641 /*
 642  * Prototypes
 643  */
 644 extern void jit_get_cpu(void);
 645
 646 #define jit_init()                      _jit_init(_jit)
 647 extern void _jit_init(jit_state_t*);
 648
 649 #define jit_synth_inc()                 _jit_synth_inc(_jit)
 650 extern void _jit_synth_inc(jit_state_t*);
 651
 652 #define jit_new_node_no_link(u)         _jit_new_node_no_link(_jit, u)
 653 extern jit_node_t *_jit_new_node_no_link(jit_state_t*, jit_code_t);
 654
 655 #define jit_link_node(u)                _jit_link_node(_jit, u)
 656 extern void _jit_link_node(jit_state_t*, jit_node_t*);
 657
 658 #define jit_link_label(l)       _jit_link_label(_jit,l)
 659 extern void
 660 _jit_link_label(jit_state_t*,jit_node_t*);
 661
 662 #define jit_synth_dec()                 _jit_synth_dec(_jit)
 663 extern void _jit_synth_dec(jit_state_t*);
 664
 665 #define jit_reglive(node)       _jit_reglive(_jit, node)
 666 extern void
 667 _jit_reglive(jit_state_t*, jit_node_t*);
 668
 669 #define jit_regarg_set(n,v)     _jit_regarg_set(_jit,n,v)
 670 extern void
 671 _jit_regarg_set(jit_state_t*, jit_node_t*, jit_int32_t);
 672
 673 #define jit_regarg_clr(n,v)     _jit_regarg_clr(_jit,n,v)
 674 extern void
 675 _jit_regarg_clr(jit_state_t*, jit_node_t*, jit_int32_t);
 676
 677 #define jit_save(reg)           _jit_save(_jit, reg)
 678 extern void
 679 _jit_save(jit_state_t*, jit_int32_t);
 680
 681 #define jit_load(reg)           _jit_load(_jit, reg)
 682 extern void
 683 _jit_load(jit_state_t*, jit_int32_t);
 684
 685 #define jit_trampoline(u,v)     _jit_trampoline(_jit, u, v)
 686 extern void _jit_trampoline(jit_state_t*, jit_int32_t, jit_bool_t);
 687
 688 #define jit_optimize()          _jit_optimize(_jit)
 689 extern void
 690 _jit_optimize(jit_state_t*);
 691
 692 #define jit_classify(code)      _jit_classify(_jit, code)
 693 extern jit_int32_t
 694 _jit_classify(jit_state_t*, jit_code_t);
 695
 696 #define jit_regarg_p(n, r)      _jit_regarg_p(_jit, n, r)
 697 extern jit_bool_t
 698 _jit_regarg_p(jit_state_t*, jit_node_t*, jit_int32_t);
 699
 700 #define emit_code()             _emit_code(_jit)
 701 extern jit_pointer_t
 702 _emit_code(jit_state_t*);
 703
 704 extern void
 705 jit_flush(void *fptr, void *tptr);
 706
 707 #define emit_ldxi(r0, r1, i0)   _emit_ldxi(_jit, r0, r1, i0)
 708 extern void
 709 _emit_ldxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 710
 711 #define emit_stxi(i0, r0, r1)   _emit_stxi(_jit, i0, r0, r1)
 712 extern void
 713 _emit_stxi(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 714
 715 #define emit_ldxi_d(r0, r1, i0) _emit_ldxi_d(_jit, r0, r1, i0)
 716 extern void
 717 _emit_ldxi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 718
 719 #define emit_stxi_d(i0, r0, r1) _emit_stxi_d(_jit, i0, r0, r1)
 720 extern void
 721 _emit_stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 722
 723 extern void jit_init_print(void);
 724 extern void jit_init_debug(const char*);
 725 extern void jit_finish_debug(void);
 726
 727 extern void jit_init_note(void);
 728 extern void jit_finish_note(void);
 729 #define jit_set_note(n,u,v,w)   _jit_set_note(_jit, n, u, v, w)
 730 extern void _jit_set_note(jit_state_t*, jit_note_t*, char*, int, jit_int32_t);
 731 #define jit_annotate()          _jit_annotate(_jit)
 732 extern void _jit_annotate(jit_state_t*);
 733
 734 #define jit_print_node(u)       _jit_print_node(_jit,u)
 735 extern void _jit_print_node(jit_state_t*,jit_node_t*);
 736
 737 extern jit_pointer_t jit_memcpy(jit_pointer_t,const void*,jit_word_t);
 738 extern jit_pointer_t jit_memmove(jit_pointer_t,const void*,jit_word_t);
 739 extern void jit_alloc(jit_pointer_t*, jit_word_t);
 740 extern void jit_realloc(jit_pointer_t*, jit_word_t, jit_word_t);
 741 void jit_free(jit_pointer_t*);
 742
 743 extern void jit_init_size(void);
 744 extern void jit_finish_size(void);
 745
 746 #if GET_JIT_SIZE
 747 #  define jit_size_prepare()            _jit_size_prepare(_jit)
 748 extern void
 749 _jit_size_prepare(jit_state_t*);
 750
 751 #  define jit_size_collect(node)        _jit_size_collect(_jit, node)
 752 extern void
 753 _jit_size_collect(jit_state_t*, jit_node_t*);
 754 #else
 755 #  define jit_get_size()                _jit_get_size(_jit)
 756 extern jit_word_t
 757 _jit_get_size(jit_state_t*);
 758 #endif
 759
 760 extern jit_word_t
 761 jit_get_max_instr(void);
 762
 763 /*
 764  * Externs
 765  */
 766 extern jit_register_t    _rvs[];
 767
 768 #endif /* _jit_private_h */