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