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