2 * Copyright (C) 2012-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
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)
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.
17 * Paulo Cesar Pereira de Andrade
20 #ifndef _jit_private_h
21 #define _jit_private_h
34 # if !defined(offsetof)
35 # define offsetof(type, field) ((char *)&((type *)0)->field - (char *)0)
40 # define maybe_unused __attribute__ ((unused))
41 # define unlikely(exprn) __builtin_expect(!!(exprn), 0)
42 # define likely(exprn) __builtin_expect(!!(exprn), 1)
44 # define PUBLIC __attribute__ ((visibility("default")))
45 # define HIDDEN __attribute__ ((visibility("hidden")))
51 # define maybe_unused /**/
52 # define unlikely(exprn) exprn
53 # define likely(exprn) exprn
58 #if PACKED_STACK || STRONG_TYPE_CHECKING
59 # define assert_arg_type(code, expect) \
60 do assert((code) == (expect)); while (0)
61 # define assert_putarg_type(code, expect) \
63 assert((((code) - jit_code_putargr_c) >> 2) == \
64 ((expect) - jit_code_arg_c)); \
67 # define assert_arg_type(code, expect) \
68 do assert((int)(code) == (int)(expect) || \
69 (code) == jit_code_arg); while (0)
70 # define assert_putarg_type(code, expect) \
72 assert(((((code) - jit_code_putargr_c) >> 2) == \
73 ((expect) - jit_code_arg_c)) || \
74 ((code) == jit_code_arg)); \
78 #define rc(value) jit_class_##value
79 #define rn(reg) (jit_regno(_rvs[jit_regno(reg)].spec))
81 #if defined(__i386__) || defined(__x86_64__)
85 # define JIT_FRET _ST0
86 typedef jit_uint32_t jit_regset_t;
88 # if __CYGWIN__ || _WIN32
93 # define JIT_FA0 _XMM0
94 # define JIT_FRET _XMM0
95 typedef jit_uint64_t jit_regset_t;
97 #elif defined(__mips__)
102 # define JIT_FRET _F0
103 typedef jit_uint64_t jit_regset_t;
104 #elif defined(__arm__)
109 # if defined(__ARM_PCS_VFP)
110 # define JIT_FRET _D0
112 # define JIT_FRET _R0
114 typedef jit_uint64_t jit_regset_t;
115 #elif defined(__powerpc__)
120 # define JIT_FRET _F1
121 typedef jit_uint64_t jit_regset_t;
122 #elif defined(__sparc__)
125 # define JIT_FRET _F0
126 # if __WORDSIZE == 32
127 typedef jit_uint64_t jit_regset_t;
134 #elif defined(__ia64__)
137 # define JIT_FRET _F8
144 #elif defined(__hppa__)
146 # define JIT_RET _R28
147 # define JIT_FRET _F4
148 typedef jit_uint64_t jit_regset_t;
149 #elif defined(__aarch64__)
154 # define JIT_FRET _V0
155 typedef jit_uint64_t jit_regset_t;
156 #elif defined(__s390__) || defined(__s390x__)
159 # define JIT_FRET _F0
160 typedef jit_uint32_t jit_regset_t;
161 #elif defined(__alpha__)
164 # define JIT_FRET _F0
165 typedef jit_uint64_t jit_regset_t;
166 #elif defined(__riscv)
168 # define JIT_FA0 _FA0
171 # define JIT_FRET _FA0
172 typedef jit_uint64_t jit_regset_t;
173 #elif defined(__loongarch__)
175 # define JIT_FA0 _FA0
178 # define JIT_FRET _FA0
179 typedef jit_uint64_t jit_regset_t;
182 #define jit_data(u,v,w) _jit_data(_jit,u,v,w)
183 extern jit_node_t *_jit_data(jit_state_t*, const void*,
184 jit_word_t, jit_int32_t);
186 #define jit_size(vector) (sizeof(vector) / sizeof((vector)[0]))
188 #define jit_reg_free_p(regno) \
189 (!jit_regset_tstbit(&_jitc->reglive, regno) && \
190 !jit_regset_tstbit(&_jitc->regarg, regno) && \
191 !jit_regset_tstbit(&_jitc->regsav, regno))
193 #define jit_reg_free_if_spill_p(regno) \
194 (!jit_regset_tstbit(&_jitc->regarg, regno) && \
195 !jit_regset_tstbit(&_jitc->regsav, regno))
197 #define jit_code_inc_synth(code) \
199 (void)jit_new_node(code); \
202 #define jit_inc_synth(name) \
203 jit_code_inc_synth(jit_code_##name)
204 #define jit_code_inc_synth_w(code, u) \
206 (void)jit_new_node_w(code, u); \
209 #define jit_inc_synth_w(name, u) \
210 jit_code_inc_synth_w(jit_code_##name, u)
211 #define jit_code_inc_synth_f(code, u) \
213 (void)jit_new_node_f(code, u); \
216 #define jit_inc_synth_f(name, u) \
217 jit_code_inc_synth_f(jit_code_##name, u)
218 #define jit_code_inc_synth_d(code, u) \
220 (void)jit_new_node_d(code, u); \
223 #define jit_inc_synth_d(name, u) \
224 jit_code_inc_synth_d(jit_code_##name, u)
225 #define jit_code_inc_synth_ww(code, u, v) \
227 (void)jit_new_node_ww(code, u, v); \
230 #define jit_inc_synth_ww(name, u, v) \
231 jit_code_inc_synth_ww(jit_code_##name, u, v)
232 #define jit_code_inc_synth_wp(code, u, v) \
234 (void)jit_new_node_wp(code, u, v); \
237 #define jit_inc_synth_wp(name, u, v) \
238 jit_code_inc_synth_wp(jit_code_##name, u, v)
239 #define jit_code_inc_synth_fp(code, u, v) \
241 (void)jit_new_node_fp(code, u, v); \
244 #define jit_inc_synth_fp(name, u, v) \
245 jit_code_inc_synth_fp(jit_code_##name, u, v)
246 #define jit_code_inc_synth_dp(code, u, v) \
248 (void)jit_new_node_dp(code, u, v); \
251 #define jit_inc_synth_dp(name, u, v) \
252 jit_code_inc_synth_dp(jit_code_##name, u, v)
253 #define jit_inc_synth_wf(name, u, v) \
254 jit_code_inc_synth_wf(jit_code_##name, u, v)
255 #define jit_code_inc_synth_wf(code, u, v) \
257 (void)jit_new_node_wf(code, u, v); \
260 #define jit_inc_synth_wqf(name, u, v, w, x) \
262 (void)jit_new_node_wqf(jit_code_##name, u, v, w, x); \
265 #define jit_inc_synth_wd(name, u, v) \
266 jit_code_inc_synth_wd(jit_code_##name, u, v)
267 #define jit_inc_synth_wqd(name, u, v, w, x) \
269 (void)jit_new_node_wqd(jit_code_##name, u, v, w, x); \
272 #define jit_code_inc_synth_wd(code, u, v) \
274 (void)jit_new_node_wd(code, u, v); \
277 #define jit_dec_synth() jit_synth_dec()
279 #define jit_link_alist(node) \
281 node->link = _jitc->function->alist; \
282 _jitc->function->alist = node; \
284 #define jit_check_frame() \
286 if (!_jitc->function->need_frame) { \
288 _jitc->function->need_frame = 1; \
291 #define jit_diffsize() (stack_framesize - _jitc->framesize)
292 #define jit_framesize() (stack_framesize - jit_diffsize())
293 #define jit_selfsize() (_jitc->function->self.size - jit_diffsize())
295 #define jit_link_prolog() \
297 _jitc->tail->link = _jitc->function->prolog->link; \
298 _jitc->function->prolog->link = _jitc->tail; \
300 #define jit_link_prepare() \
302 _jitc->tail->link = _jitc->prepare->link; \
303 _jitc->prepare->link = _jitc->tail; \
305 #define jit_link_reverse(where) \
307 jit_node_t *tmp, *tail = 0; \
309 tmp = (where)->link; \
310 (where)->link = tail; \
318 * Private jit_class bitmasks
320 #define jit_class_named 0x00400000 /* hit must be the named reg */
321 #define jit_class_nospill 0x00800000 /* hint to fail if need spill */
322 #define jit_class_sft 0x01000000 /* not a hardware register */
323 #define jit_class_rg8 0x04000000 /* x86 8 bits */
324 #define jit_class_xpr 0x80000000 /* float / vector */
325 /* Used on sparc64 where %f0-%f31 can be encode for single float
326 * but %f32 to %f62 only as double precision */
327 #define jit_class_sng 0x00010000 /* Single precision float */
328 #define jit_class_dbl 0x00020000 /* Only double precision float */
329 #define jit_regno_patch 0x00008000 /* this is a register
330 * returned by a "user" call
331 * to jit_get_reg() */
333 #define jit_call_default 0
334 #define jit_call_varargs 1
336 #define jit_kind_register 1
337 #define jit_kind_code 2
338 #define jit_kind_word 3
339 #define jit_kind_float32 4
340 #define jit_kind_float64 5
342 #define jit_cc_a0_reg 0x00000001 /* arg0 is a register */
343 #define jit_cc_a0_chg 0x00000002 /* arg0 is modified */
344 #define jit_cc_a0_jmp 0x00000004 /* arg0 is a jump target */
345 #define jit_cc_a0_rlh 0x00000008 /* arg0 is a register pair */
346 #define jit_cc_a0_int 0x00000010 /* arg0 is immediate word */
347 #define jit_cc_a0_flt 0x00000020 /* arg0 is immediate float */
348 #define jit_cc_a0_dbl 0x00000040 /* arg0 is immediate double */
349 #define jit_cc_a0_arg 0x00000080 /* arg1 is an argument int id */
350 #define jit_cc_a0_cnd 0x00000100 /* arg1 is a conditinally set register */
351 #define jit_cc_a1_reg 0x00000200 /* arg1 is a register */
352 #define jit_cc_a1_chg 0x00000400 /* arg1 is modified */
353 #define jit_cc_a1_int 0x00000800 /* arg1 is immediate word */
354 #define jit_cc_a1_flt 0x00001000 /* arg1 is immediate float */
355 #define jit_cc_a1_dbl 0x00002000 /* arg1 is immediate double */
356 #define jit_cc_a1_arg 0x00004000 /* arg1 is an argument node */
357 #define jit_cc_a1_rlh 0x00008000 /* arg1 is a register pair */
358 #define jit_cc_a2_reg 0x00010000 /* arg2 is a register */
359 #define jit_cc_a2_chg 0x00020000 /* arg2 is modified */
360 #define jit_cc_a2_int 0x00100000 /* arg2 is immediate word */
361 #define jit_cc_a2_flt 0x00200000 /* arg2 is immediate float */
362 #define jit_cc_a2_dbl 0x00400000 /* arg2 is immediate double */
363 #define jit_cc_a2_rlh 0x00800000 /* arg2 is a register pair */
365 #if __ia64__ || (__sparc__ && __WORDSIZE == 64)
367 jit_regset_com(jit_regset_t*, jit_regset_t*);
370 jit_regset_and(jit_regset_t*, jit_regset_t*, jit_regset_t*);
373 jit_regset_ior(jit_regset_t*, jit_regset_t*, jit_regset_t*);
376 jit_regset_xor(jit_regset_t*, jit_regset_t*, jit_regset_t*);
379 jit_regset_set(jit_regset_t*, jit_regset_t*);
382 jit_regset_set_mask(jit_regset_t*, jit_int32_t);
385 jit_regset_cmp_ui(jit_regset_t*, jit_word_t);
388 jit_regset_set_ui(jit_regset_t*, jit_word_t);
391 jit_regset_set_p(jit_regset_t*);
394 jit_regset_clrbit(jit_regset_t*, jit_int32_t);
397 jit_regset_setbit(jit_regset_t*, jit_int32_t);
400 jit_regset_tstbit(jit_regset_t*, jit_int32_t);
401 # if __sparc__ && __WORDSIZE == 64
402 # define jit_regset_new(set) \
403 do { (set)->rl = (set)->rh = 0; } while (0)
404 # define jit_regset_del(set) \
405 do { (set)->rl = (set)->rh = 0; } while (0)
407 # define jit_regset_new(set) \
408 do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
409 # define jit_regset_del(set) \
410 do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
413 # define jit_regset_com(u, v) (*(u) = ~*(v))
414 # define jit_regset_and(u, v, w) (*(u) = *(v) & *(w))
415 # define jit_regset_ior(u, v, w) (*(u) = *(v) | *(w))
416 # define jit_regset_xor(u, v, w) (*(u) = *(v) ^ *(w))
417 # define jit_regset_set(u, v) (*(u) = *(v))
418 # define jit_regset_set_mask(u, v) (*(u) = (1LL << (v)) - 1)
419 # define jit_regset_cmp_ui(u, v) (*(u) != (v))
420 # define jit_regset_set_ui(u, v) (*(u) = (v))
421 # define jit_regset_set_p(set) (*set)
422 # define jit_regset_clrbit(set, bit) (*(set) &= ~(1LL << (bit)))
423 # define jit_regset_setbit(set, bit) (*(set) |= 1LL << (bit))
424 # define jit_regset_tstbit(set, bit) (*(set) & (1LL << (bit)))
425 # define jit_regset_new(set) (*(set) = 0)
426 # define jit_regset_del(set) (*(set) = 0)
429 jit_regset_scan1(jit_regset_t*, jit_int32_t);
431 #define jit_reglive_setup() \
433 jit_regset_set_ui(&_jitc->reglive, 0); \
434 jit_regset_set_ui(&_jitc->regmask, 0); \
440 typedef union jit_data jit_data_t;
441 typedef struct jit_note jit_note_t;
442 typedef struct jit_line jit_line_t;
443 typedef struct jit_block jit_block_t;
444 typedef struct jit_value jit_value_t;
445 typedef struct jit_compiler jit_compiler_t;
446 typedef struct jit_function jit_function_t;
447 typedef struct jit_register jit_register_t;
450 typedef struct jit_data_info jit_data_info_t;
453 typedef struct jit_const jit_const_t;
458 #if __BYTE_ORDER == __LITTLE_ENDIAN
478 jit_word_t size; /* of code */
483 jit_int32_t *linenos;
484 jit_int32_t *offsets;
492 jit_uint16_t offset; /* Used if DEVEL_DISASSEMBLER */
501 jit_regset_t reglive;
502 jit_regset_t regmask;
503 jit_bool_t again; /* Flag need to rebuild regset masks
504 * due to changes in live and unknown
523 #if __arm__ && DISASSEMBLER
524 struct jit_data_info {
525 jit_uword_t code; /* pointer in code buffer */
526 jit_word_t length; /* length of constant vector */
528 #elif __riscv && __WORDSIZE == 64
536 struct jit_function {
544 jit_int32_t argn; /* for debug output */
558 #if defined(__i386__) || defined(__x86_64__) || \
559 defined(__powerpc__) || defined(__sparc__) || \
560 defined(__s390__) || defined(__s390x__) || \
561 defined(__hppa__) || defined(__alpha__)
562 jit_int32_t cvt_offset; /* allocai'd offset for x87<->xmm or
563 * fpr<->gpr transfer using the stack */
566 /* Helper for common jit generation pattern, used in GNU Smalltalk
567 * and possibly others, where a static frame layout is required or
570 jit_uint32_t define_frame : 1;
571 jit_uint32_t assume_frame : 1;
573 jit_uint32_t need_frame : 1; /* need frame pointer? */
574 jit_uint32_t need_stack : 1; /* need stack pointer? */
575 jit_uint32_t need_return : 1; /* not a leaf function */
577 /* alloca offset offset */
579 /* uses allocar flag */
580 jit_uint32_t allocar : 1;
583 /* If will, or might use float registers and vfp is not available.
584 * Use the first 64 bytes always, as the access to the virtual float
585 * registers use hardcoded instructions that can only reach 64 byte
586 * displacements, and to keep code simpler, do not use temporaries. */
587 jit_uint32_t swf_offset : 1;
588 /* If need to call C functions for some operation, or variadic function */
589 jit_uint32_t save_reg_args : 1;
592 /* varargs state offsets */
593 jit_int32_t vaoff; /* offset of jit_va_list */
594 jit_int32_t vagp; /* first gp va argument */
595 jit_int32_t vafp; /* first fp va argument */
598 /* data used only during jit generation */
599 struct jit_compiler {
605 jit_regset_t regs; /* changed regs since last stop */
606 jit_int32_t pred; /* changed preds last stop */
607 jit_int32_t ioff; /* offset in inst vector */
608 jit_int32_t rout; /* first output register */
609 jit_int32_t breg; /* base register for prolog/epilog */
613 jit_int32_t op; /* pending instruction, candidate
614 * to be inserted in a delay slot */
615 jit_bool_t pend; /* non zero if need to emit op */
618 #if __mips__ || __ia64__ || __alpha__ || \
619 (__sparc__ && __WORDSIZE == 64) || __riscv || __loongarch__
621 #define jit_carry _jitc->carry
625 jit_node_t *prepare; /* inside prepare/finish* block */
626 jit_uint32_t realize : 1; /* jit_realize() called? */
627 jit_uint32_t dataset : 1; /* jit_dataset() called? */
628 jit_uint32_t done : 1; /* emit state finished */
629 jit_uint32_t emit : 1; /* emit state entered */
630 jit_uint32_t again : 1; /* start over emiting function */
631 jit_uint32_t synth : 8; /* emiting synthesized instructions */
633 jit_uint32_t getreg : 1;
635 jit_uint32_t no_data : 1;
636 jit_uint32_t no_note : 1;
637 /* FIXME undocumented, might be moved to a jit_cpu field or a better
639 * These are switches to a different unld* or unst*.
640 * Defaults are the algorithms that generate shorter code*/
641 jit_uint32_t unld_algorithm : 1;
642 jit_uint32_t unst_algorithm : 1;
643 jit_int32_t framesize; /* space for callee save registers,
644 * frame pointer and return address */
645 jit_int32_t reglen; /* number of registers */
646 jit_regset_t regarg; /* cannot allocate */
647 jit_regset_t regsav; /* automatic spill only once */
648 jit_regset_t reglive; /* known live registers at some point */
649 jit_regset_t regmask; /* register mask to update reglive */
650 jit_regset_t explive; /* explicitly marked as live */
656 jit_node_t **table; /* very simple hash table */
657 jit_word_t size; /* number of vectors in table */
658 jit_word_t count; /* number of hash table entries */
659 jit_word_t offset; /* offset in bytes in ptr */
662 jit_int32_t *gen; /* ssa like "register version" */
663 jit_value_t *values; /* temporary jit_value_t vector */
668 } blocks; /* basic blocks */
673 } patches; /* forward patch information */
674 jit_function_t *function; /* current function */
679 } functions; /* prolog/epilogue offsets in code */
687 jit_node_t *head; /* first note node */
688 jit_node_t *tail; /* linked list insertion */
689 /* fields to store temporary state information */
696 /* prevent using thumb instructions that set flags? */
697 jit_uint32_t no_set_flags : 1;
700 jit_data_info_t *ptr;
703 } data_info; /* constant pools information */
705 /* Note that this field is somewhat hackish, but required by most
706 * ways to implement jit, unless implementing a pure one function
707 * per jit, as most times it needs to start the jit buffer with a
708 * jump where the "main" prolog starts, and because the initial
709 * code is in "arm mode", need to make an "arm mode" patch on that
710 * jump. A good example is the test suite assembler, where most
711 * test cases start with a "jmpi main" call. */
714 jit_uint8_t *data; /* pointer to code */
715 jit_word_t size; /* size data */
716 jit_word_t offset; /* pending patches */
717 jit_word_t length; /* number of pending constants */
718 jit_int32_t values[1024]; /* pending constants */
719 jit_word_t patches[2048];
721 #elif (__powerpc__ && _CALL_AIXDESC) || __ia64__
722 /* Keep track of prolog addresses, just for the sake of making
723 * jit that starts with a jump to a "main" label work like other
731 #elif __riscv && __WORDSIZE == 64
733 /* Hash table for constants to be resolved and patched */
735 jit_const_t **table; /* very simple hash table */
736 jit_word_t size; /* number of vectors in table */
737 jit_word_t count; /* number of distinct entries */
740 jit_const_t **ptr; /* keep a single pointer */
741 jit_const_t *list; /* free list */
742 jit_word_t length; /* length of pool */
744 /* Linear list for constants that cannot be encoded easily */
746 jit_word_t *instrs; /* list of direct movi instructions */
747 jit_word_t *values; /* list of direct movi constants */
748 jit_word_t offset; /* offset in instrs/values vector */
749 jit_word_t length; /* length of instrs/values vector */
754 /* Temporary storage to calculate instructions length */
756 /* Global flag for code buffer heuristic size computation */
758 /* Pointer to code to prevent miscalculation if reallocating buffer */
763 #define _jitc _jit->comp
775 /* PROTECTED bytes starting at PTR are mprotect'd. */
786 jit_compiler_t *comp;
787 /* Flags to know if user did set the code and data buffers */
788 jit_uint32_t user_code : 1;
789 jit_uint32_t user_data : 1;
792 struct jit_register {
800 extern void jit_get_cpu(void);
802 #define jit_init() _jit_init(_jit)
803 extern void _jit_init(jit_state_t*);
805 #define jit_synth_inc() _jit_synth_inc(_jit)
806 extern void _jit_synth_inc(jit_state_t*);
808 #define jit_new_node_no_link(u) _jit_new_node_no_link(_jit, u)
809 extern jit_node_t *_jit_new_node_no_link(jit_state_t*, jit_code_t);
811 #define jit_link_node(u) _jit_link_node(_jit, u)
812 extern void _jit_link_node(jit_state_t*, jit_node_t*);
814 #define jit_link_label(l) _jit_link_label(_jit,l)
816 _jit_link_label(jit_state_t*,jit_node_t*);
818 #define jit_synth_dec() _jit_synth_dec(_jit)
819 extern void _jit_synth_dec(jit_state_t*);
821 #define jit_reglive(node) _jit_reglive(_jit, node)
823 _jit_reglive(jit_state_t*, jit_node_t*);
825 #define jit_regarg_set(n,v) _jit_regarg_set(_jit,n,v)
827 _jit_regarg_set(jit_state_t*, jit_node_t*, jit_int32_t);
829 #define jit_regarg_clr(n,v) _jit_regarg_clr(_jit,n,v)
831 _jit_regarg_clr(jit_state_t*, jit_node_t*, jit_int32_t);
833 #define jit_save(reg) _jit_save(_jit, reg)
835 _jit_save(jit_state_t*, jit_int32_t);
837 #define jit_load(reg) _jit_load(_jit, reg)
839 _jit_load(jit_state_t*, jit_int32_t);
841 #define jit_trampoline(u,v) _jit_trampoline(_jit, u, v)
842 extern void _jit_trampoline(jit_state_t*, jit_int32_t, jit_bool_t);
844 #define jit_optimize() _jit_optimize(_jit)
846 _jit_optimize(jit_state_t*);
848 #define jit_classify(code) _jit_classify(_jit, code)
850 _jit_classify(jit_state_t*, jit_code_t);
852 #define jit_regarg_p(n, r) _jit_regarg_p(_jit, n, r)
854 _jit_regarg_p(jit_state_t*, jit_node_t*, jit_int32_t);
856 #define emit_code() _emit_code(_jit)
858 _emit_code(jit_state_t*);
861 jit_flush(void *fptr, void *tptr);
863 #define emit_ldxi(r0, r1, i0) _emit_ldxi(_jit, r0, r1, i0)
865 _emit_ldxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
867 #define emit_stxi(i0, r0, r1) _emit_stxi(_jit, i0, r0, r1)
869 _emit_stxi(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
871 #define emit_ldxi_d(r0, r1, i0) _emit_ldxi_d(_jit, r0, r1, i0)
873 _emit_ldxi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
875 #define emit_stxi_d(i0, r0, r1) _emit_stxi_d(_jit, i0, r0, r1)
877 _emit_stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
879 extern void jit_init_print(void);
880 extern void jit_init_debug(const char*);
881 extern void jit_finish_debug(void);
883 extern void jit_init_note(void);
884 extern void jit_finish_note(void);
885 #define jit_set_note(n,u,v,w) _jit_set_note(_jit, n, u, v, w)
886 extern void _jit_set_note(jit_state_t*, jit_note_t*, char*, int, jit_int32_t);
887 #define jit_annotate() _jit_annotate(_jit)
888 extern void _jit_annotate(jit_state_t*);
890 #define jit_print_node(u) _jit_print_node(_jit,u)
891 extern void _jit_print_node(jit_state_t*,jit_node_t*);
893 extern jit_pointer_t jit_memcpy(jit_pointer_t,const void*,jit_word_t);
894 extern jit_pointer_t jit_memmove(jit_pointer_t,const void*,jit_word_t);
895 extern void jit_alloc(jit_pointer_t*, jit_word_t);
896 extern void jit_realloc(jit_pointer_t*, jit_word_t, jit_word_t);
897 void jit_free(jit_pointer_t*);
899 extern void jit_init_size(void);
900 extern void jit_finish_size(void);
903 # define jit_size_prepare() _jit_size_prepare(_jit)
905 _jit_size_prepare(jit_state_t*);
907 # define jit_size_collect(node) _jit_size_collect(_jit, node)
909 _jit_size_collect(jit_state_t*, jit_node_t*);
911 # define jit_get_size() _jit_get_size(_jit)
913 _jit_get_size(jit_state_t*);
917 jit_get_max_instr(void);
922 extern jit_register_t _rvs[];
924 #endif /* _jit_private_h */