diff --git a/ChangeLog b/ChangeLog index f4b40b985..ecd3846b2 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,21 @@ +2013-04-25 Paulo Andrade + + * include/lightning/jit_ia64.h, lib/jit_ia64-cpu.c, + lib/jit_ia64-fpu.c, lib/jit_ia64.c: New files implementing + the basic infrastructure of an Itanium port. The code + compiles and can generate jit for basic hello world like + functions. + + * check/lightning.c, configure.ac, include/lightning.h, + include/lightning/Makefile.am, include/lightning/jit_private.h, + lib/Makefile.am, lib/lightning.c: Update for the Itanium + port. + + * lib/jit_mips-cpu.c, lib/jit_mips.c: Correct typo and + make the jit_carry register local to the jit_state_t. + This matches code reviewed in the Itanium port, that + should use the same base logic to handle carry/borrow. + 2013-04-10 Paulo Andrade * include/lightning/jit_private.h, lib/jit_arm.c, diff --git a/check/lightning.c b/check/lightning.c index 439aedef0..0c7e914ed 100644 --- a/check/lightning.c +++ b/check/lightning.c @@ -522,6 +522,9 @@ static void rehash(hash_t *hash); /* * Initialization */ +#if __ia64__ +extern int missing_count; +#endif static jit_state_t *_jit; static int flag_verbose; static int flag_disasm; @@ -3566,6 +3569,10 @@ execute(int argc, char *argv[]) } function = jit_emit(); +#if __ia64__ + if (missing_count) + flag_disasm = 1; +#endif if (flag_verbose > 1 || flag_disasm) { jit_print(); fprintf(stdout, " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n"); diff --git a/configure.ac b/configure.ac index d4badf5f7..f32e53228 100644 --- a/configure.ac +++ b/configure.ac @@ -73,6 +73,7 @@ case "$target_cpu" in *mips*) cpu=mips ;; *powerpc*) cpu=ppc ;; *sparc*) cpu=sparc ;; + ia64) cpu=ia64 ;; *) ;; esac AM_CONDITIONAL(cpu_arm, [test cpu-$cpu = cpu-arm]) @@ -80,6 +81,7 @@ AM_CONDITIONAL(cpu_mips, [test cpu-$cpu = cpu-mips]) AM_CONDITIONAL(cpu_ppc, [test cpu-$cpu = cpu-ppc]) AM_CONDITIONAL(cpu_sparc, [test cpu-$cpu = cpu-sparc]) AM_CONDITIONAL(cpu_x86, [test cpu-$cpu = cpu-x86]) +AM_CONDITIONAL(cpu_ia64, [test cpu-$cpu = cpu-ia64]) # Test x87 if both, x87 and sse2 available ac_cv_test_x86_x87= diff --git a/include/lightning.h b/include/lightning.h index a5c7cc8c7..88029b861 100644 --- a/include/lightning.h +++ b/include/lightning.h @@ -74,6 +74,8 @@ typedef jit_int32_t jit_fpr_t; # include #elif defined(__sparc__) # include +#elif defined(__ia64__) +# include #endif #define jit_flag_node 0x00000001 /* patch node not absolute */ diff --git a/include/lightning/Makefile.am b/include/lightning/Makefile.am index 9e1425a6a..23e232b48 100644 --- a/include/lightning/Makefile.am +++ b/include/lightning/Makefile.am @@ -37,3 +37,7 @@ if cpu_x86 lightning_include_HEADERS = \ jit_x86.h endif +if cpu_ia64 +lightning_include_HEADERS = \ + jit_ia64.h +endif diff --git a/include/lightning/jit_ia64.h b/include/lightning/jit_ia64.h new file mode 100644 index 000000000..06c71a474 --- /dev/null +++ b/include/lightning/jit_ia64.h @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2013 Free Software Foundation, Inc. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Authors: + * Paulo Cesar Pereira de Andrade + */ + +#ifndef _jit_ia64_h +#define _jit_ia64_h + +#define JIT_HASH_CONSTS 1 +#define JIT_NUM_OPERANDS 3 + +/* + * Types + */ +#define JIT_FP _R4 /* Not abi specific */ +typedef enum { +#define JIT_R0 _R14 +#define JIT_R1 _R15 +#define JIT_R2 _R16 +#define JIT_V0 _R40 +#define JIT_V1 _R41 +#define JIT_V2 _R42 +#define jit_r_num() 16 +#define jit_r(n) (_R14 - (n)) +#define jit_v_num() 8 +#define jit_v(n) (_R40 + (n)) + _R0, /* constant - Always 0 */ + _R1, /* special - Global Data pointer (gp) */ + /* r2-r3 - scratch - Use with 22-bit immediate add - scratch */ + _R2, _R3, + /* r4-r7 - preserved */ + _R4, _R5, _R6, _R7, + _R8, /* scratch - Return value; structure/union return pointer */ + /* r9-r11 - scratch - Return values */ + _R9, _R10, _R11, + _R12, /* special - Memory stack pointer (sp) */ + _R13, /* special - Reserved as a thread pointer (tp)*/ + /* r14-r31 - scratch */ + _R31, _R30, + _R29, _R28, _R27, _R26, _R25, _R24, _R23, _R22, + _R21, _R20, _R19, _R18, _R17, _R16, _R15, _R14, + /* r32-r39 - aka in0-in7 - Incoming register arguments */ + _R32, _R33, _R34, _R35, _R36, _R37, _R38, _R39, + /* r40-r127 - loc0...locn,out0...outn */ + _R40, _R41, _R42, _R43, _R44, _R45, _R46, _R47, + _R48, _R49, _R50, _R51, _R52, _R53, _R54, _R55, + _R56, _R57, _R58, _R59, _R60, _R61, _R62, _R63, + _R64, _R65, _R66, _R67, _R68, _R69, _R70, _R71, + _R72, _R73, _R74, _R75, _R76, _R77, _R78, _R79, + _R80, _R81, _R82, _R83, _R84, _R85, _R86, _R87, + _R88, _R89, _R90, _R91, _R92, _R93, _R94, _R95, + _R96, _R97, _R98, _R99, _R100, _R101, _R102, _R103, + _R104, _R105, _R106, _R107, _R108, _R109, _R110, _R111, + _R112, _R113, _R114, _R115, _R116, _R117, _R118, _R119, + _R120, _R121, _R122, _R123, _R124, _R125, _R126, _R127, +#define JIT_F0 _F32 +#define JIT_F1 _F33 +#define JIT_F2 _F34 +#define JIT_F3 _F35 +#define JIT_F4 _F36 +#define JIT_F5 _F37 +#define JIT_F6 _F38 +#define JIT_F7 _F39 +#define jit_f_num() 8 +#define jit_f(n) (_F32 + (n)) + _F0, /* constant - Always 0.0 */ + _F1, /* constant - Always 1.0 */ + /* f2-f5 - preserved */ + _F2, _F3, _F4, _F5, + /* f6-f7 - scratch */ + _F6, _F7, + /* f8-f15 - scratch - Argument/return registers */ + _F8, _F9, _F10, _F11, _F12, _F13, _F14, _F15, + /* f16-f31 - preserved */ + _F16, _F17, _F18, _F19, _F20, _F21, _F22, _F23, + _F24, _F25, _F26, _F27, _F28, _F29, _F30, _F31, + /* f32-f127 - scratch - Rotating registers or scratch */ + _F32, _F33, _F34, _F35, _F36, _F37, _F38, _F39, + _F40, _F41, _F42, _F43, _F44, _F45, _F46, _F47, + _F48, _F49, _F50, _F51, _F52, _F53, _F54, _F55, + _F56, _F57, _F58, _F59, _F60, _F61, _F62, _F63, + _F64, _F65, _F66, _F67, _F68, _F69, _F70, _F71, + _F72, _F73, _F74, _F75, _F76, _F77, _F78, _F79, + _F80, _F81, _F82, _F83, _F84, _F85, _F86, _F87, + _F88, _F89, _F90, _F91, _F92, _F93, _F94, _F95, + _F96, _F97, _F98, _F99, _F100, _F101, _F102, _F103, + _F104, _F105, _F106, _F107, _F108, _F109, _F110, _F111, + _F112, _F113, _F114, _F115, _F116, _F117, _F118, _F119, + +#if 0 + /* Do not list these to not need an unique identifier larger + * than 255 for jit_regset_t */ + _F120, _F121, _F122, _F123, _F124, _F125, _F126, _F127, +#endif + + /* Fake registers. Required because while "in" parameters start at r32, + * "out" parameters start *after* registers allocated for temporaries, + * and that are supposed to kept alive (what is desirable, that is, to + * not spill/reload them in memory) */ + _OUT0, _OUT1, _OUT2, _OUT3, _OUT4, _OUT5, _OUT6, _OUT7, + +#define JIT_NOREG _NOREG + _NOREG, +} jit_reg_t; + +typedef struct { + jit_int64_t rl; + jit_int64_t rh; + jit_int64_t fl; + jit_int64_t fh; +} jit_regset_t; + +#endif /* _jit_ia64_h */ diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h index ae8a9e7cb..d6fd8ea3a 100644 --- a/include/lightning/jit_private.h +++ b/include/lightning/jit_private.h @@ -73,6 +73,10 @@ # define JIT_SP _SP # define JIT_RET _I0 # define JIT_FRET _F0 +#elif defined(__ia64__) +# define JIT_SP _R12 +# define JIT_RET _R8 +# define JIT_FRET _F8 #endif #define jit_size(vector) (sizeof(vector) / sizeof((vector)[0])) @@ -121,20 +125,62 @@ #define jit_cc_a2_flt 0x00200000 /* arg2 is immediate float */ #define jit_cc_a2_dbl 0x00400000 /* arg2 is immediate double */ -#define jit_regset_com(u, v) (*(u) = ~*(v)) -#define jit_regset_and(u, v, w) (*(u) = *(v) & *(w)) -#define jit_regset_ior(u, v, w) (*(u) = *(v) | *(w)) -#define jit_regset_xor(u, v, w) (*(u) = *(v) ^ *(w)) -#define jit_regset_set(u, v) (*(u) = *(v)) -#define jit_regset_set_mask(u, v) (*(u) = (1LL << (v)) - 1) -#define jit_regset_cmp_ui(u, v) (*(u) != (v)) -#define jit_regset_set_ui(u, v) (*(u) = (v)) -#define jit_regset_set_p(set) (*set) -#define jit_regset_clrbit(set, bit) (*(set) &= ~(1LL << (bit))) -#define jit_regset_setbit(set, bit) (*(set) |= 1LL << (bit)) -#define jit_regset_tstbit(set, bit) (*(set) & (1LL << (bit))) -#define jit_regset_new(set) (*(set) = 0) -#define jit_regset_del(set) (*(set) = 0) +#if __ia64__ +extern void +jit_regset_com(jit_regset_t*, jit_regset_t*); + +extern void +jit_regset_and(jit_regset_t*, jit_regset_t*, jit_regset_t*); + +extern void +jit_regset_ior(jit_regset_t*, jit_regset_t*, jit_regset_t*); + +extern void +jit_regset_xor(jit_regset_t*, jit_regset_t*, jit_regset_t*); + +extern void +jit_regset_set(jit_regset_t*, jit_regset_t*); + +extern void +jit_regset_set_mask(jit_regset_t*, jit_int32_t); + +extern jit_bool_t +jit_regset_cmp_ui(jit_regset_t*, jit_word_t); + +extern void +jit_regset_set_ui(jit_regset_t*, jit_word_t); + +extern jit_bool_t +jit_regset_set_p(jit_regset_t*); + +extern void +jit_regset_clrbit(jit_regset_t*, jit_int32_t); + +extern void +jit_regset_setbit(jit_regset_t*, jit_int32_t); + +extern jit_bool_t +jit_regset_tstbit(jit_regset_t*, jit_int32_t); +# define jit_regset_new(set) \ + do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0) +# define jit_regset_del(set) \ + do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0) +#else +# define jit_regset_com(u, v) (*(u) = ~*(v)) +# define jit_regset_and(u, v, w) (*(u) = *(v) & *(w)) +# define jit_regset_ior(u, v, w) (*(u) = *(v) | *(w)) +# define jit_regset_xor(u, v, w) (*(u) = *(v) ^ *(w)) +# define jit_regset_set(u, v) (*(u) = *(v)) +# define jit_regset_set_mask(u, v) (*(u) = (1LL << (v)) - 1) +# define jit_regset_cmp_ui(u, v) (*(u) != (v)) +# define jit_regset_set_ui(u, v) (*(u) = (v)) +# define jit_regset_set_p(set) (*set) +# define jit_regset_clrbit(set, bit) (*(set) &= ~(1LL << (bit))) +# define jit_regset_setbit(set, bit) (*(set) |= 1LL << (bit)) +# define jit_regset_tstbit(set, bit) (*(set) & (1LL << (bit))) +# define jit_regset_new(set) (*(set) = 0) +# define jit_regset_del(set) (*(set) = 0) +#endif extern unsigned long jit_regset_scan1(jit_regset_t*, jit_int32_t); @@ -255,12 +301,30 @@ struct jit_function { /* data used only during jit generation */ struct jit_compiler { +#if __ia64__ + struct { + jit_uint64_t i : 41; + jit_uint64_t t : 4; + } inst[3]; + jit_regset_t gprs; /* changed gprs since last stop */ + jit_regset_t fprs; /* changed fprs since last stop */ + jit_int32_t ioff; /* offset in inst vector */ + jit_int32_t rout; /* first output register */ + jit_int32_t breg; /* base register for prolog/epilog */ +#endif +#if __mips__ || __ia64__ + jit_int32_t carry; +#define jit_carry _jitc->carry +#endif jit_node_t *head; jit_node_t *tail; jit_uint32_t done : 1; /* emit state finished */ jit_uint32_t emit : 1; /* emit state entered */ jit_uint32_t again : 1; /* start over emiting function */ jit_uint32_t prepare : 1; /* inside prepare/finish* block */ +#if DEBUG + jit_uint32_t getreg : 1; +#endif jit_int32_t reglen; /* number of registers */ jit_regset_t regarg; /* cannot allocate */ jit_regset_t regsav; /* automatic spill only once */ @@ -307,7 +371,6 @@ struct jit_compiler { struct { jit_node_t *head; /* first note node */ jit_node_t *tail; /* linked list insertion */ - /* fields to store temporary state information */ jit_word_t size; jit_node_t *name; @@ -338,7 +401,7 @@ struct jit_compiler { jit_int32_t values[1024]; /* pending constants */ jit_word_t patches[2048]; } consts; -#elif __powerpc64__ +#elif __powerpc64__ || __ia64__ /* Keep track of prolog addresses, just for the sake of making * jit that starts with a jump to a "main" label work like other * backends. */ @@ -488,5 +551,8 @@ extern jit_bool_t _jit_remap(jit_state_t*); */ extern jit_register_t _rvs[]; extern const char *jit_progname; +#if __ia64__ +extern int missing_count; +#endif #endif /* _jit_private_h */ diff --git a/lib/Makefile.am b/lib/Makefile.am index a723e7392..6b5dbc2bf 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am @@ -28,6 +28,9 @@ EXTRA_DIST = \ jit_arm-cpu.c \ jit_arm-swf.c \ jit_arm-vfp.c \ + jit_ia64.c \ + jit_ia64-cpu.c \ + jit_ia64-fpu.c \ jit_mips.c \ jit_mips-cpu.c \ jit_mips-fpu.c \ diff --git a/lib/jit_ia64-cpu.c b/lib/jit_ia64-cpu.c new file mode 100644 index 000000000..981ca68c1 --- /dev/null +++ b/lib/jit_ia64-cpu.c @@ -0,0 +1,5030 @@ +/* + * Copyright (C) 2013 Free Software Foundation, Inc. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Authors: + * Paulo Cesar Pereira de Andrade + */ + +#if PROTO +#define INST_NONE 0 /* should never be generated */ +#define INST_STOP 1 /* or'ed if stop is required */ +#define INST_A 2 /* M- or I- unit */ +#define INST_As 3 +#define INST_I 4 +#define INST_Is 5 +#define INST_M 6 +#define INST_Ms 7 +#define INST_F 8 +#define INST_Fs 9 +#define INST_B 10 +#define INST_Bs 11 +#define INST_L 12 +#define INST_Ls 13 +#define INST_X 14 +#define INST_Xs 15 + +typedef union { + struct { + jit_uint64_t tm : 5; + jit_uint64_t s0 : 41; + jit_uint64_t s1 : 18; + } b; + jit_int64_t w; +} inst_lo_t; + +typedef union { + struct { + jit_uint64_t s1 : 23; + jit_uint64_t s2 : 41; + } b; + jit_int64_t w; +} inst_hi_t; +#define il(ii) *_jit->pc.ul++ = ii +#define to_tm(v) l.b.tm = v +#define get_tm(v) v = l.b.tm +#define to_s0(v) l.b.s0 = v +#define get_s0(v) v = l.b.s0 +#define to_s1(v) \ + do { \ + l.b.s1 = (v) & 0x3ffff; \ + h.b.s1 = ((v) >> 18) & 0x7fffff; \ + } while (0) +#define get_s1(v) v = l.b.s1 | ((jit_word_t)h.b.s1 << 18) +#define to_s2(v) h.b.s2 = v +#define get_s2(v) v = h.b.s2 + +/* Need to insert a stop if a modified register would (or could) + * be read in the same cycle. + */ +#define TSTREG1(r0) \ + do { \ + if (jit_regset_tstbit(&_jitc->gprs, r0)) \ + stop(); \ + } while (0) +#define TSTREG2(r0, r1) \ + do { \ + if (jit_regset_tstbit(&_jitc->gprs, r0) || \ + jit_regset_tstbit(&_jitc->gprs, r1)) \ + stop(); \ + } while (0) +/* Record register was modified */ +#define SETREG(r0) jit_regset_setbit(&_jitc->gprs, r0) + +/* Avoid using constants in macros and code */ +typedef enum { + GR_0, GR_1, GR_2, GR_3, + GR_4, GR_5, GR_6, GR_7, + GR_8, GR_9, GR_10, GR_11, + GR_12, GR_13, GR_14, GR_15, + GR_16, GR_17, GR_18, GR_19, + GR_20, GR_21, GR_22, GR_23, + GR_24, GR_25, GR_26, GR_27, + GR_28, GR_29, GR_30, GR_31, + GR_32, GR_33, GR_34, GR_35, + GR_36, GR_37, GR_38, GR_39, + GR_40, GR_41, GR_42, GR_43, + /* GR_44...GR_127 */ +} gr_reg_t; + +typedef enum { + PR_0, /* constant - always 1 */ + /* p0-p5 - preserved */ + PR_1, PR_2, PR_3, PR_4, + PR_5, + /* p6-p15 - scratch */ + PR_6, PR_7, PR_8, PR_9, + PR_10, PR_11, PR_12, PR_13, + PR_14, PR_15, + /* p16-... - preserved - rotating */ +} pr_reg_t; + +typedef enum { + BR_0, /* scratch - Return link */ + /* b1-b5 - preserved */ + BR_1, BR_2, BR_3, BR_4, + BR_5, + /* b6-b7 - scratch */ + BR_6, BR_7 +} br_reg_t; + +typedef enum { + AR_KR0, AR_KR1, AR_KR2, AR_KR3, + AR_KR4, AR_KR5, AR_KR6, AR_KR7, + AR_8, AR_9, AR_10, AR_11, + AR_12, AR_13, AR_14, AR_15, + AR_RSC, AR_BSP, AR_BSPSTORE, AR_RNAT, + AR_20, AR_FCR, AR_22, AR_23, + AR_EFLAG, AR_CSD, AR_SSD, AR_CFLG, + AR_FSR, AR_FIR, AR_FDR, AR_31, + AR_CCV, AR_33, AR_34, AR_35, + AR_UNAT, AR_37, AR_38, AR_39, + AR_FPSR, AR_41, AR_42, AR_43, + AR_ITC, AR_RUC, AR_46, AR_47, + AR_48, AR_49, AR_50, AR_51, + AR_52, AR_53, AR_54, AR_55, + AR_56, AR_57, AR_58, AR_59, + AR_60, AR_61, AR_62, AR_63, + AR_PFS, AR_LC, AR_EC, + /* AR_67 ... AR_127 */ +} ar_reg_t; + +typedef enum { + TM_M_I_I_, TM_M_I_Is, TM_M_IsI_, TM_M_IsIs, + TM_M_L_X_, TM_M_L_Xs, TM_ILL_06, TM_ILL_07, + TM_M_M_I_, TM_M_M_Is, TM_MsM_I_, TM_MsM_Is, + TM_M_F_I_, TM_M_F_Is, TM_M_M_F_, TM_M_M_Fs, + TM_M_I_B_, TM_M_I_Bs, TM_M_B_B_, TM_M_B_Bs, + TM_ILL_14, TM_ILL_15, TM_B_B_B_, TM_B_B_Bs, + TM_M_M_B_, TM_M_M_Bs, TM_ILL_1A, TM_ILL_1B, + TM_M_F_B_, TM_M_F_Bs, TM_ILL_1E, TM_ILL_1F, +} template_t; + +#define MWH_SPTK 0 +#define MWH_NONE 1 +#define MWH_DPTK 2 + +#define IH_NONE 0 +#define IH_IMP 1 + +#define LD_NONE 0 +#define LD_NT1 1 +#define LD_NTA 3 + +#define ST_NONE 0 +#define ST_NTA 3 + +#define LF_NONE 0 +#define LF_NT1 1 +#define LF_NT2 2 +#define LF_NTA 3 + +#define BR_PH_FEW 0 +#define BR_PH_MANY 1 + +#define BR_BWH_SPTK 0 +#define BR_BWH_SPNT 1 +#define BR_BWH_DPTK 2 +#define BR_BWH_DPNT 3 + +#define BRI_BWH_SPTK 1 +#define BRI_BWH_SPNT 3 +#define BRI_BWH_DPTK 5 +#define BRI_BWH_DPNT 7 + +#define BR_DH_NONE 0 +#define BR_DH_CLR 1 + +#define BR_IH_NONE 0 +#define BR_IH_IMP 1 + +#define BR_IPWH_SPTK 0 +#define BR_IPWH_LOOP 1 +#define BR_IPWH_DPTK 2 +#define BR_IPWH_EXIT 3 + +#define BR_INDWH_SPTK 0 +#define BR_INDWH_DPTK 2 + +#define MUX_BRCST 0 +/* FIXME only @name values in manual and only @brcst disassembled by binutils */ +#define MUX_REV 1 /* not disassembled as @rev */ +#define MUX_MIX 2 /* not disassembled as @mix */ +#define MUX_SHUF 3 /* not disassembled as @shuf */ +#define MUX_ALT 4 /* not disassembled as @alt */ + +#define ldr(r0,r1) ldr_l(r0,r1) +#define ldi(r0,i0) ldi_l(r0,i0) +#define str(r0,r1) str_l(r0,r1) +#define sti(i0,r0) str_l(i0,r0) +#define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) +#define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) +#define stxr(r0,r1,r2) stxr_l(r0,r1,r2) +#define stxi(i0,r0,r1) stxi_l(i0,r0,r1) + +/* libgcc */ +extern void __divdi3(long,long); +extern void __udivdi3(unsigned long,unsigned long); +extern void __moddi3(long,long); +extern void __umoddi3(unsigned long,unsigned long); + +#define out(n,tm,s0,s1,s2) _out(_jit,n,tm,s0,s1,s2) +static void _out(jit_state_t*,int,int,jit_word_t,jit_word_t,jit_word_t); +#define stop() _stop(_jit) +static void _stop(jit_state_t*); +#define sync() _sync(_jit) +static void _sync(jit_state_t*); +#define flush() _flush(_jit) +static void _flush(jit_state_t*); +#define inst(w, t) _inst(_jit, w, t) +static void _inst(jit_state_t*, jit_word_t, jit_uint8_t); +#define A1(x4,x2,r3,r2,r1) _A1(_jit,0,x4,x2,r3,r2,r1) +static void _A1(jit_state_t*, jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A2(x4,ct,r3,r2,r1) A1(x4,ct,r3,r2,r1) +#define A3(x4,x2,r3,im,r1) _A3(_jit,0,x4,x2,r3,im,r1) +static void _A3(jit_state_t*, jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A4(x2a,r3,im,r1) _A4(_jit,0,x2a,r3,im,r1) +static void _A4(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A5(r3,im,r1) _A5(_jit,0,r3,im,r1) +static void _A5(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define A6(o,x2,ta,p2,r3,r2,c,p1) _A6(_jit,0,o,x2,ta,p2,r3,r2,c,p1) +static void _A6(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A7(o,x2,ta,p2,r3,c,p1) _A7(_jit,0,o,x2,ta,p2,r3,c,p1) +static void _A7(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A8(o,x2,ta,p2,r3,im,c,p1) _A8(_jit,0,o,x2,ta,p2,r3,im,c,p1) +static void _A8(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A9(za,zb,x4,x2,r3,r2,r1) _A9(_jit,0,za,zb,x4,x2,r3,r2,r1) +static void _A9(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define A10(x4,ct,r3,r2,r1) A9(0,1,x4,ct,r3,r2,r1) +#define I1(ct,x2,r3,r2,r1) _I1(_jit,0,ct,x2,r3,r2,r1) +static void _I1(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I2(za,x2a,zb,x2c,x2b,r3,r2,r1) _I2(_jit,0,za,x2a,zb,x2c,x2b,r3,r2,r1) +static void _I2(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I3(mbt,r2,r1) _I3(_jit,0,mbt,r2,r1) +static void _I3(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I4(mht,r2,r1) _I4(_jit,0,mht,r2,r1) +static void _I4(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I5(za,zb,x2b,r3,r2,r1) _I5(_jit,0,za,zb,x2b,r3,r2,r1) +static void _I5(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I6(za,zb,x2b,r3,ct,r1) _I6(_jit,0,za,zb,x2b,r3,ct,r1) +static void _I6(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I7(za,zb,r3,r2,r1) _I7(_jit,0,za,zb,r3,r2,r1) +static void _I7(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I8(za,zb,ct,r2,r1) _I8(_jit,0,za,zb,ct,r2,r1) +static void _I8(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I9(x2c,r3,r1) _I9(_jit,0,x2c,r3,r1) +static void _I9(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I10(ct,r3,r2,r1) _I10(_jit,0,ct,r3,r2,r1) +static void _I10(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I11(len,r3,pos,y,r1) _I11(_jit,0,len,r3,pos,y,r1) +static void _I11(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I12(len,pos,r2,r1) _I12(_jit,0,len,pos,r2,r1) +static void _I12(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I13(len,pos,im,r1) _I13(_jit,0,len,pos,im,r1) +static void _I13(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I14(s,len,r3,pos,r1) _I14(_jit,0,s,len,r3,pos,r1) +static void _I14(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I15(pos,len,r3,r2,r1) _I15(_jit,0,pos,len,r3,r2,r1) +static void _I15(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I16(tb,ta,p2,r3,pos,c,p1) _I16(_jit,0,tb,ta,p2,r3,pos,c,p1) +static void _I16(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I17(tb,ta,p2,r3,c,p1) _I17(_jit,0,tb,ta,p2,r3,c,p1) +static void _I17(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I18(im,y) _I18(_jit,0,im,y) +static void _I18(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I19(im) _I19(_jit,0,im) +static void _I19(jit_state_t*,jit_word_t, + jit_word_t); +#define I20(r2,im) _I20(_jit,0,r2,im) +static void _I20(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I21(im,ih,x,wh,r2,b1) _I21(_jit,0,im,ih,x,wh,r2,b1) +static void _I21(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define I22(b2,r1) _I22(_jit,0,b2,r1) +static void _I22(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I23(r2,im) _I23(_jit,0,r2,im) +static void _I23(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I24(im) _I24(_jit,0,im) +static void _I24(jit_state_t*,jit_word_t, + jit_word_t); +#define I25(x6,r1) _I25(_jit,0,x6,r1) +static void _I25(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I26(ar,r2) _I26(_jit,0,ar,r2) +static void _I26(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I27(ar,im) _I27(_jit,0,ar,im) +static void _I27(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I28(ar,r1) _I28(_jit,0,ar,r1) +static void _I28(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define I29(x6,r3,r1) _I29(_jit,0,x6,r3,r1) +static void _I29(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define I30(tb,ta,p2,im,c,p1) _I30(_jit,0,ta,tb,p2,im,c,p1) +static void _I30(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M1(x6,ht,x,r3,r1) _M1(_jit,0,x6,ht,x,r3,r1) +static void _M1(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M2(x6,ht,r3,r2,r1) _M2(_jit,0,x6,ht,r3,r2,r1) +static void _M2(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M3(x6,ht,r3,im,r1) _M3(_jit,0,x6,ht,r3,im,r1) +static void _M3(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M5(x6,ht,r3,r2,im) _M5(_jit,0,x6,ht,r3,r2,im) +static void _M5(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M6(x6,ht,x,r3,r2) _M6(_jit,0,x6,ht,x,r3,r2) +static void _M6(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M13(x6,ht,r3,f2) _M13(_jit,0,x6,ht,r3,f2) +static void _M13(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M14(x6,ht,r3,r2) _M14(_jit,0,x6,ht,r3,r2) +static void _M14(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M15(x6,ht,r3,im) _M15(_jit,0,x6,ht,r3,im) +static void _M15(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M16(x6,ht,r3,r2,r1) _M16(_jit,0,x6,ht,r3,r2,r1) +static void _M16(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M17(x6,ht,r3,im,r1) _M17(_jit,0,x6,ht,r3,im,r1) +static void _M17(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M20(r2,im) M20x(0x1,r2,im) +#define M20x(x3,r2,im) _M20x(_jit,0,x3,r2,im) +static void _M20x(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M22(x3,im,r1) M22x(x3,im,r1) +#define M22x(x3,im,r1) _M22x(_jit,0,x3,im,r1) +static void _M22x(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M24(x2,x4) _M24(_jit,0,x2,x4) +#define M25(x4) M24(0,x4) +static void _M24(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M26(r1) M26x(2,r1) +#define M26x(x4,r1) _M26x(_jit,0,x4,r1) +static void _M26x(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M28(x,r3) _M28(_jit,0,x,r3) +static void _M28(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M29(ar,r2) _M29(_jit,0,ar,r2) +static void _M29(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M30(ar,im) _M30(_jit,0,ar,im) +static void _M30(jit_state_t*,jit_word_t,jit_word_t,jit_word_t); +#define M31(ar,r1) _M31(_jit,0,ar,r1) +static void _M31(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M32(cr,r2) _M32(_jit,0,cr,r2) +static void _M32(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M33(cr,r1) _M33(_jit,0,cr,r1) +static void _M33(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M34(sor,sol,sof,r1) _M34(_jit,0,sor,sol,sof,r1) +static void _M34(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M35(x6,r2) _M35(_jit,0,x6,r2) +static void _M35(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M36(x6,r1) _M36(_jit,0,x6,r1) +static void _M36(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M37(im) _M37(_jit,0,im) +static void _M37(jit_state_t*,jit_word_t, + jit_word_t); +#define M38(x6,r3,r2,r1) _M38(_jit,0,x6,r3,r2,r1) +static void _M38(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M39(x6,r3,im,r1) _M39(_jit,0,x6,r3,im,r1) +static void _M39(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M40(x6,r3,im) _M40(_jit,0,x6,r3,im) +static void _M40(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M41(x6,r2) _M41(_jit,0,x6,r2) +static void _M41(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M42(x6,r3,r2) _M42(_jit,0,x6,r3,r2) +static void _M42(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M43(x6,r3,r1) _M43(_jit,0,x6,r3,r1) +static void _M43(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M44(x4,im) _M44(_jit,0,x4,im) +static void _M44(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define M45(x6,r3,r2) _M45(_jit,0,x6,r3,r2) +static void _M45(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M46(x6,r3,r1) _M46(_jit,0,x6,r3,r1) +#define M47(x6,r3) M46(x6,r3,0) +static void _M46(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M48(y,im) _M48(_jit,0,y,im) +static void _M48(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define B1(d,wh,im,p,tp) _B1(_jit,0,d,wh,im,p,tp) +#define B2(d,wh,im,p,tp) B1(d,wh,im,p,tp) +static void _B1(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define B3(d,wh,im,p,b) _B3(_jit,0,d,wh,im,p,b) +static void _B3(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define B4(d,wh,x6,b,p,tp) _B4(_jit,0,d,wh,x6,b,p,tp) +static void _B4(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define B5(d,wh,b2,p,b1) _B5(_jit,0,d,wh,b2,p,b1) +static void _B5(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define B6(ih,im,tag,wh) _B6(_jit,0,ih,im,tag,wh) +static void _B6(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define B7(ih,x6,b2,tag,wh) _B7(_jit,0,ih,x6,b2,tag,wh) +static void _B7(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define B8(x6) _B8(_jit,0,x6) +static void _B8(jit_state_t*,jit_word_t, + jit_word_t); +#define B9(op,x6,im) _B9(_jit,0,op,x6,im) +static void _B9(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define X1(im) _X1(_jit,0,im) +static void _X1(jit_state_t*,jit_word_t, + jit_word_t); +#define X2(r1,im) _X2(_jit,0,r1,im) +static void _X2(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); +#define X3x(o,d,wh,p,tp,im) _X3x(_jit,0,o,d,wh,p,tp,im) +#define X3(d,wh,p,tp,im) X3x(0xc,d,wh,p,tp,im) +#define X4(d,wh,p,tp,im) X3x(0xd,d,wh,p,tp,im) +static void _X3x(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define X5(y,im) _X5(_jit,0,y,im) +static void _X5(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); + +/* add */ +#define ADD(r1,r2,r3) A1(0,0,r3,r2,r1) +#define ADD1(r1,r2,r3) A1(0,1,r3,r2,r1) +#define ADDS(r1,im,r3) A4(2,r3,im,r1) +#define ADDS_p(r1,im,r3,_p) _A4(_jit,_p,2,r3,im,r1) +#define ADDL(r1,im,r3) A5(r3,im,r1) +#define ADDL_p(r1,im,r3,_p) _A5(_jit,_p,r3,im,r1) +/* addp4 */ +#define ADDP4(r1,r2,r3) A1(2,0,r3,r2,r1) +#define ADDIP4(r1,im,r3) A4(3,r3,im,r1) +/* alloc */ +#define ALLOCR(r1,i,l,o,r) M34((r)>>3,(i)+(l),(i)+(l)+(o),r1) +#define ALLOC(r1,i,o) ALLOCR(r1,i,0,o,0) +/* and */ +#define AND(r1,r2,r3) A1(3,0,r3,r2,r1) +#define ANDI(r1,im,r3) A3(0xb,0,r3,im,r1) +/* andcm */ +#define ANDCM(r1,r2,r3) A1(3,1,r3,r2,r1) +#define ANDCMI(r1,im,r3) A3(0xb,1,r3,im,r1) +/* br */ +#define BRI(im) B1(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_FEW,0) +#define BRI_COND(im,_p) _B1(_jit,_p,BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_FEW,0) +#define BRI_WEXIT(im) B1(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_MANY,2) +#define BRI_WTOP(im) B1(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_MANY,3) +#define BRI_CALL(b,im) B3(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_MANY,b) +#define BRI_CLOOP(im) B2(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_MANY,5) +#define BRI_CEXIT(im) B2(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_MANY,6) +#define BRI_CTOP(im) B2(BR_DH_NONE,BR_BWH_SPTK,im,BR_PH_MANY,7) +#define BR_COND(b,_p) _B4(_jit,_p,BR_DH_NONE,BR_BWH_SPTK,0x20,b,BR_PH_FEW,0) +#define BR(b) B4(BR_DH_NONE,BR_BWH_SPTK,0x20,b,BR_PH_FEW,0) +#define BR_IA(b) B4(BR_DH_NONE,BR_BWH_SPTK,0x20,b,BR_PH_MANY,1) +#define BR_RET(b) B4(BR_DH_NONE,BR_BWH_SPTK,0x21,b,BR_PH_MANY,4) +#define BR_CALL(b1,b2) B5(BR_DH_NONE,BRI_BWH_SPTK,b2,BR_PH_MANY,b1) +/* break */ +#define BREAK_I(im) I19(im) +#define BREAK_M(im) M37(im) +#define BREAK_B(im) B9(0,0,im) +#define BREAK_X(im) X1(im) +/* brl */ +#define BRL(im) X3(BR_DH_NONE,BR_BWH_SPTK,BR_PH_MANY,0,im) +#define BRL_COND(im,_p) _X3(_jit,_p,BR_DH_NONE,BR_BWH_SPTK,BR_PH_MANY,0,im) +#define BRL_CALL(b1,im) X4(BR_DH_NONE,BR_BWH_SPTK,BR_PH_MANY,b1,im) +/* brp */ +#define BRP(im,tag) B6(BR_IH_NONE,im,tag,BR_IPWH_SPTK) +#define BRPI(b2,tag) B7(BR_IH_NONE,0x10,b2,tag,BR_INDWH_SPTK) +#define BRPI_RET(b2,tag) B7(BR_IH_NONE,0x11,b2,tag,BR_INDWH_SPTK) +/* bsw */ +#define BSW_0() B8(0x0c) +#define BSW_1() B8(0x0d) +/* chk */ +#define CHK_S_I(r2,im) I20(r2,im) +#define CHK_S_M(r2,im) M20(r2,im) +#define CHK_A_NC(r1,im) M22(0x4,im,r1) +#define CHK_A_CLR(r1,im) M22(0x5,im,r1) +/* clrrrb */ +#define CLRRRB() B8(0x04) +#define CLRRRB_PR() B8(0x05) +/* clz */ +#define CLZ(r1,r3) I9(3,r3,r1) +/* cmp */ +#define CMP_LT(p1,p2,r2,r3) A6(0xc,0,0,p2,r3,r2,0,p1) +#define CMP_LT_p(p1,p2,r2,r3,_p) A6(_jit,_p,0xc,0,0,p2,r3,r2,0,p1) +#define CMP_LTU(p1,p2,r2,r3) A6(0xd,0,0,p2,r3,r2,0,p1) +#define CMP_EQ(p1,p2,r2,r3) A6(0xe,0,0,p2,r3,r2,0,p1) +#define CMP_LT_UNC(p1,p2,r2,r3) A6(0xc,0,0,p2,r3,r2,1,p1) +#define CMP_LTU_UNC(p1,p2,r2,r3) A6(0xd,0,0,p2,r3,r2,1,p1) +#define CMP_EQ_UNC(p1,p2,r2,r3) A6(0xe,0,0,p2,r3,r2,1,p1) +#define CMP_EQ_AND(p1,p2,r2,r3) A6(0xc,0,1,p2,r3,r2,0,p1) +#define CMP_EQ_OR(p1,p2,r2,r3) A6(0xd,0,1,p2,r3,r2,0,p1) +#define CMP_EQ_OR_ANDCM(p1,p2,r2,r3) A6(0xe,0,1,p2,r3,r2,0,p1) +#define CMP_NE_AND(p1,p2,r2,r3) A6(0xc,0,1,p2,r3,r2,1,p1) +#define CMP_NE_OR(p1,p2,r2,r3) A6(0xd,0,1,p2,r3,r2,1,p1) +#define CMP_NE_OR_ANDCM(p1,p2,r2,r3) A6(0xe,0,1,p2,r3,r2,1,p1) +#define CMPI_LT(p1,p2,im,r3) A8(0xc,2,0,p2,r3,im,0,p1) +#define CMPI_LTU(p1,p2,im,r3) A8(0xd,2,0,p2,r3,im,0,p1) +#define CMPI_EQ(p1,p2,im,r3) A8(0xe,2,0,p2,r3,im,0,p1) +#define CMPI_EQ_p(p1,p2,im,r3,_p) _A8(_jit,_p,0xe,2,0,p2,r3,im,0,p1) +#define CMPI_LT_UNC(p1,p2,im,r3) A8(0xc,2,0,p2,r3,im,1,p1) +#define CMPI_LTU_UNC(p1,p2,im,r3) A8(0xd,2,0,p2,r3,im,1,p1) +#define CMPI_EQ_UNC(p1,p2,im,r3) A8(0xe,2,0,p2,r3,im,1,p1) +#define CMPI_EQ_AND(p1,p2,im,r3) A8(0xc,2,1,p2,r3,im,0,p1) +#define CMPI_EQ_OR(p1,p2,im,r3) A8(0xd,2,1,p2,r3,im,0,p1) +#define CMPI_EQ_ANDCM(p1,p2,im,r3) A8(0xe,2,1,p2,r3,im,0,p1) +#define CMPI_NE_AND(p1,p2,im,r3) A8(0xc,2,1,p2,r3,im,1,p1) +#define CMPI_NE_OR(p1,p2,im,r3) A8(0xd,2,1,p2,r3,im,1,p1) +#define CMPI_NE_ANDCM(p1,p2,im,r3) A8(0xe,2,1,p2,r3,im,1,p1) +#define ZCMP_GT_AND(p1,p2,r3) A7(0xc,0,0,p2,r3,0,p1) +#define ZCMP_GT_OR(p1,p2,r3) A7(0xd,0,0,p2,r3,0,p1) +#define ZCMP_GT_ANDCM(p1,p2,r3) A7(0xe,0,0,p2,r3,0,p1) +#define ZCMP_LE_AND(p1,p2,r3) A7(0xc,0,0,p2,r3,1,p1) +#define ZCMP_LE_OR(p1,p2,r3) A7(0xd,0,0,p2,r3,1,p1) +#define ZCMP_LE_ANDCM(p1,p2,r3) A7(0xe,0,0,p2,r3,1,p1) +#define ZCMP_GE_AND(p1,p2,r3) A7(0xc,0,1,p2,r3,0,p1) +#define ZCMP_GE_OR(p1,p2,r3) A7(0xd,0,1,p2,r3,0,p1) +#define ZCMP_GE_ANDCM(p1,p2,r3) A7(0xe,0,1,p2,r3,0,p1) +#define ZCMP_LT_AND(p1,p2,r3) A7(0xc,0,1,p2,r3,1,p1) +#define ZCMP_LT_OR(p1,p2,r3) A7(0xd,0,1,p2,r3,1,p1) +#define ZCMP_LT_ANDCM(p1,p2,r3) A7(0xe,0,1,p2,r3,1,p1) +/* cmp4 */ +#define CMP4_LT(p1,p2,r2,r3) A6(0xc,1,0,p2,r3,r2,0,p1) +#define CMP4_LTU(p1,p2,r2,r3) A6(0xd,1,0,p2,r3,r2,0,p1) +#define CMP4_EQ(p1,p2,r2,r3) A6(0xe,1,0,p2,r3,r2,0,p1) +#define CMP4_LT_UNC(p1,p2,r2,r3) A6(0xc,1,0,p2,r3,r2,1,p1) +#define CMP4_LTU_UNC(p1,p2,r2,r3) A6(0xd,1,0,p2,r3,r2,1,p1) +#define CMP4_EQ_UNC(p1,p2,r2,r3) A6(0xe,1,0,p2,r3,r2,1,p1) +#define CMP4_EQ_AND(p1,p2,r2,r3) A6(0xc,1,1,p2,r3,r2,0,p1) +#define CMP4_EQ_OR(p1,p2,r2,r3) A6(0xd,1,1,p2,r3,r2,0,p1) +#define CMP4_EQ_XOR(p1,p2,r2,r3) A6(0xe,1,1,p2,r3,r2,0,p1) +#define CMP4_NE_AND(p1,p2,r2,r3) A6(0xc,1,1,p2,r3,r2,1,p1) +#define CMP4_NE_OR(p1,p2,r2,r3) A6(0xd,1,1,p2,r3,r2,1,p1) +#define CMP4_NE_XOR(p1,p2,r2,r3) A6(0xe,1,1,p2,r3,r2,1,p1) +#define CMP4I_LT(p1,p2,im,r3) A8(0xc,3,0,p2,r3,im,0,p1) +#define CMP4I_LTU(p1,p2,im,r3) A8(0xd,3,0,p2,r3,im,0,p1) +#define CMP4I_EQ(p1,p2,im,r3) A8(0xe,3,0,p2,r3,im,0,p1) +#define CMP4I_LT_UNC(p1,p2,im,r3) A8(0xc,3,0,p2,r3,im,1,p1) +#define CMP4I_LTU_UNC(p1,p2,im,r3) A8(0xd,3,0,p2,r3,im,1,p1) +#define CMP4I_EQ_UNC(p1,p2,im,r3) A8(0xe,3,0,p2,r3,im,1,p1) +#define CMP4I_EQ_AND(p1,p2,im,r3) A8(0xc,3,1,p2,r3,im,0,p1) +#define CMP4I_EQ_OR(p1,p2,im,r3) A8(0xd,3,1,p2,r3,im,0,p1) +#define CMP4I_EQ_ANDCM(p1,p2,im,r3) A8(0xe,3,1,p2,r3,im,0,p1) +#define CMP4I_NE_AND(p1,p2,im,r3) A8(0xc,3,1,p2,r3,im,1,p1) +#define CMP4I_NE_OR(p1,p2,im,r3) A8(0xd,3,1,p2,r3,im,1,p1) +#define CMP4I_NE_ANDCM(p1,p2,im,r3) A8(0xe,3,1,p2,r3,im,1,p1) +#define ZCMP4_GT_AND(p1,p2,r3) A7(0xc,1,0,p2,r3,0,p1) +#define ZCMP4_GT_OR(p1,p2,r3) A7(0xd,1,0,p2,r3,0,p1) +#define ZCMP4_GT_ANDCM(p1,p2,r3) A7(0xe,1,0,p2,r3,0,p1) +#define ZCMP4_LE_AND(p1,p2,r3) A7(0xc,1,0,p2,r3,1,p1) +#define ZCMP4_LE_OR(p1,p2,r3) A7(0xd,1,0,p2,r3,1,p1) +#define ZCMP4_LE_ANDCM(p1,p2,r3) A7(0xe,1,0,p2,r3,1,p1) +#define ZCMP4_GE_AND(p1,p2,r3) A7(0xc,1,1,p2,r3,0,p1) +#define ZCMP4_GE_OR(p1,p2,r3) A7(0xd,1,1,p2,r3,0,p1) +#define ZCMP4_GE_ANDCM(p1,p2,r3) A7(0xe,1,1,p2,r3,0,p1) +#define ZCMP4_LT_AND(p1,p2,r3) A7(0xc,1,1,p2,r3,1,p1) +#define ZCMP4_LT_OR(p1,p2,r3) A7(0xd,1,1,p2,r3,1,p1) +#define ZCMP4_LT_ANDCM(p1,p2,r3) A7(0xe,1,1,p2,r3,1,p1) +/* cmpxchg */ +#define CMPXCHG1_ACQ(r1,r3,r2) M16(0x00,LD_NONE,r3,r2,r1) +#define CMPXCHG2_ACQ(r1,r3,r2) M16(0x01,LD_NONE,r3,r2,r1) +#define CMPXCHG4_ACQ(r1,r3,r2) M16(0x02,LD_NONE,r3,r2,r1) +#define CMPXCHG8_ACQ(r1,r3,r2) M16(0x03,LD_NONE,r3,r2,r1) +#define CMPXCHG1_REL(r1,r3,r2) M16(0x04,LD_NONE,r3,r2,r1) +#define CMPXCHG2_REL(r1,r3,r2) M16(0x05,LD_NONE,r3,r2,r1) +#define CMPXCHG4_REL(r1,r3,r2) M16(0x06,LD_NONE,r3,r2,r1) +#define CMPXCHG8_REL(r1,r3,r2) M16(0x07,LD_NONE,r3,r2,r1) +#define CMP8XCHG16_ACQ(r1,r3,r2) M16(0x20,LD_NONE,r3,r2,r1) +#define CMP8XCHG16_REL(r1,r3,r2) M16(0x24,LD_NONE,r3,r2,r1) +/* cover */ +#define COVER() B8(0x02) +/* cxz */ +#define CZX1_L(r1,r3) I29(0x18,r3,r1) +#define CZX2_L(r1,r3) I29(0x19,r3,r1) +#define CZX1_R(r1,r3) I29(0x1c,r3,r1) +#define CZX2_R(r1,r3) I29(0x1d,r3,r1) +/* dep */ +#define DEP_Z(r1,r2,pos,len) I12(len,pos,r2,r1) +#define DEPI_Z(r1,im,pos,len) I13(len,pos,im,r1) +#define DEPs(r1,r2,r3,pos,len) I14(1,len,r3,pos,r1) +#define DEPu(r1,r2,r3,pos,len) I14(0,len,r3,pos,r1) +#define DEP(r1,r2,r3,pos,len) I15(pos,len,r3,r2,r1) +/* epc */ +#define EPC() B8(0x10) +/* extr */ +#define EXTR(r1,r3,pos,len) I11(len,r3,pos,1,r1) +#define EXTR_U(r1,r3,pos,len) I11(len,r3,pos,0,r1) +/* fc */ +#define FC(r3) M28(0,r3) +#define FC_I(r3) M28(1,r3) +/* fetchadd */ +#define FETCHADD4_ACQ(r1,r3,im) M17(0x12,LD_NONE,r3,im,r1) +#define FETCHADD8_ACQ(r1,r3,im) M17(0x13,LD_NONE,r3,im,r1) +#define FETCHADD4_REL(r1,r3,im) M17(0x16,LD_NONE,r3,im,r1) +#define FETCHADD8_REL(r1,r3,im) M17(0x17,LD_NONE,r3,im,r1) +/* flushrs */ +#define FLUSHRS() M25(0xc) +/* fwb */ +#define FWB() M24(2,0) +/* hint */ +#define HINT_I(im) I18(im,1) +#define HINT_M(im) M48(1,im) +#define HINT_B(im) B9(2,1,im) +#define HINT_X(im) X5(1,im) +/* invala */ +#define INVALA() M24(1,0) +#define INVALA_E(r1) M26(r1) +/* itc */ +#define ITC_I(r2) M41(0x2f,r2) +#define ITC_D(r2) M41(0x2e,r2) +/* itr */ +#define ITR_I(r3,r2) M42(0x0f,r3,r2) +#define ITR_D(r3,r2) M42(0x0e,r3,r2) +/* ld */ +#define LD1(r1,r3) M1(0x00,LD_NONE,0,r3,r1) +#define LD2(r1,r3) M1(0x01,LD_NONE,0,r3,r1) +#define LD4(r1,r3) M1(0x02,LD_NONE,0,r3,r1) +#define LD8(r1,r3) M1(0x03,LD_NONE,0,r3,r1) +#define LD1_S(r1,r3) M1(0x04,LD_NONE,0,r3,r1) +#define LD2_S(r1,r3) M1(0x05,LD_NONE,0,r3,r1) +#define LD4_S(r1,r3) M1(0x06,LD_NONE,0,r3,r1) +#define LD8_S(r1,r3) M1(0x07,LD_NONE,0,r3,r1) +#define LD1_A(r1,r3) M1(0x08,LD_NONE,0,r3,r1) +#define LD2_A(r1,r3) M1(0x09,LD_NONE,0,r3,r1) +#define LD4_A(r1,r3) M1(0x0a,LD_NONE,0,r3,r1) +#define LD8_A(r1,r3) M1(0x0b,LD_NONE,0,r3,r1) +#define LD1_SA(r1,r3) M1(0x0c,LD_NONE,0,r3,r1) +#define LD2_SA(r1,r3) M1(0x0d,LD_NONE,0,r3,r1) +#define LD4_SA(r1,r3) M1(0x0e,LD_NONE,0,r3,r1) +#define LD8_SA(r1,r3) M1(0x0f,LD_NONE,0,r3,r1) +#define LD1_BIAS(r1,r3) M1(0x10,LD_NONE,0,r3,r1) +#define LD2_BIAS(r1,r3) M1(0x11,LD_NONE,0,r3,r1) +#define LD4_BIAS(r1,r3) M1(0x12,LD_NONE,0,r3,r1) +#define LD8_BIAS(r1,r3) M1(0x13,LD_NONE,0,r3,r1) +#define LD1_ACQ(r1,r3) M1(0x14,LD_NONE,0,r3,r1) +#define LD2_ACQ(r1,r3) M1(0x15,LD_NONE,0,r3,r1) +#define LD4_ACQ(r1,r3) M1(0x16,LD_NONE,0,r3,r1) +#define LD8_ACQ(r1,r3) M1(0x17,LD_NONE,0,r3,r1) +#define LD8_FILL(r1,r3) M1(0x1b,LD_NONE,0,r3,r1) +#define LD1_C_CLR(r1,r3) M1(0x20,LD_NONE,0,r3,r1) +#define LD2_C_CLR(r1,r3) M1(0x21,LD_NONE,0,r3,r1) +#define LD4_C_CLR(r1,r3) M1(0x22,LD_NONE,0,r3,r1) +#define LD8_C_CLR(r1,r3) M1(0x23,LD_NONE,0,r3,r1) +#define LD1_C_NC(r1,r3) M1(0x24,LD_NONE,0,r3,r1) +#define LD2_C_NC(r1,r3) M1(0x25,LD_NONE,0,r3,r1) +#define LD4_C_NC(r1,r3) M1(0x26,LD_NONE,0,r3,r1) +#define LD8_C_NC(r1,r3) M1(0x27,LD_NONE,0,r3,r1) +#define LD1_C_CLR_ACQ(r1,r3) M1(0x28,LD_NONE,0,r3,r1) +#define LD2_C_CLR_ACQ(r1,r3) M1(0x29,LD_NONE,0,r3,r1) +#define LD4_C_CLR_ACQ(r1,r3) M1(0x2a,LD_NONE,0,r3,r1) +#define LD8_C_CLR_ACQ(r1,r3) M1(0x2b,LD_NONE,0,r3,r1) +#define LD16(r1,r3) M1(0x28,LD_NONE,1,r3,r1) +#define LD16_ACQ(r1,r3) M1(0x2c,LD_NONE,1,r3,r1) +#define LD1_inc(r1,r3,im) M3(0x00,LD_NONE,r3,im,r1) +#define LD2_inc(r1,r3,im) M3(0x01,LD_NONE,r3,im,r1) +#define LD4_inc(r1,r3,im) M3(0x02,LD_NONE,r3,im,r1) +#define LD8_inc(r1,r3,im) M3(0x03,LD_NONE,r3,im,r1) +#define LD1_S_inc(r1,r3,im) M3(0x04,LD_NONE,r3,im,r1) +#define LD2_S_inc(r1,r3,im) M3(0x05,LD_NONE,r3,im,r1) +#define LD4_S_inc(r1,r3,im) M3(0x06,LD_NONE,r3,im,r1) +#define LD8_S_inc(r1,r3,im) M3(0x07,LD_NONE,r3,im,r1) +#define LD1_A_inc(r1,r3,im) M3(0x08,LD_NONE,r3,im,r1) +#define LD2_A_inc(r1,r3,im) M3(0x09,LD_NONE,r3,im,r1) +#define LD4_A_inc(r1,r3,im) M3(0x0a,LD_NONE,r3,im,r1) +#define LD8_A_inc(r1,r3,im) M3(0x0b,LD_NONE,r3,im,r1) +#define LD1_SA_inc(r1,r3,im) M3(0x0c,LD_NONE,r3,im,r1) +#define LD2_SA_inc(r1,r3,im) M3(0x0d,LD_NONE,r3,im,r1) +#define LD4_SA_inc(r1,r3,im) M3(0x0e,LD_NONE,r3,im,r1) +#define LD8_SA_inc(r1,r3,im) M3(0x0f,LD_NONE,r3,im,r1) +#define LD1_BIAS_inc(r1,r3,im) M3(0x10,LD_NONE,r3,im,r1) +#define LD2_BIAS_inc(r1,r3,im) M3(0x11,LD_NONE,r3,im,r1) +#define LD4_BIAS_inc(r1,r3,im) M3(0x12,LD_NONE,r3,im,r1) +#define LD8_BIAS_inc(r1,r3,im) M3(0x13,LD_NONE,r3,im,r1) +#define LD1_ACQ_inc(r1,r3,im) M3(0x14,LD_NONE,r3,im,r1) +#define LD2_ACQ_inc(r1,r3,im) M3(0x15,LD_NONE,r3,im,r1) +#define LD4_ACQ_inc(r1,r3,im) M3(0x16,LD_NONE,r3,im,r1) +#define LD8_AVQ_inc(r1,r3,im) M3(0x17,LD_NONE,r3,im,r1) +#define LD8_FILL_inc(r1,r3,im) M3(0x1b,LD_NONE,r3,im,r1) +#define LD1_C_CLR_inc(r1,r3,im) M3(0x20,LD_NONE,r3,im,r1) +#define LD2_C_CLR_inc(r1,r3,im) M3(0x21,LD_NONE,r3,im,r1) +#define LD4_C_CLR_inc(r1,r3,im) M3(0x22,LD_NONE,r3,im,r1) +#define LD8_C_CLR_inc(r1,r3,im) M3(0x23,LD_NONE,r3,im,r1) +#define LD1_C_NC_inc(r1,r3,im) M3(0x24,LD_NONE,r3,im,r1) +#define LD2_C_NC_inc(r1,r3,im) M3(0x25,LD_NONE,r3,im,r1) +#define LD4_C_NC_inc(r1,r3,im) M3(0x26,LD_NONE,r3,im,r1) +#define LD8_C_NC_inc(r1,r3,im) M3(0x27,LD_NONE,r3,im,r1) +#define LD1_C_CLR_ACQ_inc(r1,r3,im) M3(0x28,LD_NONE,r3,im,r1) +#define LD2_C_CLR_ACQ_inc(r1,r3,im) M3(0x29,LD_NONE,r3,im,r1) +#define LD4_C_CLR_ACQ_inc(r1,r3,im) M3(0x2a,LD_NONE,r3,im,r1) +#define LD8_C_CLR_ACQ_inc(r1,r3,im) M3(0x2b,LD_NONE,r3,im,r1) +#define LDX1(r1,r3,r2) M2(0x00,LD_NONE,r3,r2,r1) +#define LDX2(r1,r3,r2) M2(0x01,LD_NONE,r3,r2,r1) +#define LDX4(r1,r3,r2) M2(0x02,LD_NONE,r3,r2,r1) +#define LDX8(r1,r3,r2) M2(0x03,LD_NONE,r3,r2,r1) +#define LDX1_S(r1,r3,r2) M2(0x04,LD_NONE,r3,r2,r1) +#define LDX2_S(r1,r3,r2) M2(0x05,LD_NONE,r3,r2,r1) +#define LDX4_S(r1,r3,r2) M2(0x06,LD_NONE,r3,r2,r1) +#define LDX8_S(r1,r3,r2) M2(0x07,LD_NONE,r3,r2,r1) +#define LDX1_A(r1,r3,r2) M2(0x08,LD_NONE,r3,r2,r1) +#define LDX2_A(r1,r3,r2) M2(0x09,LD_NONE,r3,r2,r1) +#define LDX4_A(r1,r3,r2) M2(0x0a,LD_NONE,r3,r2,r1) +#define LDX8_A(r1,r3,r2) M2(0x0b,LD_NONE,r3,r2,r1) +#define LDX1_SA(r1,r3,r2) M2(0x0c,LD_NONE,r3,r2,r1) +#define LDX2_SA(r1,r3,r2) M2(0x0d,LD_NONE,r3,r2,r1) +#define LDX4_SA(r1,r3,r2) M2(0x0e,LD_NONE,r3,r2,r1) +#define LDX8_SA(r1,r3,r2) M2(0x0f,LD_NONE,r3,r2,r1) +#define LDX1_BIAS(r1,r3,r2) M2(0x10,LD_NONE,r3,r2,r1) +#define LDX2_BIAS(r1,r3,r2) M2(0x11,LD_NONE,r3,r2,r1) +#define LDX4_BIAS(r1,r3,r2) M2(0x12,LD_NONE,r3,r2,r1) +#define LDX8_BIAS(r1,r3,r2) M2(0x13,LD_NONE,r3,r2,r1) +#define LDX1_ACQ(r1,r3,r2) M2(0x14,LD_NONE,r3,r2,r1) +#define LDX2_ACQ(r1,r3,r2) M2(0x15,LD_NONE,r3,r2,r1) +#define LDX4_ACQ(r1,r3,r2) M2(0x16,LD_NONE,r3,r2,r1) +#define LDX8_ACQ(r1,r3,r2) M2(0x17,LD_NONE,r3,r2,r1) +#define LDX8_FILL(r1,r3,r2) M2(0x1b,LD_NONE,r3,r2,r1) +#define LDX1_C_CLR(r1,r3,r2) M2(0x20,LD_NONE,r3,r2,r1) +#define LDX2_C_CLR(r1,r3,r2) M2(0x21,LD_NONE,r3,r2,r1) +#define LDX4_C_CLR(r1,r3,r2) M2(0x22,LD_NONE,r3,r2,r1) +#define LDX8_C_CLR(r1,r3,r2) M2(0x23,LD_NONE,r3,r2,r1) +#define LDX1_C_NC(r1,r3,r2) M2(0x24,LD_NONE,r3,r2,r1) +#define LDX2_C_NC(r1,r3,r2) M2(0x25,LD_NONE,r3,r2,r1) +#define LDX4_C_NC(r1,r3,r2) M2(0x26,LD_NONE,r3,r2,r1) +#define LDX8_C_NC(r1,r3,r2) M2(0x27,LD_NONE,r3,r2,r1) +#define LDX1_C_CLR_ACQ(r1,r3,r2) M2(0x28,LD_NONE,r3,r2,r1) +#define LDX2_C_CLR_ACQ(r1,r3,r2) M2(0x29,LD_NONE,r3,r2,r1) +#define LDX4_C_CLR_ACQ(r1,r3,r2) M2(0x2a,LD_NONE,r3,r2,r1) +#define LDX8_C_CLR_ACQ(r1,r3,r2) M2(0x2b,LD_NONE,r3,r2,r1) +/* lfetch */ +#define LFETCH_EXCL(r3) M13(0x2d,LF_NONE,r3,GR_0) +#define LFETCH_FAULT(r3) M13(0x2e,LF_NONE,r3,GR_0) +#define LFETCH_FAULT_EXCL(r3) M13(0x2f,LF_NONE,r3,GR_0) +#define LXFETCH(r3,r2) M14(0x2c,LF_NONE,r3,r2) +#define LXFETCH_EXCL(r3,r2) M14(0x2d,LF_NONE,r3,r2) +#define LXFETCH_FAULT(r3,r2) M14(0x2e,LF_NONE,r3,r2) +#define LXFETCH_FAULT_EXCL(r3,r2) M14(0x2f,LF_NONE,r3,r2) +#define LFETCHI(r3,im) M15(0x2c,LF_NONE,r3,im) +#define LFETCHI_EXCL(r3,im) M15(0x2d,LF_NONE,r3,im) +#define LFETCHI_FAULT(r3,im) M15(0x2e,LF_NONE,r3,im) +#define LFETCHI_FAULT_EXCL(r3,im) M15(0x2f,LF_NONE,r3,im) +/* loadrs */ +#define LOADRS() M25(0xa) +/* mf */ +#define MF() M24(2,2) +#define MF_A() M24(2,3) +/* mix */ +#define MIX1_R(r1,r2,r3) I2(0,2,0,2,0,r3,r2,r1) +#define MIX2_R(r1,r2,r3) I2(0,2,1,2,0,r3,r2,r1) +#define MIX4_R(r1,r2,r3) I2(1,2,0,2,0,r3,r2,r1) +#define MIX1_L(r1,r2,r3) I2(0,2,0,2,2,r3,r2,r1) +#define MIX2_L(r1,r2,r3) I2(0,2,1,2,2,r3,r2,r1) +#define MIX4_L(r1,r2,r3) I2(1,2,0,2,2,r3,r2,r1) +/* mov - Move Application Register */ +#define MOV_I_rn_ar(r1,ar) I28(ar,r1) +#define MOV_I_ar_rn(ar,r2) I26(ar,r2) +#define MOV_I_ar_im(ar,im) I27(ar,im) +#define MOV_M_rn_a(r1,ar) M31(r1,ar) +#define MOV_M_ar_rn(ar,r2) M29(ar,r2) +#define MOV_M_ar_im(ar,im) M30(ar,im) +/* mov - Move Branch Register */ +#define MOV_rn_br(r1,b2) I22(b2,r1) +#define MOV_br_rn_tg(b1,r2,tag) I21(tag,IH_NONE,0,MWH_NONE,r2,b1) +#define MOV_br_rn(b1,r2) MOV_br_rn_tg(b1,r2,0) +#define MOV_RET_br_rn_tg(b1,r2,tag) I21(tag,IH_NONE,1,MWH_NONE,r2,b1) +/* mov - Move Control Register */ +#define MOV_rn_cr(cr,r1) M33(cr,r1) +#define MOV_cr_rr(cr,r2) M32(cr,r2) +/* mov - Move General Register */ +#define MOV(r0,r1) ADDS(r0,0,r1) +#define MOV_p(r0,r1,_p) ADDS_p(r0,0,r1,_p) +/* mov - Move Immediate */ +#define MOVI(r1,im) ADDL(r1,im,0) +#define MOVI_p(r1,im,_p) ADDL_p(r1,im,0,_p) +/* mov - Move Indirect Register */ +#define MOV_rn_RR(r1,r3) M43(0x10,r3,r1) +#define MOV_rn_DBR(r1,r3) M43(0x11,r3,r1) +#define MOV_rn_IBR(r1,r3) M43(0x012,r3,r1) +#define MOV_rn_PKR(r1,r3) M43(0x13,r3,r1) +#define MOV_rn_PMC(r1,r3) M43(0x14,r3,r1) +#define MOV_rn_PMD(r1,r3) M43(0x15,r3,r1) +#define MOV_rn_CPUID(r1,r3) M43(0x17,r3,r1) +#define MOV_RR_rn(r3,r2) M42(0x00,r3,r2) +#define MOV_DBR_rn(r3,r2) M42(0x01,r3,r2) +#define MOV_IBR_rn(r3,r2) M42(0x02,r3,r2) +#define MOV_PKR_rn(r3,r2) M42(0x03,r3,r2) +#define MOV_PMC_rn(r3,r2) M42(0x04,r3,r2) +#define MOV_PMD_rn(r3,r2) M42(0x05,r3,r2) +/* mov - Move Instruction Pointer */ +#define MOV_rn_ip(r1) I25(0x30,r1) +/* mov - Move Predicates */ +#define MOV_rn_pr(r1) I25(0x33,r1) +#define MOV_pr_rn(r2,im) I23(r2,im) +#define MOVI_pr(im) I24(im) +/* mov - Move Processor Status Register */ +#define MOV_rn_psr(r1) M36(0x25,r1) +#define MOV_psr_l_rn(r2) M35(0x2d,r2) +/* mov - Move User Mask */ +#define MOV_rn_psr_um(r1) M36(0x21,r1) +#define MOV_psr_um_rn(r2) M35(0x29,r2) +/* movl */ +#define MOVL(r1,im) X2(r1,im) +/* mpy4 */ +#define MPY4(r1,r2,r3) I2(1,0,0,3,1,r3,r2,r1) +/* mpyshl4 */ +#define MPYSHL4(r1,r2,r3) I2(1,0,0,3,3,r3,r2,r1) +/* mux */ +#define MUX1(r1,r2,mbt) I3(mbt,r2,r1) +#define MUX2(r1,r2,mht) I4(mht,r2,r1) +/* nop */ +#define NOP_I(im) I18(im,0) +#define NOP_M(im) M48(0,im) +#define NOP_B(im) B9(2,0,im) +#define NOP_X(im) X5(0,im) +/* or */ +#define OR(r1,r2,r3) A1(3,2,r3,r2,r1) +#define ORI(r1,im,r3) A3(0xb,2,r3,im,r1) +/* pack */ +#define PACK2_USS(r1,r2,r3) I2(0,2,1,0,0,r3,r2,r1) +#define PACK2_SSS(r1,r2,r3) I2(0,2,1,0,2,r3,r2,r1) +#define PACK4_SSS(r1,r2,r3) I2(1,2,0,0,2,r3,r2,r1) +/* padd */ +#define PADD1(r1,r2,r3) A9(0,0,0,0,r3,r2,r1) +#define PADD1_SSS(r1,r2,r3) A9(0,0,0,1,r3,r2,r1) +#define PADD1_UUU(r1,r2,r3) A9(0,0,0,2,r3,r2,r1) +#define PADD1_UUS(r1,r2,r3) A9(0,0,0,3,r3,r2,r1) +#define PADD2(r1,r2,r3) A9(0,1,0,0,r3,r2,r1) +#define PADD2_SSS(r1,r2,r3) A9(0,1,0,1,r3,r2,r1) +#define PADD2_UUU(r1,r2,r3) A9(0,1,0,2,r3,r2,r1) +#define PADD2_UUS(r1,r2,r3) A9(0,1,0,3,r3,r2,r1) +#define PADD4(r1,r2,r3) A9(1,0,0,0,r3,r2,r1) +/* pavg */ +#define PAVG1(r1,r2,r3) A9(0,0,2,2,r3,r2,r1) +#define PAVG2(r1,r2,r3) A9(0,1,2,2,r3,r2,r1) +#define PAVG1_RAZ(r1,r2,r3) A9(0,0,2,3,r3,r2,r1) +#define PAVG2_RAZ(r1,r2,r3) A9(0,1,2,3,r3,r2,r1) +/* pavgsub */ +#define PAVGSUB1(r1,r2,r3) A9(0,0,3,2,r3,r2,r1) +#define PAVGSUB2(r1,r2,r3) A9(0,1,3,2,r3,r2,r1) +/* pcmp */ +#define PCMP1_EQ(r1,r2,r3) A9(0,0,9,0,r3,r2,r1) +#define PCMP2_EQ(r1,r2,r3) A9(0,1,9,0,r3,r2,r1) +#define PCMP4_EQ(r1,r2,r3) A9(1,0,9,0,r3,r2,r1) +#define PCMP1_GT(r1,r2,r3) A9(0,0,9,1,r3,r2,r1) +#define PCMP2_GT(r1,r2,r3) A9(0,1,9,1,r3,r2,r1) +#define PCMP4_GT(r1,r2,r3) A9(1,0,9,1,r3,r2,r1) +/* pmax */ +#define PMAX1_U(r1,r2,r3) I2(0,2,0,1,1,r3,r2,r1) +#define PMAX2(r1,r2,r3) I2(0,2,1,1,3,r3,r2,r1) +/* pmin */ +#define PMIN1_U(r1,r2,r3) I2(0,2,0,0,1,r3,r2,r1) +#define PMIN2(r1,r2,r3) I2(0,2,1,0,3,r3,r2,r1) +/* pmpy */ +#define PMPY2_R(r1,r2,r3) I2(0,2,1,3,1,r3,r2,r1) +#define PMPY2_L(r1,r2,r3) I2(0,2,1,3,3,r3,r2,r1) +/* pmpyshr */ +#define PMPYSHR2(r1,r2,r3,im) I1(im,3,r3,r2,r1) +#define PMPYSHR2_U(r1,r2,r3,im) I1(im,1,r3,r2,r1) +/* popcnt */ +#define POPCNT(r1,r3) I9(2,r3,r1) +/* probe */ +#define PROBE_R(r1,r3,r2) M38(0x38,r3,r2,r1) +#define PROBE_W(r1,r3,r2) M38(0x39,r3,r2,r1) +#define PROBEI_R(r1,r3,im) M39(0x18,r3,im,r1) +#define PROBEI_W(r1,r3,im) M39(0x19,r3,im,r1) +#define PROBE_RW_FAULT(r3,im) M40(0x31,r3,im) +#define PROBE_R_FAULT(r3,im) M40(0x32,r3,im) +#define PROBE_W_FAULT(r3,im) M40(0x33,r3,im) +/* psad */ +#define PSAD1(r1,r2,r3) I2(0,2,0,2,3,r3,r2,r1) +/* pshl */ +#define PSHL2(r1,r2,r3) I7(0,1,r3,r2,r1) +#define PSHL4(r1,r2,r3) I7(1,0,r3,r2,r1) +#define PSHL2I(r1,r2,im) I8(0,1,im,r2,r1) +#define PSHL4I(r1,r2,im) I8(1,0,im,r2,r1) +/* pshladd */ +#define PSHLADD2(r1,r2,im,r3) A10(4,im,r3,r2,r1) +/* pshr */ +#define PSHR2(r1,r3,r2) I5(0,1,2,r3,r2,r1) +#define PSHR2I(r1,r3,im) I6(0,1,3,r3,im,r1) +#define PSHR2_U(r1,r3,r2) I5(0,1,0,r3,r2,r1) +#define PSHR2I_U(r1,r3,im) I6(0,1,1,r3,im,r1) +#define PSHR4(r1,r3,r2) I5(1,0,2,r3,r2,r1) +#define PSHR4I(r1,r3,im) I6(1,0,3,r3,im,r1) +#define PSHR4_U(r1,r3,r2) I5(1,0,0,r3,r2,r1) +#define PSHR4I_U(r1,r3,im) I6(1,0,1,r3,im,r1) +/* pshradd */ +#define PSHRADD2(r1,r2,im,r3) A10(6,im,r3,r2,r1) +/* psub */ +#define PSUB1(r1,r2,r3) A9(0,0,1,0,r3,r2,r1) +#define PSUB1_SSS(r1,r2,r3) A9(0,0,1,1,r3,r2,r1) +#define PSUB1_UUU(r1,r2,r3) A9(0,0,1,2,r3,r2,r1) +#define PSUB1_UUS(r1,r2,r3) A9(0,0,1,3,r3,r2,r1) +#define PSUB2(r1,r2,r3) A9(0,1,1,0,r3,r2,r1) +#define PSUB2_SSS(r1,r2,r3) A9(0,1,1,1,r3,r2,r1) +#define PSUB2_UUU(r1,r2,r3) A9(0,1,1,2,r3,r2,r1) +#define PSUB2_UUS(r1,r2,r3) A9(0,1,1,3,r3,r2,r1) +#define PSUB4(r1,r2,r3) A9(1,0,1,0,r3,r2,r1) +/* ptc.e */ +#define PTC_E(r3) M47(0x34,r3) +/* ptc.g, ptc.ga */ +#define PTC_G(r3,r2) M45(0xa,r3,r2) +#define PTC_GA(r3,r2) M45(0xb,r3,r2) +/* ptc.l */ +#define PTC_L(r3,r2) M45(0x9,r3,r2) +/* ptr */ +#define PTR_D(r3,r2) M45(0xc,r3,r2) +#define PTR_I(r3,r2) M45(0xd,r3,r2) +/* rfi */ +#define RFI() B8(0x08) +/* rsm */ +#define RSM(im) M44(7,im) +/* rum */ +#define RUM(im) M44(5,im) +/* shl */ +#define SHL(r1,r2,r3) I7(1,1,r3,r2,r1) +/* shladd */ +#define SHLADD(r1,r2,im,r3) A2(4,im,r3,r2,r1) +/* shladdp4 */ +#define SHLADDP4(r1,r2,im,r3) A2(6,im,r3,r2,r1) +/* shr */ +#define SHR(r1,r3,r2) I5(1,1,2,r3,r2,r1) +#define SHR_U(r1,r3,r2) I5(1,1,0,r3,r2,r1) +/* shrp */ +#define SHRP(r1,r2,r3,im) I10(im,r3,r2,r1) +/* srlz */ +#define SRLZ_I() M24(3,1) +#define SRLZ_D() M24(3,0) +/* ssm */ +#define SSM(im) M44(6,im) +/* st */ +#define ST1(r3,r2) M6(0x30,ST_NONE,0,r3,r2) +#define ST2(r3,r2) M6(0x31,ST_NONE,0,r3,r2) +#define ST4(r3,r2) M6(0x32,ST_NONE,0,r3,r2) +#define ST8(r3,r2) M6(0x33,ST_NONE,0,r3,r2) +#define ST1_REL(r3,r2) M6(0x34,ST_NONE,0,r3,r2) +#define ST2_REL(r3,r2) M6(0x35,ST_NONE,0,r3,r2) +#define ST4_REL(r3,r2) M6(0x36,ST_NONE,0,r3,r2) +#define ST8_REL(r3,r2) M6(0x37,ST_NONE,0,r3,r2) +#define ST8_SPILL(r3,r2) M6(0x3b,ST_NONE,0,r3,r2) +#define ST16(r3,r2) M6(0x30,ST_NONE,1,r3,r2) +#define ST16_REL(r3,r2) M6(0x34,ST_NONE,1,r3,r2) +#define ST1_inc(r3,r2,im) M5(0x30,ST_NONE,r3,r2,im) +#define ST2_inc(r3,r2,im) M5(0x31,ST_NONE,r3,r2,im) +#define ST4_inc(r3,r2,im) M5(0x32,ST_NONE,r3,r2,im) +#define ST8_inc(r3,r2,im) M5(0x33,ST_NONE,r3,r2,im) +#define ST1_REL_inc(r3,r2,im) M5(0x34,ST_NONE,r3,r2,im) +#define ST2_REL_inc(r3,r2,im) M5(0x35,ST_NONE,r3,r2,im) +#define ST4_REL_inc(r3,r2,im) M5(0x36,ST_NONE,r3,r2,im) +#define ST8_REL_inc(r3,r2,im) M5(0x37,ST_NONE,r3,r2,im) +#define ST8_SPILL_inc(r3,r2,im) M5(0x3b,ST_NONE,r3,r2,im) +/* sub */ +#define SUB(r1,r2,r3) A1(1,1,r3,r2,r1) +#define SUB1(r1,r2,r3) A1(1,0,r3,r2,r1) +#define SUBI(r1,im,r3) A3(9,1,r3,im,r1) +/* sum */ +#define SUM(im) M44(4,im) +/* sxt */ +#define SXT1(r1,r3) I29(0x14,r3,r1) +#define SXT2(r1,r3) I29(0x15,r3,r1) +#define SXT4(r1,r3) I29(0x16,r3,r1) +/* sync */ +#define SYNC_I() M24(3,3) +/* tak */ +#define TAK(r1,r3) M46(0x1f,r3,r1) +/* tbit */ +#define TBIT_Z(p1,p2,r3,pos) I16(0,0,p2,r3,pos,0,p1) +#define TBIT_Z_UNC(p1,p2,r3,pos) I16(0,0,p2,r3,pos,1,p1) +#define TBIT_Z_AND(p1,p2,r3,pos) I16(1,0,p2,r3,pos,0,p1) +#define TBIT_NZ_AND(p1,p2,r3,pos) I16(1,0,p2,r3,pos,1,p1) +#define TBIT_Z_OR(p1,p2,r3,pos) I16(0,1,p2,r3,pos,0,p1) +#define TBIT_NZ_OR(p1,p2,r3,pos) I16(0,1,p2,r3,pos,1,p1) +#define TBIT_Z_ANDCM(p1,p2,r3,pos) I16(1,1,p2,r3,pos,0,p1) +#define TBIT_NZ_ANDCM(p1,p2,r3,pos) I16(1,1,p2,r3,pos,1,p1) +/* tf */ +#define TF_Z(p1,p2,im) I30(0,0,p2,im,0,p1) +#define TF_Z_UNC(p1,p2,im) I30(0,0,p2,im,1,p1) +#define TF_Z_AND(p1,p2,im) I30(1,0,p2,im,0,p1) +#define TF_NZ_AND(p1,p2,im) I30(1,0,p2,im,1,p1) +#define TF_Z_OR(p1,p2,im) I30(0,1,p2,im,0,p1) +#define TF_NZ_OR(p1,p2,im) I30(0,1,p2,im,1,p1) +#define TF_Z_ANDCM(p1,p2,im) I30(1,1,p2,im,0,p1) +#define TF_NZ_ANDCM(p1,p2,im) I30(1,1,p2,im,1,p1) +/* thash */ +#define THASH(r1,r3) M46(0x1a,r3,r1) +/* tnat */ +#define TNAT_Z(p1,p2,r3) I17(0,0,p2,r3,0,p1) +#define TNAT_Z_UNC(p1,p2,r3) I17(0,0,p2,r3,1,p1) +#define TNAT_Z_AND(p1,p2,r3) I17(1,0,p2,r3,0,p1) +#define TNAT_NZ_AND(p1,p2,r3) I17(1,0,p2,r3,1,p1) +#define TNAT_Z_OR(p1,p2,r3) I17(0,1,p2,r3,0,p1) +#define TNAT_NZ_OR(p1,p2,r3) I17(0,1,p2,r3,1,p1) +#define TNAT_Z_ANDCM(p1,p2,r3) I17(1,1,p2,r3,0,p1) +#define TNAT_NZ_ANDCM(p1,p2,r3) I17(1,1,p2,r3,1,p1) +/* tpa */ +#define TPA(r1,r3) M46(0x1e,r3,r1) +/* ttag */ +#define TTAG(r1,r3) M46(0x1b,r3,r1) +/* unpack */ +#define UNPACK1_H(r1,r2,r3) I2(0,2,0,1,0,r3,r2,r1) +#define UNPACK2_H(r1,r2,r3) I2(0,2,1,1,0,r3,r2,r1) +#define UNPACK4_H(r1,r2,r3) I2(1,2,0,1,0,r3,r2,r1) +#define UNPACK1_L(r1,r2,r3) I2(0,2,0,1,2,r3,r2,r1) +#define UNPACK2_L(r1,r2,r3) I2(0,2,1,1,2,r3,r2,r1) +#define UNPACK4_L(r1,r2,r3) I2(1,2,0,1,2,r3,r2,r1) +/* vmsw */ +#define VMSW_0() B8(0x18) +#define VMSW_1() B8(0x19) +/* xchg */ +#define XCHG1_ACQ(r1,r3,r2) M16(0x08,LD_NONE,r3,r2,r1) +#define XCHG2_ACQ(r1,r3,r2) M16(0x09,LD_NONE,r3,r2,r1) +#define XCHG4_ACQ(r1,r3,r2) M16(0x0a,LD_NONE,r3,r2,r1) +#define XCHG8_ACQ(r1,r3,r2) M16(0x0b,LD_NONE,r3,r2,r1) +/* xor */ +#define XOR(r1,r2,r3) A1(3,3,r3,r2,r1) +#define XORI(r1,im,r3) A3(0xb,3,r3,im,r1) +/* zxt */ +#define ZXT1(r1,r3) I29(0x10,r3,r1) +#define ZXT2(r1,r3) I29(0x11,r3,r1) +#define ZXT4(r1,r3) I29(0x12,r3,r1) + +#define addr(r0,r1,r2) ADD(r0,r1,r2) +#define addi(r0,r1,i0) _addi(_jit,r0,r1,i0) +static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2) +static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); +#define addci(r0, r1, i0) _addci(_jit, r0, r1, i0) +static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2) +static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); +# define addxi(r0, r1, i0) _addxi(_jit, r0, r1, i0) +static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define subr(r0,r1,r2) SUB(r0,r1,r2) +#define subi(r0,r1,i0) _subi(_jit,r0,r1,i0) +static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2) +static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define subci(r0, r1, i0) _subci(_jit, r0, r1, i0) +static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2) +static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define subxi(r0, r1, i0) _subxi(_jit, r0, r1, i0) +static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2) +static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) +static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define divr(r0,r1,r2) _divr(_jit,r0,r1,r2) +static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define divi(r0,r1,i0) _divi(_jit,r0,r1,i0) +static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2) +static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0) +static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define remr(r0,r1,r2) _remr(_jit,r0,r1,r2) +static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define remi(r0,r1,i0) _remi(_jit,r0,r1,i0) +static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2) +static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0) +static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define mulh(r0,r1,r2,sign) _mulh(_jit,r0,r1,r2,sign) +static void _mulh(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1) +#define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0) +#define iqmulr(r0,r1,r2,r3,sign) _iqmulr(_jit,r0,r1,r2,r3,sign) +static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_bool_t); +#define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1) +#define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0) +#define iqmuli(r0,r1,r2,i0,sign) _iqmuli(_jit,r0,r1,r2,i0,sign) +static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_word_t,jit_bool_t); +#define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1) +#define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0) +#define iqdivr(r0,r1,r2,r3,sign) _iqdivr(_jit,r0,r1,r2,r3,sign) +static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_bool_t); +#define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1) +#define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0) +#define iqdivi(r0,r1,r2,i0,sign) _iqdivi(_jit,r0,r1,r2,i0,sign) +static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_word_t,jit_bool_t); +#define andr(r0,r1,r2) AND(r0,r1,r2) +#define andi(r0,r1,i0) _andi(_jit,r0,r1,i0) +static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define orr(r0,r1,r2) OR(r0,r1,r2) +#define ori(r0,r1,i0) _ori(_jit,r0,r1,i0) +static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define xorr(r0,r1,r2) XOR(r0,r1,r2) +#define xori(r0,r1,i0) _xori(_jit,r0,r1,i0) +static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define lshr(r0,r1,r2) SHL(r0,r1,r2) +#define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0) +static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define rshr(r0,r1,r2) SHR(r0,r1,r2) +#define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0) +static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define rshr_u(r0,r1,r2) SHR_U(r0,r1,r2) +#define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) +static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2) +static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lti(r0,r1,i0) _lti(_jit,r0,r1,i0) +static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2) +static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0) +static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ler(r0,r1,r2) _ler(_jit,r0,r1,r2) +static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lei(r0,r1,i0) _lei(_jit,r0,r1,i0) +static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2) +static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0) +static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2) +static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0) +static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ger(r0,r1,r2) _ger(_jit,r0,r1,r2) +static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define gei(r0,r1,i0) _gei(_jit,r0,r1,i0) +static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2) +static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0) +static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2) +static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define gti(r0,r1,i0) _gti(_jit,r0,r1,i0) +static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2) +static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0) +static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ner(r0,r1,r2) _ner(_jit,r0,r1,r2) +static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define nei(r0,r1,i0) _nei(_jit,r0,r1,i0) +static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define negr(r0,r1) subr(r0,0,r1) +#define comr(r0,r1) ANDCMI(r0,-1,r1) +#define movr(r0,r1) _movr(_jit,r0,r1) +static void _movr(jit_state_t*,jit_int32_t,jit_int32_t); +#define movi(r0,i0) _movi(_jit,r0,i0) +static void _movi(jit_state_t*,jit_int32_t,jit_word_t); +#define movi_p(r0,i0) _movi_p(_jit,r0,i0) +static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t); +#define htonr(r0,r1) MUX1(r0,r1,MUX_REV) +#define extr_c(r0,r1) SXT1(r0,r1) +#define extr_uc(r0,r1) ZXT1(r0,r1) +#define extr_s(r0,r1) SXT2(r0,r1) +#define extr_us(r0,r1) ZXT2(r0,r1) +#define extr_i(r0,r1) SXT4(r0,r1) +#define extr_ui(r0,r1) ZXT4(r0,r1) +#define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1) +static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define blti(i0,r0,i1) _blti(_jit,i0,r0,i1) +static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1) +static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1) +static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bler(i0,r0,r1) _bler(_jit,i0,r0,r1) +static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define blei(i0,r0,i1) _blei(_jit,i0,r0,i1) +static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1) +static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1) +static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1) +static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1) +static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bger(i0,r0,r1) _bger(_jit,i0,r0,r1) +static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1) +static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1) +static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1) +static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1) +static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1) +static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1) +static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1) +static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bner(i0,r0,r1) _bner(_jit,i0,r0,r1) +static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1) +static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1) +static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1) +static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1) +static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1) +static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define baddr(i0,r0,r1,cc) _baddr(_jit,i0,r0,r1,cc) +static jit_word_t _baddr(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_bool_t); +#define baddi(i0,r0,i1,cc) _baddi(_jit,i0,r0,i1,cc) +static jit_word_t _baddi(jit_state_t*,jit_word_t, + jit_int32_t,jit_word_t,jit_bool_t); +#define baddr_u(i0,r0,r1,cc) _baddr_u(_jit,i0,r0,r1,cc) +static jit_word_t _baddr_u(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_bool_t); +#define baddi_u(i0,r0,i1,cc) _baddi_u(_jit,i0,r0,i1,cc) +static jit_word_t _baddi_u(jit_state_t*,jit_word_t, + jit_int32_t,jit_word_t,jit_bool_t); +#define bsubr(i0,r0,r1,cc) _bsubr(_jit,i0,r0,r1,cc) +static jit_word_t _bsubr(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_bool_t); +#define bsubi(i0,r0,i1,cc) _bsubi(_jit,i0,r0,i1,cc) +static jit_word_t _bsubi(jit_state_t*,jit_word_t, + jit_int32_t,jit_word_t,jit_bool_t); +#define bsubr_u(i0,r0,r1,cc) _bsubr_u(_jit,i0,r0,r1,cc) +static jit_word_t _bsubr_u(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_bool_t); +#define bsubi_u(i0,r0,i1,cc) _bsubi_u(_jit,i0,r0,i1,cc) +static jit_word_t _bsubi_u(jit_state_t*,jit_word_t, + jit_int32_t,jit_word_t,jit_bool_t); +#define boaddr(i0,r0,r1) baddr(i0,r0,r1,1) +#define boaddi(i0,r0,i1) baddi(i0,r0,i1,1) +#define boaddr_u(i0,r0,r1) baddr_u(i0,r0,r1,1) +#define boaddi_u(i0,r0,i1) baddi_u(i0,r0,i1,1) +#define bxaddr(i0,r0,r1) baddr(i0,r0,r1,0) +#define bxaddi(i0,r0,i1) baddi(i0,r0,i1,0) +#define bxaddr_u(i0,r0,r1) baddr_u(i0,r0,r1,0) +#define bxaddi_u(i0,r0,i1) baddi_u(i0,r0,i1,0) +#define bosubr(i0,r0,r1) bsubr(i0,r0,r1,1) +#define bosubi(i0,r0,i1) bsubi(i0,r0,i1,1) +#define bosubr_u(i0,r0,r1) bsubr_u(i0,r0,r1,1) +#define bosubi_u(i0,r0,i1) bsubi_u(i0,r0,i1,1) +#define bxsubr(i0,r0,r1) bsubr(i0,r0,r1,0) +#define bxsubi(i0,r0,i1) bsubi(i0,r0,i1,0) +#define bxsubr_u(i0,r0,r1) bsubr_u(i0,r0,r1,0) +#define bxsubi_u(i0,r0,i1) bsubi_u(i0,r0,i1,0) +#define ldr_c(r0,r1) LD1_S(r0,r1) +#define ldi_c(r0,i0) _ldi_c(_jit,r0,i0) +static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t); +#define ldr_uc(r0,r1) LD1(r0,r1) +#define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0) +static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t); +#define ldr_s(r0,r1) LD2_S(r0,r1) +#define ldi_s(r0,i0) _ldi_s(_jit,r0,i0) +static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t); +#define ldr_us(r0,r1) LD2(r0,r1) +#define ldi_us(r0,i0) _ldi_us(_jit,r0,i0) +static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t); +#define ldr_i(r0,r1) LD4_S(r0,r1) +#define ldi_i(r0,i0) _ldi_i(_jit,r0,i0) +static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t); +#define ldr_ui(r0,r1) LD4(r0,r1) +#define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0) +static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t); +#define ldr_l(r0,r1) LD8(r0,r1) +#define ldi_l(r0,i0) _ldi_l(_jit,r0,i0) +static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2) +static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0) +static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2) +static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0) +static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2) +static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0) +static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_us(r0,r1,r2) _ldxr_us(_jit,r0,r1,r2) +static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0) +static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_i(r0,r1,r2) _ldxr_i(_jit,r0,r1,r2) +static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0) +static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_ui(r0,r1,r2) _ldxr_ui(_jit,r0,r1,r2) +static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0) +static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2) +static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0) +static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define str_c(r0,r1) ST1(r0,r1) +#define sti_c(i0,r0) _sti_c(_jit,i0,r0) +static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t); +#define str_s(r0,r1) ST2(r0,r1) +#define sti_s(i0,r0) _sti_s(_jit,i0,r0) +static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t); +#define str_i(r0,r1) ST4(r0,r1) +#define sti_i(i0,r0) _sti_i(_jit,i0,r0) +static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t); +#define str_l(r0,r1) ST8(r0,r1) +#define sti_l(i0,r0) _sti_l(_jit,i0,r0) +static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t); +#define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2) +static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1) +static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2) +static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1) +static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2) +static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1) +static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2) +static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1) +static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define jmpr(r0) _jmpr(_jit,r0) +static void _jmpr(jit_state_t*,jit_int32_t); +#define jmpi(i0) _jmpi(_jit,i0) +static void _jmpi(jit_state_t*,jit_word_t); +#define jmpi_p(i0) _jmpi_p(_jit,i0) +static jit_word_t _jmpi_p(jit_state_t*,jit_word_t); +#define callr(r0) _callr(_jit,r0) +static void _callr(jit_state_t*,jit_int32_t); +#define calli(i0) _calli(_jit,i0) +static void _calli(jit_state_t*,jit_word_t); +#define calli_p(i0) _calli_p(_jit,i0) +static jit_word_t _calli_p(jit_state_t*,jit_word_t); +#define prolog(node) _prolog(_jit,node) +static void _prolog(jit_state_t*,jit_node_t*); +#define epilog(node) _epilog(_jit,node) +static void _epilog(jit_state_t*,jit_node_t*); +#define patch_at(node,instr,label) _patch_at(_jit,node,instr,label) +static void _patch_at(jit_state_t*,jit_node_t*,jit_word_t,jit_word_t); +#endif + +#if CODE +static void +_out(jit_state_t *_jit, int n, int tm, + jit_word_t s0, jit_word_t s1, jit_word_t s2) +{ + int i; + inst_lo_t l; + inst_hi_t h; + jit_word_t *w; + to_tm(tm); + to_s0(s0); + to_s1(s1); + to_s2(s2); + il(l.w); + il(h.w); + w = (jit_word_t *)_jitc->inst; + for (i = n; i < _jitc->ioff; i++) + w[i - n] = w[i]; + _jitc->ioff -= n; +} + +#define nop_m 0x0008000000L +#define nop_i 0x0008000000L +#define nop_b 0x4000000000L +static void +_stop(jit_state_t *_jit) +{ + /* Clear set of live registers */ + jit_regset_set_ui(&_jitc->gprs, 0); + jit_regset_set_ui(&_jitc->fprs, 0); + /* Flag a stop is required */ + if (_jitc->ioff) + _jitc->inst[_jitc->ioff - 1].t |= INST_STOP; + else + inst(nop_m, INST_Ms); +} + +static void +_sync(jit_state_t *_jit) +{ + /* Taken branches are supposed to not need a stop, so, it + * should not be required to stop if no registers live in + * sequential code */ + if (jit_regset_cmp_ui(&_jitc->gprs, 0) != 0 || + jit_regset_cmp_ui(&_jitc->fprs, 0) != 0) + stop(); + do + flush(); + while (_jitc->ioff); +} + +#define A_0 INST_A +#define As0 INST_As +#define I_0 INST_I +#define Is0 INST_Is +#define M_0 INST_M +#define Ms0 INST_Ms +#define F_0 INST_F +#define Fs0 INST_Fs +#define B_0 INST_B +#define Bs0 INST_Bs +#define L_0 INST_L +#define Ls0 INST_Ls +#define X_0 INST_X +#define Xs0 INST_Xs +#define A_1 (INST_A<<4) +#define As1 (INST_As<<4) +#define I_1 (INST_I<<4) +#define Is1 (INST_Is<<4) +#define M_1 (INST_M<<4) +#define Ms1 (INST_Ms<<4) +#define F_1 (INST_F<<4) +#define Fs1 (INST_Fs<<4) +#define B_1 (INST_B<<4) +#define Bs1 (INST_Bs<<4) +#define L_1 (INST_L<<4) +#define Ls1 (INST_Ls<<4) +#define X_1 (INST_X<<4) +#define Xs1 (INST_Xs<<4) +#define A_2 (INST_A<<8) +#define As2 (INST_As<<8) +#define I_2 (INST_I<<8) +#define Is2 (INST_Is<<8) +#define M_2 (INST_M<<8) +#define Ms2 (INST_Ms<<8) +#define F_2 (INST_F<<8) +#define Fs2 (INST_Fs<<8) +#define B_2 (INST_B<<8) +#define Bs2 (INST_Bs<<8) +#define L_2 (INST_L<<8) +#define Ls2 (INST_Ls<<8) +#define X_2 (INST_X<<8) +#define Xs2 (INST_Xs<<8) + +#define I_ I_0 +#define I_I_ I_0|I_1 +#define I_Is I_0|Is1 +#define I_B_ I_0|B_1 +#define I_Bs I_0|Bs1 +#define Is Is0 +#define IsI_ Is0|I_1 +#define IsIs Is0|Is1 +#define M_ M_0 +#define M_I_ M_0|I_1 +#define M_Is M_0|Is1 +#define M_M_ M_0|M_1 +#define M_Ms M_0|Ms1 +#define M_F_ M_0|F_1 +#define M_Fs M_0|Fs1 +#define M_B_ M_0|B_1 +#define M_Bs M_0|Bs1 +#define M_I_I_ M_0|I_1|I_2 +#define M_I_Is M_0|I_1|Is2 +#define M_I_B_ M_0|I_1|B_2 +#define M_I_Bs M_0|I_1|Bs2 +#define M_IsI_ M_0|Is1|I_2 +#define M_IsIs M_0|Is1|Is2 +#define M_M_I_ M_0|M_1|I_2 +#define M_M_Is M_0|M_1|Is2 +#define M_M_F_ M_0|M_1|F_2 +#define M_M_Fs M_0|M_1|Fs2 +#define M_M_B_ M_0|M_1|B_2 +#define M_M_Bs M_0|M_1|Bs2 +#define M_F_I_ M_0|F_1|I_2 +#define M_F_Is M_0|F_1|Is2 +#define M_F_B_ M_0|F_1|B_2 +#define M_F_Bs M_0|F_1|Bs2 +#define M_B_B_ M_0|B_1|B_2 +#define M_B_Bs M_0|B_1|Bs2 +#define M_L_X_ M_0|L_1|X_2 +#define M_L_Xs M_0|L_1|Xs2 +#define Ms Ms0 +#define MsI_ Ms0|I_1 +#define MsIs Ms0|Is1 +#define MsM_ Ms0|M_1 +#define MsMs Ms0|Ms1 +#define MsM_I_ Ms0|M_1|I_2 +#define MsM_Is Ms0|M_1|Is2 +#define F_ F_0 +#define F_I_ F_0|I_1 +#define F_Is F_0|Is1 +#define F_B_ F_0|B_1 +#define F_Bs F_0|Bs1 +#define Fs Fs0 +#define B_ B_0 +#define B_B_ B_0|B_1 +#define B_Bs B_0|Bs1 +#define B_B_B_ B_0|B_1|B_2 +#define B_B_Bs B_0|B_1|Bs2 +#define Bs Bs0 +#define L_X_ L_0|X_1 +#define L_Xs L_0|Xs1 + +static jit_word_t +templat(jit_word_t cc) +{ + switch (cc) { + case I_: + case I_I_: case I_Is: + case I_B_: case I_Bs: + case Is: + case IsI_: case IsIs: + case M_: + case M_I_: case M_Is: + case M_M_: case M_Ms: + case M_F_: case M_Fs: + case M_B_: case M_Bs: + case M_I_I_: case M_I_Is: + case M_I_B_: case M_I_Bs: + case M_IsI_: case M_IsIs: + case M_M_I_: case M_M_Is: + case M_M_F_: case M_M_Fs: + case M_M_B_: case M_M_Bs: + case M_F_I_: case M_F_Is: + case M_F_B_: case M_F_Bs: + case M_B_B_: case M_B_Bs: + case M_L_X_: case M_L_Xs: + case Ms: + case MsI_: case MsIs: + case MsM_: case MsMs: + case MsM_I_: case MsM_Is: + case F_: + case F_I_: case F_Is: + case F_B_: case F_Bs: + case Fs: + case B_: + case B_B_: case B_Bs: + case B_B_B_: case B_B_Bs: + case Bs: + case L_X_: case L_Xs: + return (cc); + default: + return (0); + } +} + +/* match* functions recurse attempting to find a template for A- + * instructions, that may be executed in M- or I- unit. + * It also uses an heuristic of trying first M- for slot 0 and 2, + * and I- for slot 1, but tries all possible matches. + */ +static jit_word_t +match_2(jit_word_t cc) +{ + jit_word_t t; + if ((t = templat(cc | M_2))) + return (t); + if ((t = templat(cc | I_2))) + return (t); + return (0); +} + +static jit_word_t +matchs2(jit_word_t cc) +{ + jit_word_t t; + if ((t = templat(cc | Ms2))) + return (t); + if ((t = templat(cc | Is2))) + return (t); + return (0); +} + +static jit_word_t +match2(jit_word_t cc) +{ + if ((cc & 0xf00) == A_2) + return (match_2(cc & ~0xf00)); + if ((cc & 0xf00) == As2) + return (matchs2(cc & ~0xf00)); + return (0); +} + +static jit_word_t +match_1(jit_word_t cc) +{ + jit_word_t t; + if ((t = templat(cc | I_1))) + return (t); + if ((t = templat(cc | M_1))) + return (t); + if ((t = match2(cc | I_1))) + return (t); + if ((t = match2(cc | M_1))) + return (t); + return (0); +} + +static jit_word_t +matchs1(jit_word_t cc) +{ + jit_word_t t; + if ((t = templat(cc | Is1))) + return (t); + if ((t = templat(cc | Ms1))) + return (t); + if ((t = match2(cc | Is1))) + return (t); + if ((t = match2(cc | Ms1))) + return (t); + return (0); +} + +static jit_word_t +match1(jit_word_t cc) +{ + if ((cc & 0x0f0) == A_1) + return (match_1(cc & ~0x0f0)); + if ((cc & 0x0f0) == As1) + return (matchs1(cc & ~0x0f0)); + return (0); +} + +static jit_word_t +match_0(jit_word_t cc) +{ + jit_word_t t; + if ((t = templat(cc | M_0))) + return (t); + if ((t = templat(cc | I_0))) + return (t); + if ((t = match1(cc | M_0))) + return (t); + if ((t = match1(cc | I_0))) + return (t); + return (0); +} + +static jit_word_t +matchs0(jit_word_t cc) +{ + jit_word_t t; + if ((t = templat(cc | Ms0))) + return (t); + if ((t = templat(cc | Is0))) + return (t); + if ((t = match1(cc | Ms0))) + return (t); + if ((t = match1(cc | Is0))) + return (t); + return (0); +} + +static jit_word_t +match0(jit_word_t cc) +{ + if ((cc & 0x00f) == A_0) + return (match_0(cc & ~0x00f)); + if ((cc & 0x00f) == As0) + return (matchs0(cc & ~0x00f)); + return (0); +} + +static void +_flush(jit_state_t *_jit) +{ + int n, soff; + jit_word_t t, cc, tm, s0, s1, s2; + + if (!_jitc->ioff) + return; + for (cc = 0, n = soff = 0; n < _jitc->ioff; n++, soff += 4) + cc |= (jit_uword_t)(_jitc->inst[n].t) << soff; + + soff = 0xf00; + while (soff) { + /* Try to find a template, or reduce down + * to one instruction if no template match */ + if ((t = templat(cc))) { + cc = t; + break; + } + /* A- instructions may be execute in M- or I- unit */ + if ((t = match0(cc))) { + cc = t; + break; + } + cc &= ~soff; + soff >>= 4; + } + assert(soff); + + /* Prefer tail nop if need to add some nop, so that patching is easier */ +#define ii(n) _jitc->inst[n].i + switch (cc) { + case I_: + n = 1; tm = TM_M_I_I_; + s0 = nop_m; s1 = ii(0); s2 = nop_i; + break; + case I_I_: + n = 2; tm = TM_M_I_I_; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case I_Is: + n = 2; tm = TM_M_I_Is; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case I_B_: + n = 2; tm = TM_M_I_B_; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case I_Bs: + n = 2; tm = TM_M_I_Bs; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case Is: + n = 1; tm = TM_M_IsI_; + s0 = nop_m; s1 = ii(0); s2 = nop_i; + break; + case IsI_: + n = 2; tm = TM_M_IsI_; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case IsIs: + n = 2; tm = TM_M_IsIs; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case M_: + n = 1; tm = TM_M_I_I_; + s0 = ii(0); s1 = nop_i; s2 = nop_i; + break; + case M_I_: + n = 2; tm = TM_M_I_I_; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case M_Is: + n = 2; tm = TM_M_IsI_; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case M_M_: + n = 2; tm = TM_M_M_I_; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case M_Ms: + n = 2; tm = TM_M_M_Is; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case M_F_: + n = 2; tm = TM_M_F_I_; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case M_Fs: + n = 2; tm = TM_M_F_Is; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case M_B_: + n = 2; tm = TM_M_B_B_; + s0 = ii(0); s1 = ii(1); s2 = nop_b; + break; + case M_Bs: + n = 2; tm = TM_M_B_Bs; + s0 = ii(0); s1 = ii(1); s2 = nop_b; + break; + case M_I_I_: + n = 3; tm = TM_M_I_I_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_I_Is: + n = 3; tm = TM_M_I_Is; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_I_B_: + n = 3; tm = TM_M_I_B_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_I_Bs: + n = 3; tm = TM_M_I_Bs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_IsI_: + n = 3; tm = TM_M_IsI_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_IsIs: + n = 3; tm = TM_M_IsIs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_M_I_: + n = 3; tm = TM_M_M_I_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_M_Is: + n = 3; tm = TM_M_M_Is; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_M_F_: + n = 3; tm = TM_M_M_F_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_M_Fs: + n = 3; tm = TM_M_M_Fs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_M_B_: + n = 3; tm = TM_M_M_B_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_M_Bs: + n = 3; tm = TM_M_M_Bs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_F_I_: + n = 3; tm = TM_M_F_I_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_F_Is: + n = 3; tm = TM_M_F_Is; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_F_B_: + n = 3; tm = TM_M_F_B_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_F_Bs: + n = 3; tm = TM_M_F_Bs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_B_B_: + n = 3; tm = TM_M_B_B_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_B_Bs: + n = 3; tm = TM_M_B_Bs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_L_X_: + n = 3; tm = TM_M_L_X_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case M_L_Xs: + n = 3; tm = TM_M_L_Xs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case Ms: + n = 1; tm = TM_MsM_I_; + s0 = ii(0); s1 = nop_m; s2 = nop_i; + break; + case MsI_: + n = 2; tm = TM_MsM_I_; + s0 = ii(0); s1 = nop_m; s2 = ii(1); + break; + case MsIs: + n = 2; tm = TM_MsM_Is; + s0 = ii(0); s1 = nop_m; s2 = ii(1); + break; + case MsM_: + n = 2; tm = TM_MsM_I_; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case MsMs: + n = 2; tm = TM_MsM_I_; + s0 = ii(0); s1 = ii(1); s2 = nop_i; + break; + case MsM_I_: + n = 3; tm = TM_MsM_I_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case MsM_Is: + n = 3; tm = TM_MsM_Is; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case F_: + n = 1; tm = TM_M_F_I_; + s0 = nop_m; s1 = ii(0); s2 = nop_i; + break; + case F_I_: + n = 2; tm = TM_M_F_I_; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case F_Is: + n = 2; tm = TM_M_F_Is; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case F_B_: + n = 2; tm = TM_M_F_B_; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case F_Bs: + n = 2; tm = TM_M_F_Bs; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case Fs: + n = 1; tm = TM_M_F_Is; + s0 = nop_m; s1 = ii(0); s2 = nop_i; + break; + case B_: + n = 1; tm = TM_B_B_B_; + s0 = ii(0); s1 = nop_b; s2 = nop_b; + break; + case B_B_: + n = 2; tm = TM_B_B_B_; + s0 = ii(0); s1 = ii(1); s2 = nop_b; + break; + case B_Bs: + n = 2; tm = TM_B_B_Bs; + s0 = ii(0); s1 = ii(1); s2 = nop_b; + break; + case B_B_B_: + n = 3; tm = TM_B_B_B_; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case B_B_Bs: + n = 3; tm = TM_B_B_Bs; + s0 = ii(0); s1 = ii(1); s2 = ii(2); + break; + case Bs: + n = 1; tm = TM_B_B_Bs; + s0 = ii(0); s1 = nop_b; s2 = nop_b; + break; + case L_X_: + n = 2; tm = TM_M_L_X_; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + case L_Xs: + n = 2; tm = TM_M_L_Xs; + s0 = nop_m; s1 = ii(0); s2 = ii(1); + break; + default: + abort(); + } + out(n, tm, s0, s1, s2); +} + +static void +_inst(jit_state_t *_jit, jit_word_t i, jit_uint8_t t) +{ + if (_jitc->ioff > 2) + flush(); + assert(!(i & 0x11111e0000000000L)); + _jitc->inst[_jitc->ioff].i = i; + _jitc->inst[_jitc->ioff].t = t; + ++_jitc->ioff; +} + +static void +_A1(jit_state_t *_jit, jit_word_t _p, + jit_word_t x4, jit_word_t x2, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x4 & ~0xfL)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((8L<<37)|(x4<<29)|(x2<<27)|(r3<<20)|(r2<<13)|(r1<<6)|_p, INST_A); + SETREG(r1); +} + +static void +_A3(jit_state_t *_jit, jit_word_t _p, + jit_word_t x4, jit_word_t x2, jit_word_t r3, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x4 & ~0xfL)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(im >= -128 && im < 127); + assert(!(r1 & ~0x7f)); + TSTREG1(r3); + inst((8L<<37)|(((im>>7)&1L)<<36)|(x4<<29)|(x2<<27)| + (r3<<20)|((im&0x7fL)<<13)|(r1<<6)|_p, INST_A); + SETREG(r1); +} + +static void +_A4(jit_state_t *_jit, jit_word_t _p, + jit_word_t x2, jit_word_t r3, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(im >= -8192 && im < 8191); + assert(!(r1 & ~0x7f)); + TSTREG1(r3); + inst((8L<<37)|(((im>>13)&1L)<<36)|(x2<<34)|(((im>>7)&0x3fL)<<27)| + (r3<<20)|((im&0x7fL)<<13)|(r1<<6)|_p, INST_A); + SETREG(r1); +} + +static void +_A5(jit_state_t *_jit, jit_word_t _p, + jit_word_t r3, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(r3 & ~0x3L)); + assert(im >= -2097152 && im < 2097151); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((9L<<37)|(((im>>7)&0x7fffL)<<22)|(r3<<20)| + ((im&0x7fL)<<13)|(r1<<6)|_p, INST_A); + SETREG(r1); +} + +static void +_A6(jit_state_t *_jit, jit_word_t _p, + jit_word_t o, jit_word_t x2, jit_word_t ta, jit_word_t p2, + jit_word_t r3, jit_word_t r2, jit_word_t c, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(o & ~0xfL)); + assert(!(x2 & ~0x3L)); + assert(!(ta & ~0x1L)); + assert(!(p2 & ~0x7fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(c & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTREG2(r2, r3); + inst((o<<37)|(x2<<34)|(ta<<33)|(p2<<27)|(r3<<20)| + (r2<<13)|(c<<12)|(p1<<6)|_p, INST_A); +} + +static void +_A7(jit_state_t *_jit, jit_word_t _p, + jit_word_t o, jit_word_t x2, jit_word_t ta, + jit_word_t p2, jit_word_t r3, jit_word_t c, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(o & ~0xfL)); + assert(!(x2 & ~0x3L)); + assert(!(ta & ~0x1L)); + assert(!(p2 & ~0x7fL)); + assert(!(r3 & ~0x7fL)); + assert(!(c & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTREG1(r3); + inst((o<<37)|(1L<<36)|(x2<<34)|(ta<<33)| + (p2<<27)|(r3<<20)|(c<<12)|(p1<<6)|_p, INST_A); +} + +static void +_A8(jit_state_t *_jit, jit_word_t _p, + jit_word_t o, jit_word_t x2, jit_word_t ta, jit_word_t p2, + jit_word_t r3, jit_word_t im, jit_word_t c, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(o & ~0xfL)); + assert(!(x2 & ~0x3L)); + assert(!(ta & ~0x1L)); + assert(!(p2 & ~0x7fL)); + assert(!(r3 & ~0x7fL)); + assert(im >= -128 && im <= 127); + assert(!(c & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTREG1(r3); + inst((o<<37)|(((im>>7)&1L)<<36)|(x2<<34)|(ta<<33)|(p2<<27)|(r3<<20)| + ((im&0x7fL)<<13)|(c<<12)|(p1<<6)|_p, INST_A); +} + +static void +_A9(jit_state_t *_jit, jit_word_t _p, + jit_word_t za, jit_word_t zb, jit_word_t x4, + jit_word_t x2, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(za & ~0x1L)); + assert(!(zb & ~0x1L)); + assert(!(x4 & ~0xfL)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((8L<<37)|(za<<36)|(1L<<34)|(zb<<33)|(x4<<29)|(x2<<27)| + (r3<<20)|(r2<<13)|(r1<<6)|_p, INST_A); + SETREG(r1); +} + +static void +_I1(jit_state_t *_jit, jit_word_t _p, + jit_word_t ct, jit_word_t x2, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(ct & ~0x3L)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((7L<<37)|(1L<<33)|(ct<<30)|(x2<<28)| + (r3<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I2(jit_state_t *_jit, jit_word_t _p, + jit_word_t za, jit_word_t xa, jit_word_t zb, jit_word_t xc, + jit_word_t xb ,jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(za & ~0x1L)); + assert(!(xa & ~0x3L)); + assert(!(zb & ~0x1L)); + assert(!(xc & ~0x3L)); + assert(!(xb & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((7L<<37)|(za<<36)|(xa<<34)|(zb<<33)|(xc<<30)| + (xb<<28)|(r3<<20)|(r2<<13)|(r1<<6), INST_I); + SETREG(r1); +} + +static void +_I3(jit_state_t *_jit, jit_word_t _p, + jit_word_t mb, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(mb & ~0xfL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r2); + inst((7L<<37)|(3L<<34)|(2L<<30)|(2L<<28)| + (mb<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I4(jit_state_t *_jit, jit_word_t _p, + jit_word_t mh, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(mh & ~0xffL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r2); + inst((7L<<37)|(3L<<34)|(1L<<33)|(2L<<30)| + (2L<<28)|(mh<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I5(jit_state_t *_jit, jit_word_t _p, + jit_word_t za, jit_word_t zb, jit_word_t x2, + jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(za & ~0x1L)); + assert(!(zb & ~0x1L)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((7L<<37)|(za<<36)|(zb<<33)|(x2<<28)| + (r3<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I6(jit_state_t *_jit, jit_word_t _p, + jit_word_t za, jit_word_t zb, jit_word_t x2, + jit_word_t r3, jit_word_t ct, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(za & ~0x1L)); + assert(!(zb & ~0x1L)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(ct & ~0x1fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((7L<<37)|(za<<36)|(1L<<34)|(zb<<33)| + (x2<<28)|(r3<<20)|(ct<<14)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I7(jit_state_t *_jit, jit_word_t _p, + jit_word_t za, jit_word_t zb, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(za & ~0x1L)); + assert(!(zb & ~0x1L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((7L<<37)|(za<<36)|(zb<<33)|(1L<<30)| + (r3<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I8(jit_state_t *_jit, jit_word_t _p, + jit_word_t za, jit_word_t zb, jit_word_t im, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(za & ~0x1L)); + assert(!(zb & ~0x1L)); + assert(!(im & ~0x1fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r2); + inst((7L<<37)|(za<<36)|(3L<<34)|(zb<<33)|(1L<<30)|(1L<<28)| + (im<<20)|(r2<<13)|(r1<<6), INST_I); + SETREG(r1); +} + +static void +_I9(jit_state_t *_jit, jit_word_t _p, + jit_word_t x2, jit_word_t r3, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x2 & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((7L<<37)|(1L<<34)|(1L<<34)|(1L<<33)| + (x2<<30)|(1L<<28)|(r3<<20)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I10(jit_state_t *_jit, jit_word_t _p, + jit_word_t ct, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(ct & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((5L<<37)|(3L<<34)|(ct<<27)|(r3<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I11(jit_state_t *_jit, jit_word_t _p, + jit_word_t len, jit_word_t r3, + jit_word_t pos, jit_word_t y, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(len & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(pos & ~0x1fL)); + assert(!(y & ~0x1L)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((5L<<37)|(1L<<34)|(len<<27)|(r3<<20)| + (pos<<14)|(y<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I12(jit_state_t *_jit, jit_word_t _p, + jit_word_t len, jit_word_t pos, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(len & ~0x3fL)); + assert(!(pos & ~0x3fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r2); + inst((5L<<37)|(1L<<34)|(1L<<33)|(len<<27)| + (pos<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I13(jit_state_t *_jit, jit_word_t _p, + jit_word_t len, jit_word_t pos, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(len & ~0x3fL)); + assert(!(pos & ~0x3fL)); + assert(!(im & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + inst((5L<<37)|(((im>>7)&1L)<<36)|(1L<<34)|(1L<<33)|(len<<27)| + (1L<<26)|(pos<<20)|((im&0x7fL)<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I14(jit_state_t *_jit, jit_word_t _p, + jit_word_t s, jit_word_t len, jit_word_t r3, jit_word_t pos, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(s & ~0x1L)); + assert(!(len & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(pos & ~0x1fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((5L<<37)|(s<<36)|(3L<<34)|(1L<<33)| + (len<<27)|(r3<<20)|(pos<<14)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I15(jit_state_t *_jit, jit_word_t _p, + jit_word_t pos, jit_word_t len, + jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(pos & ~0x3fL)); + assert(!(len & ~0xfL)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((4L<<37)|(pos<<31)|(len<<27)|(r3<<20)|(r2<<13)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I16(jit_state_t *_jit, jit_word_t _p, + jit_word_t tb, jit_word_t ta, jit_word_t p2, + jit_word_t r3, jit_word_t ps, jit_word_t c, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(tb & ~0x1L)); + assert(!(ta & ~0x1L)); + assert(!(p2 & ~0x7fL)); + assert(!(r3 & ~0x7fL)); + assert(!(ps & ~0x3fL)); + assert(!(c & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTREG1(r3); + inst((5L<<37)|(tb<<36)|(ta<<33)|(p2<<27)| + (r3<<20)|(ps<<14)|(c<<12)|(p1<<6), INST_I); +} + +static void +_I17(jit_state_t *_jit, jit_word_t _p, + jit_word_t tb, jit_word_t ta, jit_word_t p2, + jit_word_t r3, jit_word_t c, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(tb & ~0x1L)); + assert(!(ta & ~0x1L)); + assert(!(p2 & ~0x7fL)); + assert(!(r3 & ~0x7fL)); + assert(!(c & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTREG1(r3); + inst((5L<<37)|(tb<<36)|(ta<<33)|(p2<<27)| + (r3<<20)|(1L<<13)|(c<<12)|(p1<<6)|_p, INST_I); +} + +static void +_I18(jit_state_t *_jit, jit_word_t _p, + jit_word_t im, jit_word_t y) +{ + assert(!(_p & ~0x3fL)); + assert(!(im & ~0x1fffffL)); + assert(!(y & ~0x1L)); + /* no register referenced */ + inst((((im>>20)&1L)<<26)|(1L<<27)|(y<<26)|((im&0xffffL)<<6)|_p, INST_I); +} + +static void +_I19(jit_state_t *_jit, jit_word_t _p, + jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(im & ~0x1fffffL)); + /* no register referenced */ + inst(((im>>20)&1L)|((im&0xffffL)<<6)|_p, INST_I); +} + +static void +_I20(jit_state_t *_jit, jit_word_t _p, + jit_word_t r2, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(r2 & ~0x7fL)); + assert(!(im & ~0x1fffffL)); + TSTREG1(r2); + inst(((im>>20)&1L)|(1L<<33)|(((im>>7)&0x1fffL)<<20)| + (r2<<13)|((im&0x7fL)<<6)|_p, INST_I); +} + +static void +_I21(jit_state_t *_jit, jit_word_t _p, + jit_word_t im, jit_word_t ih, jit_word_t x, + jit_word_t wh, jit_word_t r2, jit_word_t b1) +{ + assert(!(_p & ~0x3fL)); + assert(!(im & ~0x1ffL)); + assert(!(ih & ~0x1L)); + assert(!(x & ~0x1L)); + assert(!(wh & ~0x3L)); + assert(!(r2 & ~0x7fL)); + assert(!(b1 & ~0x7L)); + TSTREG1(r2); + inst((7L<<33)|(im<<24)|(ih<<23)|(x<<22)|(wh<<20)| + (r2<<13)|(b1<<6), INST_I); +} + +static void +_I22(jit_state_t *_jit, jit_word_t _p, + jit_word_t b2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(b2 & ~0x7L)); + assert(!(r1 & ~0x7fL)); + inst((0x31L<<27)|(b2<<13)|(r1<<6)|_p, INST_I); +} + +static void +_I23(jit_state_t *_jit, jit_word_t _p, + jit_word_t r2, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(r2 & ~0x7fL)); + assert(!(im & ~0xffffL)); + TSTREG1(r2); + inst((((im>>15)&1L)<<36)|(3L<<33)|(((im>>7)&0xffL)<<24)| + (r2<<13)|(im&0x7fL)|_p, INST_I); +} + +static void +_I24(jit_state_t *_jit, jit_word_t _p, + jit_word_t im) +{ + jit_uint8_t cc = INST_I; + assert(!(_p & ~0x3fL)); + assert(!(im & ~0xfffffffL)); + /* no register referenced */ + inst((((im>>27)&1L)<<36)|(2L<<33)|((im&0x7ffffffL)<<6)|_p, cc); +} + +static void +_I25(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r1 & ~0x7fL)); + inst((x6<<27)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I26(jit_state_t *_jit, jit_word_t _p, + jit_word_t ar,jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(ar & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r2); + inst((0x2aL<<27)|(ar<<20)|(r2<<13)|_p, INST_I); +} + +static void +_I27(jit_state_t *_jit, jit_word_t _p, + jit_word_t ar,jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(ar & ~0x7fL)); + assert(!(im & ~0xffL)); + /* no register referenced */ + inst((((im>>7)&1L)<<36)|(0xaL<<27)|(ar<<20)|((im&0x7fL)<<13)|_p, INST_I); +} + +static void +_I28(jit_state_t *_jit, jit_word_t _p, + jit_word_t ar, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(ar & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + inst((0x32L<<27)|(ar<<20)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I29(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3,jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((x6<<27)|(r3<<20)|(r1<<6)|_p, INST_I); + SETREG(r1); +} + +static void +_I30(jit_state_t *_jit, jit_word_t _p, + jit_word_t ta, jit_word_t tb, jit_word_t p2, + jit_word_t im, jit_word_t c, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(ta & ~0x1L)); + assert(!(tb & ~0x1L)); + assert(!(p2 & ~0x3fL)); + assert(!(im & ~0x1fL)); + assert(!(c & ~0x1L)); + assert(!(p1 & ~0x1fL)); + /* no register referenced (only predicates) */ + inst((5L<<37)|(tb<<36)|(ta<<33)|(1L<<19)|(im<<14)| + (1L<<13)|(c<<12)|(p1<<6)|_p, INST_I); +} + +static void +_M1(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t x, jit_word_t r3, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(x & ~0x1L)); + assert(!(r3 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((4L<<37)|(x6<<30)|(ht<<28)|(x<<27)|(r3<<20)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M2(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((4L<<37)|(1L<<36)|(x6<<30)|(ht<<28)| + (r3<<20)|(r2<<13)|(r1<<6)|_p, INST_M); + SETREG(r1); + SETREG(r3); +} + +static void +_M3(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im, jit_word_t r1) +{ + jit_uint8_t cc = INST_M; + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(im > -256 && im < 255); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((5L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)| + (((im>>7)&1L)<<27)|(r3<<20)|((im&0x7fL)<<13)|(r1<<6)|_p, cc); + SETREG(r1); + SETREG(r3); +} + +static void +_M5(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(im > -256 && im < 255); + TSTREG2(r2, r3); + inst((5L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)| + (((im>>7)&1L)<<27)|(r3<<20)|(r2<<13)|((im&0x7fL)<<6)|_p, INST_M); + SETREG(r3); +} + +static void +_M6(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t x, jit_word_t r3, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(x & ~0x1L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + TSTREG2(r2, r3); + inst((4L<<37)|(x6<<30)|(ht<<28)|(x<<27)|(r3<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M13(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r3); + if (r2) + TSTFREG1(r2); + inst((6L<<37)|(x6<<30)|(ht<<28)|(r3<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M14(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + TSTREG2(r2, r3); + inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)|(r3<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M15(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(im & ~0x1ffL)); + TSTREG1(r3); + inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)| + (((im>>7)&1L)<<27)|(r3<<20)|((im&0x7fL)<<13)|_p, INST_M); +} + +static void +_M16(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((4L<<37)|(x6<<30)|(ht<<28)|(1L<<27)| + (r3<<20)|(r2<<13)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M17(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(im & ~0x7L)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((4L<<37)|(x6<<30)|(ht<<28)|(1L<<27)| + (r3<<20)|(im<<13)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M20x(jit_state_t *_jit, jit_word_t _p, + jit_word_t x3, jit_word_t r2, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(x3 & ~0x7L)); + assert(!(r2 & ~0x7fL)); + assert(!(im & ~0x1fffffL)); + if (x3 == 1) + TSTREG1(r2); + else + TSTFREG1(r2); + inst((1L<<37)|(((im>>20)&1L)<<36)|(x3<<33)| + (((im>>7)&0x1fffL)<<20)|(r2<<13)|((im&0x7fL)<<6)|_p, INST_M); +} + +static void +_M22x(jit_state_t *_jit, jit_word_t _p, + jit_word_t x3, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x3 & ~0x7L)); + assert(!(im & ~0x1fffffL)); + assert(!(r1 & ~0x7fL)); + inst((((im>>20)&1L)<<36)|(x3<<33)|((im&0xffffL)<<13)|(r1<<6)|_p, INST_M); + if (x3 < 6) + SETREG(r1); + else + SETFREG(r1); +} + +static void +_M24(jit_state_t *_jit, jit_word_t _p, + jit_word_t x2, jit_word_t x4) +{ + assert(!(_p & ~0x3fL)); + assert(!(x2 & ~0x3L)); + assert(!(x4 & ~0xfL)); + /* no registers referenced */ + inst((x2<<31)|(x4<<27)|_p, INST_M); +} + +static void +_M26x(jit_state_t *_jit, jit_word_t _p, + jit_word_t x4, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x4 & ~0xfL)); + assert(!(r1 & ~0x7fL)); + if (x4 == 2) + TSTREG1(r1); + else + TSTFREG1(r1); + inst((1L<<31)|(x4<<27)|(r1<<6)|_p, INST_M); +} + +static void +_M28(jit_state_t *_jit, jit_word_t _p, + jit_word_t x, jit_word_t r3) +{ + assert(!(_p & ~0x3fL)); + assert(!(x & ~0x1L)); + assert(!(r3 & ~0x7fL)); + TSTREG1(r3); + inst((1L<<37)|(x<<36)|(0x30L<<27)|(r3<<20)|_p, INST_M); +} + +static void +_M29(jit_state_t *_jit, jit_word_t _p, + jit_word_t ar, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(ar & ~0x7L)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r2); + inst((1L<<37)|(0x2aL<<27)|(ar<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M30(jit_state_t *_jit, jit_word_t _p, + jit_word_t ar, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(ar & ~0x7L)); + assert(!(im & ~0xffL)); + /* no registers referenced (only "application registers") */ + inst((((im>>7)&1L)<<36)|(2L<<31)|(0x8L<<27)| + (ar<<20)|((im&0x7fL)<<13)|_p, INST_M); +} + +static void +_M31(jit_state_t *_jit, jit_word_t _p, + jit_word_t ar, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(ar & ~0x7L)); + assert(!(r1 & ~0x7fL)); + inst((1L<<37)|(0x22L<<27)|(ar<<20)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M32(jit_state_t *_jit, jit_word_t _p, + jit_word_t cr, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(cr & ~0x7L)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r2); + inst((1L<<37)|(0x2cL<<27)|(cr<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M33(jit_state_t *_jit, jit_word_t _p, + jit_word_t cr, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(cr & ~0x7L)); + assert(!(r1 & ~0x7fL)); + inst((1L<<37)|(0x24L<<27)|(cr<<20)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M34(jit_state_t *_jit, jit_word_t _p, + jit_word_t sor, jit_word_t sol, jit_word_t sof, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(sor & ~0xfL)); + assert(!(sol & ~0x7fL)); + assert(!(sof & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + /* specification says changes are immediate, no need to "stop" */ + inst((1L<<37)|(6L<<33)|(sor<<27)|(sol<<20)|(sof<<13)|(r1<<6)|_p, INST_M); +} + +static void +_M35(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r2); + inst((1L<<37)|(x6<<27)|(r2<<13)|_p, INST_M); +} + +static void +_M36(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r1 & ~0x7fL)); + inst((1L<<37)|(x6<<27)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M37(jit_state_t *_jit, jit_word_t _p, + jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(im & ~0x1ffffL)); + /* no registers referenced */ + inst((((im>>20)&1L)<<36)|((im&0xffffL)<<6)|_p, INST_M); +} + +static void +_M38(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t r2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((1L<<37)|(x6<<27)|(r3<<20)|(r2<<13)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M39(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t im, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(im & ~0x7L)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((1L<<37)|(x6<<27)|(r3<<20)|(im<<13)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M40(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(im & ~0x7L)); + TSTREG1(r3); + inst((1L<<37)|(x6<<27)|(r3<<20)|(im<<13)|_p, INST_M); +} + +static void +_M41(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r2); + inst((1L<<37)|(x6<<27)|(r2<<13)|_p, INST_M); +} + +static void +_M42(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + TSTREG1(r2); + inst((1L<<37)|(x6<<27)|(r3<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M43(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + inst((1L<<37)|(x6<<27)|(r3<<20)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +_M44(jit_state_t *_jit, jit_word_t _p, + jit_word_t x4, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(x4 & ~0xfL)); + assert(!(im & ~0xfffffL)); + /* no registers referenced */ + inst((((im>>23)&1L)<<36)|(((im>>21)&3L)<<31)| + (x4<<27)|((im&0x1ffffL)<<6)|_p, INST_M); +} + +static void +_M45(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t r2) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + TSTREG2(r2, r3); + inst((1L<<37)|(x6<<27)|(r3<<20)|(r2<<13)|_p, INST_M); +} + +static void +_M46(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r3, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r3 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTREG1(r3); + inst((1L<<37)|(x6<<27)|(r3<<20)|(r1<<6)|_p, INST_M); + if (r1) SETREG(r1); +} + +static void +_M48(jit_state_t *_jit, jit_word_t _p, + jit_word_t y, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(y & ~0x1L)); + assert(!(im & ~0x1ffffL)); + /* no registers referenced */ + inst((((im>>20)&1L)<<36)|(1L<<27)|(y<<26)|((im&0xffffL)<<6)|_p, INST_M); +} + +static void +_B1(jit_state_t *_jit, jit_word_t _p, + jit_word_t d, jit_word_t wh, jit_word_t im, jit_word_t p, jit_word_t tp) +{ + assert(!(_p & ~0x3fL)); + assert(!(d & ~0x1L)); + assert(!(wh & ~0x3L)); + assert(im >= -1048576 && im < 1048575); + assert(!(p & ~0x1L)); + assert(!(tp & ~0x7L)); + /* no registers referenced */ + inst((4L<<37)|(((im>>20)&1L)<<36)|(d<<35)|(wh<<33)| + ((im&0xfffffL)<<13)|(p<<12)|(tp<<6)|_p, INST_B); +} + +static void +_B3(jit_state_t *_jit, jit_word_t _p, + jit_word_t d, jit_word_t wh, jit_word_t im, jit_word_t p, jit_word_t b) +{ + assert(!(_p & ~0x3fL)); + assert(!(d & ~0x1L)); + assert(!(wh & ~0x3L)); + assert(im >= -1048576 && im < 1048575); + assert(!(p & ~0x1L)); + assert(!(b & ~0x3L)); + /* no registers referenced */ + inst((5L<<37)|(((im>>20)&1L)<<36)|(d<<35)|(wh<<33)| + ((im&0xfffffL)<<13)|(p<<12)|(b<<6)|_p, INST_B); +} + +static void +_B4(jit_state_t *_jit, jit_word_t _p, + jit_word_t d, jit_word_t wh, jit_word_t x6, + jit_word_t b, jit_word_t p, jit_word_t tp) +{ + assert(!(_p & ~0x3fL)); + assert(!(d & ~0x1L)); + assert(!(wh & ~0x3L)); + assert(!(x6 & ~0x3fL)); + assert(!(b & ~0x7L)); + assert(!(p & ~0x1L)); + assert(!(tp & ~0x7L)); + /* no registers referenced */ + inst((d<<37)|(wh<<33)|(x6<<27)|(b<<13)|(p<<12)|(tp<<6)|_p, INST_B); +} + +static void +_B5(jit_state_t *_jit, jit_word_t _p, + jit_word_t d, jit_word_t wh, jit_word_t b2, jit_word_t p, jit_word_t b1) +{ + assert(!(_p & ~0x3fL)); + assert(!(d & ~0x1L)); + assert(!(wh & ~0x3L)); + assert(!(b2 & ~0x7L)); + assert(!(p & ~0x1L)); + assert(!(b1 & ~0x7L)); + /* no registers referenced */ + inst((1L<<37)|(d<<35)|(wh<<32)|(b2<<13)|(p<<12)|(b1<<6)|_p, INST_B); +} + +static void +_B6(jit_state_t *_jit, jit_word_t _p, + jit_word_t ih, jit_word_t im, jit_word_t tag, jit_word_t wh) +{ + assert(!(_p & ~0x3fL)); + assert(!(ih & ~0x1L)); + assert(!(im & ~0x1ffffL)); + assert(!(tag & ~0x1ffL)); + assert(!(wh & ~0x3L)); + /* no registers referenced */ + inst((7L<<37)|(((im>>20)&1L)<<36)|(ih<<35)|(((tag>>7)&3L)<<33)| + ((im&0xfffffL)<<13)|((tag&0x7fL)<<6)|(wh<<3)|_p, INST_B); +} + +static void +_B7(jit_state_t *_jit, jit_word_t _p, + jit_word_t ih, jit_word_t x6, jit_word_t b2, jit_word_t tag, jit_word_t wh) +{ + assert(!(_p & ~0x3fL)); + assert(!(ih & ~0x1L)); + assert(!(x6 & ~0x3fL)); + assert(!(b2 & ~0x7L)); + assert(!(tag & ~0x1ffL)); + assert(!(wh & ~0x3L)); + /* no registers referenced */ + inst((2L<<37)|(ih<<35)|(((tag>>7)&3L)<<33)|(x6<<27)| + (b2<<13)|((tag&0x7fL)<<6)|(wh<<3)|_p, INST_B); +} + +static void +_B8(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + /* no registers referenced */ + inst((x6<<27)|_p, INST_B); +} + +static void +_B9(jit_state_t *_jit, jit_word_t _p, + jit_word_t op, jit_word_t x6, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(op & ~0xfL)); + assert(!(x6 & ~0x3fL)); + assert(!(im & ~0x1ffffL)); + /* no registers referenced */ + inst((op<<37)|(((im>>20)&1L)<<36)|(x6<<27)|((im&0xffffL)<<6)|_p, INST_B); +} + +static void +_X1(jit_state_t *_jit, jit_word_t _p, + jit_word_t im) +{ + jit_word_t i41, i1, i20; + assert(!(_p & ~0x3fL)); + assert(im > -0x2000000000000000 && im < 0x1fffffffffffffff); + i41 = (im >> 22) & 0x1ffffffffffL; + i1 = (im >> 21) & 0x1L; + i20 = im & 0xfffffL; + /* no registers referenced */ + inst(i41, INST_L); + inst((i1<<36)|(i20<<6)|_p, INST_X); +} + +static void +_X2(jit_state_t *_jit, jit_word_t _p, + jit_word_t r1, jit_word_t im) +{ + jit_word_t i1, i41, ic, i5, i9, i7; + assert(!(_p & ~0x3fL)); + assert(!(r1 & ~0x7fL)); + i1 = (im >> 63) & 0x1L; + i41 = (im >> 22) & 0x1ffffffffffL; + ic = (im >> 21) & 0x1L; + i5 = (im >> 16) & 0x1fL; + i9 = (im >> 7) & 0x1ffL; + i7 = im & 0x7fL; + inst(i41, INST_L); + inst((6L<<37)|(i1<<36)|(i9<<27)|(i5<<22)| + (ic<<21)|(i7<<13)|(r1<<6)|_p, INST_X); + SETREG(r1); +} + +static void +_X3x(jit_state_t *_jit, jit_word_t _p, + jit_word_t op, jit_word_t d, jit_word_t wh, + jit_word_t p, jit_word_t tp, jit_word_t im) +{ + /* target64 = IP + ((i1 << 59 | imm39 << 20 | imm20b) << 4) */ + jit_word_t i1, i41, i20; + assert(!(_p & ~0x3fL)); + assert(!(op & ~0xfL)); + assert(!(d & ~0x1L)); + assert(!(wh & ~0x3L)); + assert(!(p & ~0x1L)); + assert(!(tp & ~0x7L)); + i1 = (im >> 61) & 0x1L; + i41 = (im >> 22) & 0x1ffffffffffL; + i20 = im & 0xfffffL; + /* no registers referenced */ + inst(i41, INST_L); + inst((op<<37)|(i1<<36)|(d<<35)|(wh<<33)| + (i20<<13)|(p<<12)|(tp<<6)|_p, INST_X); +} + +static void +_X5(jit_state_t *_jit, jit_word_t _p, + jit_word_t y, jit_word_t im) +{ + jit_word_t i41, i1, i20; + assert(!(_p & ~0x3fL)); + assert(im > -0x2000000000000000 && im < 0x1fffffffffffffff); + i41 = (im >> 22) & 0x1ffffffffffL; + i1 = (im >> 21) & 0x1L; + i20 = im & 0xfffffL; + /* no registers referenced */ + inst(i41, INST_L); + inst((i1<<36)|(1L<<27)|(y<<26)|(i20<<6)|_p, INST_X); +} + +static void +_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + /* patch pushargr */ + if (r0 >= 120) + r0 = _jitc->rout + (r0 - 120); + + MOV(r0, r1); +} + +static void +_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + /* patch pushargi */ + if (r0 >= 120) + r0 = _jitc->rout + (r0 - 120); + + if (i0 >= -2097152 && i0 < 2097151) + MOVI(r0, i0); + else + MOVL(r0, i0); +} + +static jit_word_t +_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + MOVL(r0, i0); + return (w); +} + +static void +_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -8192 && i0 <= 8191) + ADDS(r0, i0, r1); + else if (!(r1 & ~3) && i0 >= -2097152 && i0 < 2097151) + ADDL(r1, i0, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + addr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (jit_carry == _NOREG) + jit_carry = jit_get_reg(jit_class_gpr); + if (r0 == r1) { + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ltr_u(rn(jit_carry), rn(reg), r1); + movr(r0, rn(reg)); + jit_unget_reg(reg); + } + else { + addr(r0, r1, r2); + ltr_u(rn(jit_carry), r0, r1); + } +} + +static void +_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (jit_carry == _NOREG) + jit_carry = jit_get_reg(jit_class_gpr); + if (r0 == r1) { + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r1, i0); + ltr_u(rn(jit_carry), rn(reg), r1); + movr(r0, rn(reg)); + jit_unget_reg(reg); + } + else { + addi(r0, r1, i0); + ltr_u(rn(jit_carry), r0, r1); + } +} + +static void +_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + assert(jit_carry != _NOREG); + reg = jit_get_reg(jit_class_gpr); + movr(rn(reg), rn(jit_carry)); + addcr(r0, r1, r2); + addcr(r0, r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + assert(jit_carry != _NOREG); + reg = jit_get_reg(jit_class_gpr); + movr(rn(reg), rn(jit_carry)); + addci(r0, r1, i0); + addcr(r0, r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + SUBI(r0, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + addr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (jit_carry == _NOREG) + jit_carry = jit_get_reg(jit_class_gpr); + if (r0 == r1) { + reg = jit_get_reg(jit_class_gpr); + subr(rn(reg), r1, r2); + ltr_u(rn(jit_carry), r1, rn(reg)); + movr(r0, rn(reg)); + jit_unget_reg(reg); + } + else { + subr(r0, r1, r2); + ltr_u(rn(jit_carry), r1, r0); + } +} + +static void +_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (jit_carry == _NOREG) + jit_carry = jit_get_reg(jit_class_gpr); + if (r0 == r1) { + reg = jit_get_reg(jit_class_gpr); + subi(rn(reg), r1, i0); + ltr_u(rn(jit_carry), r1, rn(reg)); + movr(r0, rn(reg)); + jit_unget_reg(reg); + } + else { + subi(r0, r1, i0); + ltr_u(rn(jit_carry), r1, r0); + } +} + +static void +_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + assert(jit_carry != _NOREG); + reg = jit_get_reg(jit_class_gpr); + movr(rn(reg), rn(jit_carry)); + subcr(r0, r1, r2); + subcr(r0, r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + assert(jit_carry != _NOREG); + reg = jit_get_reg(jit_class_gpr); + movr(rn(reg), rn(jit_carry)); + subci(r0, r1, i0); + subcr(r0, r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t f0, f1; + f0 = jit_get_reg(jit_class_fpr); + f1 = jit_get_reg(jit_class_fpr); + SETF_SIG(rn(f0), r1); + SETF_SIG(rn(f1), r2); + XMPY_L(rn(f0), rn(f0), rn(f1)); + GETF_SIG(r0, rn(f0)); + jit_unget_reg(f0); + jit_unget_reg(f1); +} + +static void +_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + mulr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_word_t d; + /* @arg0 = r1, @arg1 = r2 */ + sync(); + d = ((jit_word_t)__divdi3 - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(0, d); + else + /* FIXME displacement likely wrong (in either case) */ + BRL_CALL(0, d); + /* r0 = @ret */ +} + +static void +_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + switch (i0) { + case 1: + movr(r0, r1); + return; + case -1: + negr(r0, r1); + return; + default: + if (i0 > 0 && !(i0 & (i0 - 1))) { + movr(r0, r1); + rshi(r0, r0, ffsl(i0) - 1); + return; + } + break; + } + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + divr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_word_t d; + /* @arg0 = r1, @arg1 = r2 */ + sync(); + d = ((jit_word_t)__udivdi3 - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(0, d); + else + /* FIXME displacement likely wrong (in either case) */ + BRL_CALL(0, d); + /* r0 = @ret */ +} + +static void +_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 == 1) { + movr(r0, r1); + return; + } + else if (i0 > 0 && !(i0 & (i0 - 1))) { + movr(r0, r1); + rshi_u(r0, r0, ffsl(i0) - 1); + return; + } + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + divr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_word_t d; + /* @arg0 = r1, @arg1 = r2 */ + sync(); + d = ((jit_word_t)__moddi3 - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(0, d); + else + /* FIXME displacement likely wrong (in either case) */ + BRL_CALL(0, d); + /* r0 = @ret */ +} + +static void +_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 == 1 || i0 == -1) { + MOV(r0, GR_0); + return; + } + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + remr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_word_t d; + /* @arg0 = r1, @arg1 = r2 */ + sync(); + d = (jit_word_t)(__umoddi3 - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(0, d); + else + /* FIXME displacement likely wrong (in either case) */ + BRL_CALL(0, d); + /* r0 = @ret */ +} + +static void +_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 == 1) { + MOV(r0, GR_0); + return; + } + else if (i0 > 0 && !(i0 & (i0 - 1))) { + movr(r0, r1); + andi(r0, r0, i0 - 1); + return; + } + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + remr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_mulh(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_bool_t sign) +{ + jit_int32_t f0, f1; + f0 = jit_get_reg(jit_class_fpr); + f1 = jit_get_reg(jit_class_fpr); + SETF_SIG(rn(f0), r1); + SETF_SIG(rn(f1), r2); + if (sign) + XMPY_H(rn(f0), rn(f0), rn(f1)); + else + XMPY_HU(rn(f0), rn(f0), rn(f1)); + GETF_SIG(r0, rn(f0)); + jit_unget_reg(f0); + jit_unget_reg(f1); +} + +static void +_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, + jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) +{ + jit_int32_t reg; + if (r0 == r2 || r0 == r3) { + reg = jit_get_reg(jit_class_gpr); + mulr(rn(reg), r2, r3); + } + else + mulr(r0, r2, r3); + mulh(sign, r1, r2, r3); + if (r0 == r2 || r0 == r3) { + movr(r0, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, + jit_int32_t r2, jit_word_t i0, jit_bool_t sign) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + iqmulr(r0, r1, r2, rn(reg), sign); + jit_unget_reg(reg); +} + +static void +_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, + jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) +{ + jit_int32_t sv0, rg0; + jit_int32_t sv1, rg1; + + if (r0 == r2 || r0 == r3) { + sv0 = jit_get_reg(jit_class_gpr); + rg0 = rn(sv0); + } + else + rg0 = r0; + if (r1 == r2 || r1 == r3) { + sv1 = jit_get_reg(jit_class_gpr); + rg1 = rn(sv1); + } + else + rg1 = r1; + + if (sign) + divr(rg0, r2, r3); + else + divr_u(rg0, r2, r3); + mulr(rg1, r3, rg0); + subr(rg1, r2, rg1); + if (rg0 != r0) { + movr(r0, rg0); + jit_unget_reg(sv0); + } + if (rg1 != r1) { + movr(r1, rg1); + jit_unget_reg(sv1); + } +} + +static void +_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, + jit_int32_t r2, jit_word_t i0, jit_bool_t sign) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + iqdivr(r0, r1, r2, rn(reg), sign); + jit_unget_reg(reg); +} + +static void +_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + ANDI(r0, i0, r1); + else if (~i0 >= -128 && ~i0 <= 127) + ANDCMI(r0, ~i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + andr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + ORI(r0, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + orr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + XORI(r0, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + xorr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + lshr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + rshr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + rshr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LT(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + CMPI_LT(PR_6, PR_7, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMP_LT(PR_6, PR_7, r1, rn(reg)); + jit_unget_reg(reg); + } + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LTU(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + CMPI_LTU(PR_6, PR_7, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMP_LTU(PR_6, PR_7, r1, rn(reg)); + jit_unget_reg(reg); + } + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LT(PR_6, PR_7, r2, r1); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ler(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LTU(PR_6, PR_7, r2, r1); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ler_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_EQ(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + CMPI_EQ(PR_6, PR_7, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMP_EQ(PR_6, PR_7, r1, rn(reg)); + jit_unget_reg(reg); + } + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LT(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + CMPI_LT(PR_6, PR_7, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMP_LT(PR_6, PR_7, r1, rn(reg)); + jit_unget_reg(reg); + } + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LTU(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + CMPI_LTU(PR_6, PR_7, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMP_LTU(PR_6, PR_7, r1, rn(reg)); + jit_unget_reg(reg); + } + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LT(PR_6, PR_7, r2, r1); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + gtr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_LTU(PR_6, PR_7, r2, r1); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} + +static void +_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + gtr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMP_EQ(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -128 && i0 <= 127) + CMPI_EQ(PR_6, PR_7, i0, r1); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMP_EQ(PR_6, PR_7, r1, rn(reg)); + jit_unget_reg(reg); + } + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} + +static void +_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_c(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_uc(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_s(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_us(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_i(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_ui(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_l(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_c(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_c(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_uc(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_uc(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_s(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_s(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_us(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_us(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_i(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_i(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_ui(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_ui(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r1, r2); + ldr_l(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_l(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_c(rn(reg), r0); + jit_unget_reg(reg); +} + +static void +_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_s(rn(reg), r0); + jit_unget_reg(reg); +} + +static void +_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_i(rn(reg), r0); + jit_unget_reg(reg); +} + +static void +_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_l(rn(reg), r0); + jit_unget_reg(reg); +} + +static void +_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r0, r1); + str_c(rn(reg), r2); + jit_unget_reg(reg); +} + +static void +_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_c(rn(reg), r1); + jit_unget_reg(reg); +} + +static void +_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r0, r1); + str_s(rn(reg), r2); + jit_unget_reg(reg); +} + +static void +_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_s(rn(reg), r1); + jit_unget_reg(reg); +} + +static void +_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r0, r1); + str_i(rn(reg), r2); + jit_unget_reg(reg); +} + +static void +_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_i(rn(reg), r1); + jit_unget_reg(reg); +} + +static void +_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r0, r1); + str_l(rn(reg), r2); + jit_unget_reg(reg); +} + +static void +_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_l(rn(reg), r1); + jit_unget_reg(reg); +} + +static jit_word_t +_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LT(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -128 && i1 <= 127) { + sync(); + w = _jit->pc.w; + CMPI_LT(PR_6, PR_7, i1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + sync(); + w = _jit->pc.w; + CMP_LT(PR_6, PR_7, r0, rn(reg)); + jit_unget_reg(reg); + } + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LTU(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -128 && i1 <= 127) { + sync(); + w = _jit->pc.w; + CMPI_LTU(PR_6, PR_7, i1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + sync(); + w = _jit->pc.w; + CMP_LTU(PR_6, PR_7, r0, rn(reg)); + jit_unget_reg(reg); + } + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LT(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bler(i0, r0, rn(reg)); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LTU(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bler_u(i0, r0, rn(reg)); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_EQ(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -128 && i1 <= 127) { + sync(); + w = _jit->pc.w; + CMPI_EQ(PR_6, PR_7, i1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + sync(); + w = _jit->pc.w; + CMP_EQ(PR_6, PR_7, r0, rn(reg)); + jit_unget_reg(reg); + } + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LT(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -128 && i1 <= 127) { + sync(); + w = _jit->pc.w; + CMPI_LT(PR_6, PR_7, i1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + sync(); + w = _jit->pc.w; + CMP_LT(PR_6, PR_7, r0, rn(reg)); + jit_unget_reg(reg); + } + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LTU(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -128 && i1 <= 127) { + sync(); + w = _jit->pc.w; + CMPI_LTU(PR_6, PR_7, i1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + sync(); + w = _jit->pc.w; + CMP_LTU(PR_6, PR_7, r0, rn(reg)); + jit_unget_reg(reg); + } + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LT(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bgtr(i0, r0, rn(reg)); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_LTU(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bgtr_u(i0, r0, rn(reg)); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + CMP_EQ(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -128 && i1 <= 127) { + sync(); + w = _jit->pc.w; + CMPI_EQ(PR_6, PR_7, i1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + sync(); + w = _jit->pc.w; + CMP_EQ(PR_6, PR_7, r0, rn(reg)); + jit_unget_reg(reg); + } + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + andr(rn(reg), r0, r1); + sync(); + w = _jit->pc.w; + CMPI_EQ(PR_6, PR_7, 0, rn(reg)); + jit_unget_reg(reg); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + andr(rn(reg), r0, rn(reg)); + sync(); + w = _jit->pc.w; + CMPI_EQ(PR_6, PR_7, 0, rn(reg)); + jit_unget_reg(reg); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} + +static jit_word_t +_bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + andr(rn(reg), r0, r1); + sync(); + w = _jit->pc.w; + CMPI_EQ(PR_6, PR_7, 0, rn(reg)); + jit_unget_reg(reg); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + andr(rn(reg), r0, rn(reg)); + sync(); + w = _jit->pc.w; + CMPI_EQ(PR_6, PR_7, 0, rn(reg)); + jit_unget_reg(reg); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} + +static jit_word_t +_baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t t0; + jit_int32_t t1; + jit_int32_t t2; + /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */ + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + t2 = jit_get_reg(jit_class_gpr); + lti(rn(t0), r1, 0); /* t0 = r1 < 0 */ + addr(rn(t1), r0, r1); /* t1 = r0 + r1 */ + ltr(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */ + ltr(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */ + CMPI_EQ(PR_6, PR_7, 0, rn(t0)); + CMPI_EQ_p(PR_8, PR_9, 0, rn(t2), PR_6);/* if (t0==0) p4=t2==0,p5=t2!=0; */ + CMPI_EQ_p(PR_8, PR_9, 0, rn(t2), PR_7);/* if (t0!=0) p4=t1==0,p5=t1!=0; */ + sync(); + w = _jit->pc.w; + MOV(r0, rn(t0)); + BRI_COND((i0 - w) >> 4, carry ? PR_9 : PR_8); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); + return (w); +} + +static jit_word_t +_baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = baddr(i0, r0, rn(reg), carry); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t t0; + jit_int32_t t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + addr(rn(t0), r0, r1); + ltr_u(rn(t1), rn(t0), r0); + CMPI_EQ(PR_6, PR_7, 0, rn(t1)); + sync(); + w = _jit->pc.w; + MOV(r0, rn(t0)); + BRI_COND((i0 - w) >> 4, carry ? PR_7 : PR_6); + jit_unget_reg(t1); + jit_unget_reg(t0); + return (w); +} + +static jit_word_t +_baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = baddr_u(i0, r0, rn(reg), carry); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t t0; + jit_int32_t t1; + jit_int32_t t2; + /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */ + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + t2 = jit_get_reg(jit_class_gpr); + gti(rn(t0), r1, 0); /* t0 = r1 > 0 */ + subr(rn(t1), r0, r1); /* t1 = r0 - r1 */ + ltr(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */ + ltr(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */ + CMPI_EQ(PR_6, PR_7, 0, rn(t0)); + CMPI_EQ_p(PR_8, PR_9, 0, rn(t2), PR_6);/* if (t0==0) p4=t2==0,p5=t2!=0; */ + CMPI_EQ_p(PR_8, PR_9, 0, rn(t2), PR_7);/* if (t0!=0) p4=t1==0,p5=t1!=0; */ + sync(); + w = _jit->pc.w; + MOV(r0, rn(t0)); + BRI_COND((i0 - w) >> 4, carry ? PR_9 : PR_8); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); + return (w); +} + +static jit_word_t +_bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bsubr(i0, r0, rn(reg), carry); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t t0; + jit_int32_t t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + subr(rn(t0), r0, r1); + ltr_u(rn(t1), r0, rn(t0)); + CMPI_EQ(PR_6, PR_7, 0, rn(t1)); + sync(); + w = _jit->pc.w; + MOV(r0, rn(t0)); + BRI_COND((i0 - w) >> 4, carry ? PR_7 : PR_6); + jit_unget_reg(t1); + jit_unget_reg(t0); + return (w); +} + +static jit_word_t +_bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1, + jit_bool_t carry) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bsubr_u(i0, r0, rn(reg), carry); + jit_unget_reg(reg); + return (w); +} + +static void +_jmpr(jit_state_t *_jit, jit_int32_t r0) +{ + MOV_rn_br(r0, BR_6); + BR(BR_6); +} + +static void +_jmpi(jit_state_t *_jit, jit_word_t i0) +{ + jit_word_t d; + sync(); + d = ((jit_word_t)i0 - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI(d); + else + BRL(d); +} + +static jit_word_t +_jmpi_p(jit_state_t *_jit, jit_word_t i0) +{ + jit_word_t d, w; + sync(); + w = _jit->pc.w; + d = ((jit_word_t)i0 - w) >> 4; + BRL(d); + return (w); +} + +static void +_callr(jit_state_t *_jit, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + LD8_inc(rn(reg), r0, 8); + MOV_br_rn(BR_6, rn(reg)); + jit_unget_reg(reg); + LD8(GR_1, r0); + BR_CALL(BR_0, BR_6); +} + +static void +_calli(jit_state_t *_jit, jit_word_t i0) +{ +#if 1 + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + callr(rn(reg)); + jit_unget_reg(reg); +#else + jit_word_t d; + sync(); + i0 = *(jit_word_t **)i0; + d = ((jit_word_t)i0 - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(BR_6, d); + else + BRL_CALL(BR_6, d); +#endif +} + +static jit_word_t +_calli_p(jit_state_t *_jit, jit_word_t i0) +{ +#if 1 + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + w = movi_p(rn(reg), i0); + callr(rn(reg)); + jit_unget_reg(reg); + return (w); +#else + jit_word_t d, w; + sync(); + i0 = *(jit_word_t *)i0; + w = _jit->pc.w; + d = ((jit_word_t)i0 - w) >> 4; + BRL_CALL(BR_6, d); + return (w); +#endif +} + +static void +_prolog(jit_state_t *_jit, jit_node_t *node) +{ + jit_int32_t reg, ruse, rout; + + _jitc->function->stack = ((_jitc->function->self.alen - + _jitc->function->self.aoff) + 15) & -16; + + /* First lowest unused register is first output register */ + for (reg = _R115; reg >= _R40; reg--) { + if (jit_regset_tstbit(&_jitc->function->regset, reg)) + break; + } + _jitc->breg = rn(reg) + 1; + _jitc->rout = _jitc->breg + 5; + ruse = _jitc->rout - GR_32; + + /* How many out argument registers required? */ + for (reg = _OUT0; reg <= _OUT7; reg++) { + if (!jit_regset_tstbit(&_jitc->function->regset, reg)) + break; + } + rout = reg - _OUT0; + + /* Match gcc prolog */ + ALLOC(_jitc->breg + 1, ruse, rout); + MOV(_jitc->breg + 2, GR_12); + MOV_rn_br(_jitc->breg, BR_0); + MOV(_jitc->breg + 3, GR_1); + /* lightning specific, use r4 as frame pointer */ + MOV(_jitc->breg + 4, GR_4); + + /* setup frame pointer */ + if (!jit_regset_tstbit(&_jitc->function->regset, _R3)) + MOV(GR_4, GR_12); + + /* adjust stack if required */ + if (_jitc->function->stack) + subi(GR_12, GR_12, _jitc->function->stack); +} + +static void +_epilog(jit_state_t *_jit, jit_node_t *node) +{ + MOV(GR_4, _jitc->breg + 4); + /* Match gcc epilog */ + MOV(GR_1, _jitc->breg + 3); + MOV_I_ar_rn(AR_PFS, _jitc->breg + 1); + MOV_br_rn(BR_0, _jitc->breg); + MOV(GR_12, _jitc->breg + 2); + BR_RET(BR_0); + flush(); +} + +static void +_patch_at(jit_state_t *_jit, jit_node_t *node, + jit_word_t instr, jit_word_t label) +{ + inst_lo_t l; + inst_hi_t h; + jit_word_t tm, s0, s1, s2; + union { + jit_word_t w; + jit_word_t *p; + } c; + jit_word_t i1, i41, i20, ic, i5, i9, i7; + + c.w = instr; l.w = c.p[0]; h.w = c.p[1]; + get_tm(tm); get_s0(s0); get_s1(s1); get_s2(s2); + switch (node->code) { + case jit_code_movi: + case jit_code_calli: + i1 = (label >> 63) & 0x1L; + i41 = (label >> 22) & 0x1ffffffffffL; + ic = (label >> 21) & 0x1L; + i5 = (label >> 16) & 0x1fL; + i9 = (label >> 7) & 0x1ffL; + i7 = label & 0x7fL; + s1 = i41; + assert((tm & ~1) == TM_M_L_X_ && + (s2 & 0xfL<<37) == (6L<<37) && + s0 == nop_m); + s2 &= (6L<<37)|(0x7fL<<6); + s2 |= (i1<<36)|(i9<<27)|(i5<<22)|(ic<<21)|(i7<<13); + break; + case jit_code_jmpi: + if (_jitc->jump) { + /* kludge to hide function descriptors; check that gp + * is zero, what is done for all jit functions */ + if (((long *)label)[1] == 0) { + for (ic = 0; ic < _jitc->prolog.offset; ic++) { + if (_jitc->prolog.ptr[ic] == label) { + label += 16; + break; + } + } + } + } + ic = (label - instr) >> 4; + i1 = (ic >> 61) & 0x1L; + i41 = (ic >> 22) & 0x1ffffffffffL; + i20 = ic & 0xfffffL; + assert((tm & ~1) == TM_M_L_X_ && + (s2 & 0xfL<<37) == (0xcL<<37) && + s0 == nop_m); + s1 = i41; + s2 &= (0xcL<<37)|(0x7L<<33)|(1L<<12); + s2 |= (i1<<36)|(i20<<13); + break; +#if 0 + case jit_code_calli: + label = *(jit_word_t *)label; + ic = (label - instr) >> 4; + i1 = (ic >> 61) & 0x1L; + i41 = (ic >> 22) & 0x1ffffffffffL; + i20 = ic & 0xfffffL; + assert((tm & ~1) == TM_M_L_X_ && + (s2 & 0xfL<<37) == (0xdL<<37) && + s0 == nop_m); + s1 = i41; + s2 &= (0xdL<<37)|(0x7L<<33)|(1L<<12)|(0x3L<<6); + s2 |= (i1<<36)|(i20<<13); + break; +#endif + default: + /* expected sequences are: + * A6, B1 (cmp_xxx, br_cond, ???) + * A8, B1 (cmpi_xxx, br_cond, ???) + * A4, B1 (mov, br_cond, ???) + * F4, B1 (fcmp_xxx, br_cond, ???) + * B1 (br, ???, ???) + */ + ic = (label - instr) >> 4; + switch (s0 >> 37) { + case 0x8: /* A4, B1 */ + /* validate s0 is register mov */ + assert((s0 & 0x3ffe0007e000L) == 0x800000000L); + /* validate s2 is br.cond */ + check_s1: + assert((s1 >> 37) == 4 && + (s1 & (7 << 6)) == 0 && + (s1 & 0x1f) != 0); + s1 &= (4L<<37)|(7L<<33)|(1L<<12)|0x1f; + s1 |= (((ic>>20)&1L)<<36)|((ic&0xfffffL)<<13); + break; + case 0xc: case 0xd: case 0xe: /* A6, B1 or A8, B1 */ + /* validate s0 is cmp.lt, cmp.ltu or cmq.eq */ + assert((s0 & ((1L<<33)|(1<<12))) == 0); + goto check_s1; + case 0x4: /* B1 or F4, B1 */ + if (s0 & 0x1f) /* F4,B1 */ + goto check_s1; + else { /* B1 */ + /* validate s0 is br */ + assert((s0 >> 37) == 4 && + (s0 & (7 << 6)) == 0 && + (s0 & 0x1f) == 0); + s0 &= (4L<<37)|(7L<<33)|(1L<<12)|0x1f; + s0 |= (((ic>>20)&1L)<<36)|((ic&0xfffffL)<<13); + } + break; + default: + abort(); + } + break; + } + to_tm(tm); to_s0(s0); to_s1(s1); to_s2(s2); + c.p[0] = l.w; + c.p[1] = h.w; +} +#endif diff --git a/lib/jit_ia64-fpu.c b/lib/jit_ia64-fpu.c new file mode 100644 index 000000000..30da6357b --- /dev/null +++ b/lib/jit_ia64-fpu.c @@ -0,0 +1,1530 @@ +/* + * Copyright (C) 2013 Free Software Foundation, Inc. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Authors: + * Paulo Cesar Pereira de Andrade + */ + +#if PROTO +#define SF_S0 0 +#define SF_S1 1 +#define SF_S2 2 +#define SF_S3 3 + +#define TSTFREG1(r0) \ + do { \ + if (jit_regset_tstbit(&_jitc->fprs, r0)) \ + stop(); \ + } while (0) +#define TSTFREG2(r0, r1) \ + do { \ + if (jit_regset_tstbit(&_jitc->fprs, r0) || \ + jit_regset_tstbit(&_jitc->fprs, r1)) \ + stop(); \ + } while (0) +#define TSTFREG3(r0, r1, r2) \ + do { \ + if (jit_regset_tstbit(&_jitc->fprs, r0) || \ + jit_regset_tstbit(&_jitc->fprs, r1) || \ + jit_regset_tstbit(&_jitc->fprs, r2)) \ + stop(); \ + } while (0) +#define SETFREG(r0) jit_regset_setbit(&_jitc->fprs, r0) + +/* libm */ +extern float sqrtf(float); +extern double sqrt(double); + +#define M7(x6,ht,r3,r2,f1) _M7(_jit,0,x6,ht,r3,r2,f1) +static void _M7(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M8(x6,ht,r3,im,f1) _M8(_jit,0,x6,ht,r3,im,f1) +static void _M8(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M9(x6,ht,r3,f1) _M9(_jit,0,x6,ht,r3,f1) +static void _M9(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M10(x6,ht,r3,r2,im) _M10(_jit,0,x6,ht,r3,r2,im) +static void _M10(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M11(x6,ht,r3,f2,f1) _M11(_jit,0,x6,ht,r3,f2,f1) +static void _M11(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M12(x6,ht,r3,f2,f1) _M12(_jit,0,x6,ht,r3,f2,f1) +static void _M12(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define M18(x6,r2,f1) _M18(_jit,0,x6,r2,f1) +static void _M18(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M19(x6,f2,r1) _M19(_jit,0,x6,f2,r1) +static void _M19(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define M21(f2,im) M20x(0x3,f2,im) +#define M23(x3,im,f1) M22x(x3,im,f1) +#define M27(f1) M26x(3,f1) +#define F1(op,x,sf,f4,f3,f2,f1) F1_(_jit,0,op,x,sf,f4,f3,f2,f1) +#define F2(x2,f4,f3,f2,f1) F1(0xe,1,x2,f4,f3,f2,f1) +#define F3(f4,f3,f2,f1) F1(0xe,0,0,f4,f3,f2,f1) +static void F1_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define F4(rb,sf,ra,p2,f3,f2,ta,p1) F4_(_jit,0,rb,sf,ra,p2,f3,f2,ta,p1) +static void F4_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define F5(p2,fc,f2,ta,p1) F5_(_jit,0,p2,fc,f2,ta,p1) +static void F5_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define F6x(op,q,sf,p2,f3,f2,f1) F6x_(_jit,0,op,q,sf,p2,f3,f2,f1) +#define F6(op,sf,p2,f3,f2,f1) F6x(op,0,sf,p2,f3,f2,f1) +#define F7(op,sf,p2,f3,f1) F6x(op,1,sf,p2,f3,0,f1) +static void F6x_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define F8(op,sf,x6,f3,f2,f1) F8_(_jit,0,op,sf,x6,f3,f2,f1) +#define F9(op,x6,f3,f2,f1) F8(op,0,x6,f3,f2,f1) +#define F10(op,sf,x6,f2,f1) F8(op,sf,x6,0,f2,f1) +#define F11(x6,f2,f1) F8(0,0,x6,0,f2,f1) +static void F8_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t, + jit_word_t,jit_word_t,jit_word_t); +#define F12(sf,x6,omsk,amsk) F12_(_jit,0,sf,x6,omsk,amsk) +#define F13(sf,x6) F12(sf,x6,0,0) +static void F12_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define F14x(sf,x,x6,im) F14x_(_jit,0,sf,x,x6,im) +#define F14(sf,im) F14x(sf,0,8,im) +#define F15(im) F14x(0,0,0,im) +static void F14x_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t,jit_word_t,jit_word_t); +#define F16(y,im) F16_(_jit,0,y,im) +static void F16_(jit_state_t*,jit_word_t, + jit_word_t,jit_word_t); + +/* break */ +#define BREAK_F(im) F15(im) +/* chk */ +#define CHK_S(f2,im) M21(f2,im) +#define CHKF_A_NC(f1,im) M23(0x6,im,f1) +#define CHKF_A_CLR(f1,im) M23(0x7,im,f1) +/* fabs */ +#define FABS(f1,f3) FMERGE_S(f1,0,f3) +/* fadd */ +#define FADD(f1,f3,f2) FMA(f1,f3,1,f2) +#define FADD_S(f1,f3,f2) FMA_S(f1,f3,1,f2) +#define FADD_D(f1,f3,f2) FMA_D(f1,f3,1,f2) +/* famax */ +#define FAMAX(f1,f2,f3) F8(0,SF_S0,0x17,f3,f2,f1) +/* famin */ +#define FAMIN(f1,f2,f3) F8(0,SF_S0,0x16,f3,f2,f1) +/* fand */ +#define FAND(f1,f2,f3) F9(0,0x2c,f3,f2,f1) +/* fandcm */ +#define FANDCM(f1,f2,f3) F9(0,0x2d,f3,f2,f1) +/* fchkf */ +#define FCHKF(im) F14(SF_S0,im) +/* fclass */ +#define FCLASS_M(p1,p2,f2,fc) F5(p2,fc,f2,0,p1) +#define FCLASS_M_UNC(p1,p2,f2,fc) F5(p2,fc,f2,1,p1) +/* fclrf */ +#define FCLRF() F13(SF_S0,5) +/* fcmp */ +#define FCMP_EQ(p1,p2,f2,f3) F4(0,SF_S0,0,p2,f3,f2,0,p1) +#define FCMP_LT(p1,p2,f2,f3) F4(1,SF_S0,0,p2,f3,f2,0,p1) +#define FCMP_LE(p1,p2,f2,f3) F4(0,SF_S0,1,p2,f3,f2,0,p1) +#define FCMP_UNORD(p1,p2,f2,f3) F4(1,SF_S0,1,p2,f3,f2,0,p1) +#define FCMP_EQ_UNC(p1,p2,f2,f3) F4(0,SF_S0,0,p2,f3,f2,1,p1) +#define FCMP_LT_UNC(p1,p2,f2,f3) F4(1,SF_S0,0,p2,f3,f2,1,p1) +#define FCMP_LE_UNC(p1,p2,f2,f3) F4(0,SF_S0,1,p2,f3,f2,1,p1) +#define FCMP_UNORD_UNC(p1,p2,f2,f3) F4(1,SF_S0,1,p2,f3,f2,1,p1) +/* fcvt.fx */ +#define FCVT_FX(f1,f2) F10(0,SF_S0,0x18,f2,f1) +#define FCVT_FXU(f1,f2) F10(0,SF_S0,0x19,f2,f1) +#define FCVT_FX_TRUNC(f1,f2) F10(0,SF_S0,0x1a,f2,f1) +#define FCVT_FXU_TRUNC(f1,f2) F10(0,SF_S0,0x1b,f2,f1) +/* fcvt.xf */ +#define FCVT_XF(f1,f2) F11(0x1c,f1,f2) +/* fcvt.fxuf */ +#define FCVT_XUF(f1,f3) FMA(f1,f3,1,0) +/* fma */ +#define FMA(f1,f3,f4,f2) F1(0x8,0,SF_S0,f4,f3,f3,f1) +#define FMA_p(f1,f3,f4,f2,sf,_p) F1_(_jit,_p,0x8,0,sf,f4,f3,f3,f1) +#define FMA_S(f1,f3,f4,f2) F1(0x8,1,SF_S0,f4,f3,f3,f1) +#define FMA_S_p(f1,f3,f4,f2,sf,_p) F1_(_jit,_p,0x8,1,sf,f4,f3,f3,f1) +#define FMA_D(f1,f3,f4,f2) F1(0x9,0,SF_S0,f4,f3,f3,f1) +#define FMA_D_p(f1,f3,f4,f2,sf,_p) F1_(_jit,_p,0x9,0,sf,f4,f3,f3,f1) +/* fmax */ +#define FMAX(f1,f2,f3) F8(0,SF_S0,0x15,f3,f2,f1) +/* fmerge */ +#define FMERGE_S(f1,f2,f3) F9(0,0x10,f3,f2,f1) +#define FMERGE_NS(f1,f2,f3) F9(0,0x11,f3,f2,f1) +#define FMERGE_SE(f1,f2,f3) F9(0,0x12,f3,f2,f1) +/* fmin */ +#define FMIN(f1,f2,f3) F8(0,SF_S0,0x14,f3,f2,f1) +/* fmix */ +#define FMIX_LR(f1,f2,f3) F9(0,0x39,f3,f2,f1) +#define FMIX_R(f1,f2,f3) F9(0,0x3a,f3,f2,f1) +#define FMIX_L(f1,f2,f3) F9(0,0x3b,f3,f2,f1) +/* fmpy */ +#define FMPY(f1,f3,f4) FMA(f1,f3,f4,0) +#define FMPY_p(f1,f3,f4,sf,_p) FMA_p(f1,f3,f4,0,sf,_p) +#define FMPY_S(f1,f3,f4) FMA_S(f1,f3,f4,0) +#define FMPY_S_p(f1,f3,f4,sf,_p) FMA_S_p(f1,f3,f4,0,sf,_p) +#define FMPY_D(f1,f3,f4) FMA_D(f1,f3,f4,0) +#define FMPY_D_p(f1,f3,f4,sf,_p) FMA_D_p(f1,f3,f4,0,sf,_p) +/* fms */ +#define FMS(f1,f3,f4,f2) F1(0xa,0,SF_S0,f4,f3,f3,f1) +#define FMS_S(f1,f3,f4,f2) F1(0xa,1,SF_S0,f4,f3,f3,f1) +#define FMS_D(f1,f3,f4,f2) F1(0xb,0,SF_S0,f4,f3,f3,f1) +/* fneg */ +#define FNEG(f1,f3) FMERGE_NS(f1,f3,f3) +/* fnegabs */ +#define FNEGABS(f1,f3) FMERGE_NS(f1,0,f3) +/* fnma */ +#define FNMA(f1,f3,f4,f2) F1(0xc,0,SF_S0,f4,f3,f3,f1) +#define FNMA_p(f1,f3,f4,f2,sf,_p) F1_(_jit,_p,0xc,0,sf,f4,f3,f3,f1) +#define FNMA_S(f1,f3,f4,f2) F1(0xc,1,SF_S0,f4,f3,f3,f1) +#define FNMA_D(f1,f3,f4,f2) F1(0xd,0,SF_S0,f4,f3,f3,f1) +/* fnmpy */ +#define FNMPY(f1,f3,f4) FNMA(f1,f3,f4,0) +/* fnorm */ +#define FNORM(f1,f3) FMA(f1,f3,1,0) +/* for */ +#define FOR(f1,f2,f3) F9(0,0x2e,f3,f2,f1) +/* fpabs */ +#define FPABS(f1,f3) FPMERGE_S(f1,0,f3) +/* fpack */ +#define FPACK(f1,f2,f3) F9(0,0x28,f3,f2,f1) +/* fpamax */ +#define FPAMAX(f1,f2,f3) F8(1,SF_S0,0x17,f3,f2,f1) +/* fpamin */ +#define FPAMIN(f1,f2,f3) F8(1,SF_S0,0x16,f3,f2,f1) +/* fpcmp */ +#define FPCMP_EQ(f1,f2,f3) F8(1,SF_S0,0x30,f3,f2,f1) +#define FPCMP_LT(f1,f2,f3) F8(1,SF_S0,0x31,f3,f2,f1) +#define FPCMP_LE(f1,f2,f3) F8(1,SF_S0,0x32,f3,f2,f1) +#define FPCMP_UNORD(f1,f2,f3) F8(1,SF_S0,0x33,f3,f2,f1) +#define FPCMP_NEQ(f1,f2,f3) F8(1,SF_S0,0x34,f3,f2,f1) +#define FPCMP_NLT(f1,f2,f3) F8(1,SF_S0,0x35,f3,f2,f1) +#define FPCMP_NLE(f1,f2,f3) F8(1,SF_S0,0x36,f3,f2,f1) +#define FPCMP_ORD(f1,f2,f3) F8(1,SF_S0,0x37,f3,f2,f1) +/* fpcvt.fx */ +#define FPCVT_FX(f1,f2) F10(1,SF_S0,0x18,f2,f1) +#define FPCVT_FXU(f1,f2) F10(1,SF_S0,0x19,f2,f1) +#define FPCVT_FX_TRUNC(f1,f2) F10(1,SF_S0,0x1a,f2,f1) +#define FPCVT_FXU_TRUNC(f1,f2) F10(1,SF_S0,0x1b,f2,f1) +/* fpma */ +#define FPMA(f1,f3,f4,f2) F1(0x9,1,SF_S0,f4,f3,f3,f1) +/* fpmax */ +#define FPMAX(f1,f2,f3) F8(1,SF_S0,0x15,f3,f2,f1) +/* fpmerge */ +#define FPMERGE_S(f1,f2,f3) F9(1,0x10,f3,f2,f1) +#define FPMERGE_NS(f1,f2,f3) F9(1,0x11,f3,f2,f1) +#define FPMERGE_SE(f1,f2,f3) F9(1,0x12,f3,f2,f1) +/* fpmin */ +#define FPMIN(f1,f2,f3) F8(1,SF_S0,0x14,f3,f2,f1) +/* fpmpy */ +#define FPMPY(f1,f3,f4) FPMA(f1,f3,f4,0) +/* fpms */ +#define FPMS(f1,f3,f4,f2) F1(0xb,1,SF_S0,f4,f3,f3,f1) +/* fpneg */ +#define FPNEG(f1,f3) FPMERGE_NS(f1,f3,f3) +/* fpnegabs */ +#define FPNEGABS(f1,f3) FPMERGE_NS(f1,0,f3) +/* fpnma */ +#define FPNMA(f1,f3,f4,f2) F1(0xd,1,SF_S0,f4,f3,f3,f1) +/* fpnmpy */ +#define FPNMPY(f1,f3,f4) FPNMA(f1,f3,f4,0) +/* fprcpa */ +#define FPRCPA(f1,p2,f2,f3) F6(1,SF_S0,p2,f3,f2,f1) +/* fprsqrta */ +#define FPRSQRTA(f1,p2,f3) F7(1,SF_S0,p2,f3,f1) +/* frcpa */ +#define FRCPA(f1,p2,f2,f3) F6(0,SF_S0,p2,f3,f2,f1) +/* frsqrta */ +#define FRSQRTA(f1,p2,f3) F7(0,SF_S0,p2,f3,f1) +/* fselect */ +#define FSELECT(f1,f3,f4,f2) F3(f4,f3,f2,f1) +#define FSETC(amsk,omsk) F12(SF_S0,4,omsk,amsk) +/* fsub */ +#define FSUB(f1,f3,f2) FMS(f1,f3,1,f2) +#define FSUB_S(f1,f3,f2) FMS_S(f1,f3,1,f2) +#define FSUB_D(f1,f3,f2) FMS_D(f1,f3,1,f2) +/* fswap */ +#define FSWAP(f1,f2,f3) F9(0,0x34,f3,f2,f1) +#define FSWAP_NL(f1,f2,f3) F9(0,0x35,f3,f2,f1) +#define FSWAP_NR(f1,f2,f3) F9(0,0x36,f3,f2,f1) +/* fsxt */ +#define FSXT_R(f1,f2,f3) F9(0,0x3c,f3,f2,f1) +#define FSXT_L(f1,f2,f3) F9(0,0x3d,f3,f2,f1) +/* fxor */ +#define FXOR(f1,f2,f3) F9(0,0x2f,f3,f2,f1) +/* getf */ +#define GETF_S(r1,f2) M19(0x1e,f2,r1) +#define GETF_D(r1,f2) M19(0x1f,f2,r1) +#define GETF_EXP(r1,f2) M19(0x1d,f2,r1) +#define GETF_SIG(r1,f2) M19(0x1c,f2,r1) +/* hint */ +#define HINT_F(im) F16(1,im) +/* invala */ +#define INVALAF_E(f1) M27(f1) +/* ldf */ +#define LDFS(f1,r3) M9(0x02,LD_NONE,r3,f1) +#define LDFD(f1,r3) M9(0x03,LD_NONE,r3,f1) +#define LDF8(f1,r3) M9(0x01,LD_NONE,r3,f1) +#define LDFE(f1,r3) M9(0x00,LD_NONE,r3,f1) +#define LDFS_S(f1,r3) M9(0x06,LD_NONE,r3,f1) +#define LDFD_S(f1,r3) M9(0x07,LD_NONE,r3,f1) +#define LDF8_S(f1,r3) M9(0x05,LD_NONE,r3,f1) +#define LDFE_S(f1,r3) M9(0x04,LD_NONE,r3,f1) +#define LDFS_A(f1,r3) M9(0x0a,LD_NONE,r3,f1) +#define LDFD_A(f1,r3) M9(0x0b,LD_NONE,r3,f1) +#define LDF8_A(f1,r3) M9(0x09,LD_NONE,r3,f1) +#define LDFE_A(f1,r3) M9(0x08,LD_NONE,r3,f1) +#define LDFS_SA(f1,r3) M9(0x0e,LD_NONE,r3,f1) +#define LDFD_SA(f1,r3) M9(0x0f,LD_NONE,r3,f1) +#define LDF8_SA(f1,r3) M9(0x0d,LD_NONE,r3,f1) +#define LDFE_SA(f1,r3) M9(0x0c,LD_NONE,r3,f1) +#define LDF_FILL(f1,r3) M9(0x1b,LD_NONE,r3,f1) +#define LDFS_C_CLR(f1,r3) M9(0x22,LD_NONE,r3,f1) +#define LDFD_C_CLR(f1,r3) M9(0x23,LD_NONE,r3,f1) +#define LDF8_C_CLR(f1,r3) M9(0x21,LD_NONE,r3,f1) +#define LDFE_C_CLR(f1,r3) M9(0x20,LD_NONE,r3,f1) +#define LDFS_C_NC(f1,r3) M9(0x26,LD_NONE,r3,f1) +#define LDFD_C_NC(f1,r3) M9(0x27,LD_NONE,r3,f1) +#define LDF8_C_NC(f1,r3) M9(0x25,LD_NONE,r3,f1) +#define LDFE_C_NC(f1,r3) M9(0x24,LD_NONE,r3,f1) +#define LDXFS(f1,r3,r2) M7(0x02,LD_NONE,r3,r2,f1) +#define LDXFD(f1,r3,r2) M7(0x03,LD_NONE,r3,r2,f1) +#define LDXF8(f1,r3,r2) M7(0x01,LD_NONE,r3,r2,f1) +#define LDXFE(f1,r3,r2) M7(0x00,LD_NONE,r3,r2,f1) +#define LDXFS_S(f1,r3,r2) M7(0x06,LD_NONE,r3,r2,f1) +#define LDXFD_S(f1,r3,r2) M7(0x07,LD_NONE,r3,r2,f1) +#define LDXF8_S(f1,r3,r2) M7(0x05,LD_NONE,r3,r2,f1) +#define LDXFE_S(f1,r3,r2) M7(0x04,LD_NONE,r3,r2,f1) +#define LDXFS_A(f1,r3,r2) M7(0x0a,LD_NONE,r3,r2,f1) +#define LDXFD_A(f1,r3,r2) M7(0x0b,LD_NONE,r3,r2,f1) +#define LDXF8_A(f1,r3,r2) M7(0x09,LD_NONE,r3,r2,f1) +#define LDXFE_A(f1,r3,r2) M7(0x08,LD_NONE,r3,r2,f1) +#define LDXFS_SA(f1,r3,r2) M7(0x0e,LD_NONE,r3,r2,f1) +#define LDXFD_SA(f1,r3,r2) M7(0x0f,LD_NONE,r3,r2,f1) +#define LDXF8_SA(f1,r3,r2) M7(0x0d,LD_NONE,r3,r2,f1) +#define LDXFE_SA(f1,r3,r2) M7(0x0c,LD_NONE,r3,r2,f1) +#define LDXFS_FILL(f1,r3,r2) M7(0x1b,LD_NONE,r3,r2,f1) +#define LDXFS_C_CLR(f1,r3,r2) M7(0x22,LD_NONE,r3,r2,f1) +#define LDXFD_C_CLR(f1,r3,r2) M7(0x23,LD_NONE,r3,r2,f1) +#define LDXF8_C_CLR(f1,r3,r2) M7(0x21,LD_NONE,r3,r2,f1) +#define LDXFE_C_CLR(f1,r3,r2) M7(0x20,LD_NONE,r3,r2,f1) +#define LDXFS_C_NC(f1,r3,r2) M7(0x26,LD_NONE,r3,r2,f1) +#define LDXFD_C_NC(f1,r3,r2) M7(0x27,LD_NONE,r3,r2,f1) +#define LDXF8_C_NC(f1,r3,r2) M7(0x25,LD_NONE,r3,r2,f1) +#define LDXFE_C_NC(f1,r3,r2) M7(0x24,LD_NONE,r3,r2,f1) +#define LDFS_inc(f1,f3,im) M8(0x02,LD_NONE,f3,im,f1) +#define LDFD_inc(f1,f3,im) M8(0x03,LD_NONE,f3,im,f1) +#define LDF8_inc(f1,f3,im) M8(0x01,LD_NONE,f3,im,f1) +#define LDFE_inc(f1,f3,im) M8(0x00,LD_NONE,f3,im,f1) +#define LDFS_S_inc(f1,f3,im) M8(0x06,LD_NONE,f3,im,f1) +#define LDFD_S_inc(f1,f3,im) M8(0x07,LD_NONE,f3,im,f1) +#define LDF8_S_inc(f1,f3,im) M8(0x05,LD_NONE,f3,im,f1) +#define LDFE_S_inc(f1,f3,im) M8(0x04,LD_NONE,f3,im,f1) +#define LDFS_A_inc(f1,f3,im) M8(0x0a,LD_NONE,f3,im,f1) +#define LDFD_A_inc(f1,f3,im) M8(0x0b,LD_NONE,f3,im,f1) +#define LDF8_A_inc(f1,f3,im) M8(0x09,LD_NONE,f3,im,f1) +#define LDFE_A_inc(f1,f3,im) M8(0x08,LD_NONE,f3,im,f1) +#define LDF_FILL_inc(f1,f3,im) M8(0x1b,LD_NONE,f3,im,f1) +#define LDFS_C_CLR_inc(f1,f3,im) M8(0x22,LD_NONE,f3,im,f1) +#define LDFD_C_CLR_inc(f1,f3,im) M8(0x23,LD_NONE,f3,im,f1) +#define LDF8_C_CLR_inc(f1,f3,im) M8(0x21,LD_NONE,f3,im,f1) +#define LDFE_C_CLR_inc(f1,f3,im) M8(0x20,LD_NONE,f3,im,f1) +#define LDFS_C_NC_inc(f1,f3,im) M8(0x26,LD_NONE,f3,im,f1) +#define LDFD_C_NC_inc(f1,f3,im) M8(0x27,LD_NONE,f3,im,f1) +#define LDF8_C_NC_inc(f1,f3,im) M8(0x25,LD_NONE,f3,im,f1) +#define LDFE_C_NC_inc(f1,f3,im) M8(0x24,LD_NONE,f3,im,f1) +/* ldpf */ +#define LDFPS(f1,f2,r3) M11(0x02,LD_NONE,r3,f2,f1) +#define LDFPD(f1,f2,r3) M11(0x03,LD_NONE,r3,f2,f1) +#define LDFP8(f1,f2,r3) M11(0x01,LD_NONE,r3,f2,f1) +#define LDFPS_S(f1,f2,r3) M11(0x06,LD_NONE,r3,f2,f1) +#define LDFPD_S(f1,f2,r3) M11(0x07,LD_NONE,r3,f2,f1) +#define LDFP8_S(f1,f2,r3) M11(0x05,LD_NONE,r3,f2,f1) +#define LDFPS_A(f1,f2,r3) M11(0x0a,LD_NONE,r3,f2,f1) +#define LDFPD_A(f1,f2,r3) M11(0x0b,LD_NONE,r3,f2,f1) +#define LDFP8_A(f1,f2,r3) M11(0x09,LD_NONE,r3,f2,f1) +#define LDFPS_SA(f1,f2,r3) M11(0x0e,LD_NONE,r3,f2,f1) +#define LDFPD_SA(f1,f2,r3) M11(0x0f,LD_NONE,r3,f2,f1) +#define LDFP8_SA(f1,f2,r3) M11(0x0d,LD_NONE,r3,f2,f1) +#define LDFPS_C_CLR(f1,f2,r3) M11(0x22,LD_NONE,r3,f2,f1) +#define LDFPD_C_CLR(f1,f2,r3) M11(0x23,LD_NONE,r3,f2,f1) +#define LDFP8_C_CLR(f1,f2,r3) M11(0x21,LD_NONE,r3,f2,f1) +#define LDFPS_C_NC(f1,f2,r3) M11(0x26,LD_NONE,r3,f2,f1) +#define LDFPD_C_NC(f1,f2,r3) M11(0x27,LD_NONE,r3,f2,f1) +#define LDFP8_C_NC(f1,f2,r3) M11(0x25,LD_NONE,r3,f2,f1) +#define LDIFPS(f1,f2,r3) M12(0x02,LD_NONE,r3,f2,f1) +#define LDIFPD(f1,f2,r3) M12(0x03,LD_NONE,r3,f2,f1) +#define LDIFP8(f1,f2,r3) M12(0x01,LD_NONE,r3,f2,f1) +#define LDIFPS_S(f1,f2,r3) M12(0x06,LD_NONE,r3,f2,f1) +#define LDIFPD_S(f1,f2,r3) M12(0x07,LD_NONE,r3,f2,f1) +#define LDIFP8_S(f1,f2,r3) M12(0x05,LD_NONE,r3,f2,f1) +#define LDIFPS_A(f1,f2,r3) M12(0x0a,LD_NONE,r3,f2,f1) +#define LDIFPD_A(f1,f2,r3) M12(0x0b,LD_NONE,r3,f2,f1) +#define LDIFP8_A(f1,f2,r3) M12(0x09,LD_NONE,r3,f2,f1) +#define LDIFPS_SA(f1,f2,r3) M12(0x0e,LD_NONE,r3,f2,f1) +#define LDIFPD_SA(f1,f2,r3) M12(0x0f,LD_NONE,r3,f2,f1) +#define LDIFP8_SA(f1,f2,r3) M12(0x0d,LD_NONE,r3,f2,f1) +#define LDIFPS_C_CLR(f1,f2,r3) M12(0x22,LD_NONE,r3,f2,f1) +#define LDIFPD_C_CLR(f1,f2,r3) M12(0x23,LD_NONE,r3,f2,f1) +#define LDIFP8_C_CLR(f1,f2,r3) M12(0x21,LD_NONE,r3,f2,f1) +#define LDIFPS_C_NC(f1,f2,r3) M12(0x26,LD_NONE,r3,f2,f1) +#define LDIFPD_C_NC(f1,f2,r3) M12(0x27,LD_NONE,r3,f2,f1) +#define LDIFP8_C_NC(f1,f2,r3) M12(0x25,LD_NONE,r3,f2,f1) +/* mov - Move Floating-point Register */ +#define MOVF(f1,f3) FMERGE_S(f1,f3,f3) +/* nop */ +#define NOP_F(im) F16(0,im) +/* setf */ +#define SETF_S(f1,r2) M18(0x1e,r2,f1) +#define SETF_D(f1,r2) M18(0x1f,r2,f1) +#define SETF_EXP(f1,r2) M18(0x1d,r2,f1) +#define SETF_SIG(f1,r2) M18(0x1c,r2,f1) +/* stf */ +#define STFS(r3,f2) M13(0x32,ST_NONE,r3,f2) +#define STFD(r3,f2) M13(0x33,ST_NONE,r3,f2) +#define STF8(r3,f2) M13(0x31,ST_NONE,r3,f2) +#define STFE(r3,f2) M13(0x30,ST_NONE,r3,f2) +#define STF_SPILL(r3,f2) M13(0x3b,ST_NONE,r3,f2) +#define STFS_inc(r3,f2,im) M10(0x32,ST_NONE,r3,f2,im) +#define STFD_inc(r3,f2,im) M10(0x33,ST_NONE,r3,f2,im) +#define STF8_inc(r3,f2,im) M10(0x31,ST_NONE,r3,f2,im) +#define STFE_inc(r3,f2,im) M10(0x30,ST_NONE,r3,f2,im) +#define STF_SPILL_inc(r3,f2,im) M10(0x3b,ST_NONE,r3,f2,im) +/* xma */ +#define XMA_L(f1,f3,f4,f2) F2(0,f4,f3,f2,f1) +#define XMA_LU(f1,f3,f4,f2) XMA_L(f1,f3,f4,f2) +#define XMA_H(f1,f3,f4,f2) F2(3,f4,f3,f2,f1) +#define XMA_HU(f1,f3,f4,f2) F2(2,f4,f3,f2,f1) +/* xmpy */ +#define XMPY_L(f1,f3,f4) XMA_L(f1,f3,f4,0) +#define XMPY_LU(f1,f3,f4) XMA_L(f1,f3,f4,0) +#define XMPY_H(f1,f3,f4) XMA_H(f1,f3,f4,0) +#define XMPY_HU(f1,f3,f4) XMA_HU(f1,f3,f4,0) + +#define movr_f(r0,r1) movr_d(r0,r1) +#define movr_d(r0,r1) MOVF(r0,r1) +#define movi_f(r0,i0) ldi_f(r0,(jit_word_t)i0) +#define movi_d(r0,i0) ldi_d(r0,(jit_word_t)i0) + +#define absr_f(r0,r1) absr_d(r0,r1) +#define absr_d(r0,r1) FABS(r0,r1) +#define negr_f(r0,r1) negr_d(r0,r1) +#define negr_d(r0,r1) FNEG(r0,r1) +#define sqrtr_f(r0,r1) _sqrtr_f(_jit,r0,r1) +static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t); +#define sqrtr_d(r0,r1) _sqrtr_d(_jit,r0,r1) +static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t); +#define extr_f_d(r0,r1) /*FNORM(r0,r1)*/ +#define extr_d_f(r0,r1) /*FNORM(r0,r1)*/ +#define extr_f(r0,r1) extr_d(r0,r1) +#define extr_d(r0,r1) _extr_d(_jit,r0,r1) +static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t); +#define truncr_f_i(r0,r1) truncr_d_l(r0,r1) +#define truncr_d_i(r0,r1) truncr_d_l(r0,r1) +#define truncr_f_l(r0,r1) truncr_d_l(r0,r1) +#define truncr_d_l(r0,r1) _truncr_d_l(_jit,r0,r1) +static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t); +#define addr_f(r0,r1,r2) FADD_S(r0,r1,r2) +#define addi_f(r0,r1,i0) _addi_f(_jit,r0,r1,i0) +static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define addr_d(r0,r1,r2) FADD_D(r0,r1,r2) +#define addi_d(r0,r1,i0) _addi_d(_jit,r0,r1,i0) +static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define subr_f(r0,r1,r2) FSUB_S(r0,r1,r2) +#define subi_f(r0,r1,i0) _subi_f(_jit,r0,r1,i0) +static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define subr_d(r0,r1,r2) FSUB_D(r0,r1,r2) +#define subi_d(r0,r1,i0) _subi_d(_jit,r0,r1,i0) +static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define mulr_f(r0,r1,r2) FMPY_S(r0,r1,r2) +#define muli_f(r0,r1,i0) _muli_f(_jit,r0,r1,i0) +static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define mulr_d(r0,r1,r2) FMPY_D(r0,r1,r2) +#define muli_d(r0,r1,i0) _muli_d(_jit,r0,r1,i0) +static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define divr_f(r0,r1,r2) _divr_f(_jit,r0,r1,r2) +static void _divr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define divi_f(r0,r1,i0) _divi_f(_jit,r0,r1,i0) +static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define divr_d(r0,r1,r2) _divr_d(_jit,r0,r1,r2) +static void _divr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define divi_d(r0,r1,i0) _divi_d(_jit,r0,r1,i0) +static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ltr_f(r0,r1,r2) ltr_d(r0,r1,r2) +#define ltr_d(r0,r1,r2) _ltr_d(_jit,r0,r1,r2) +static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lti_f(r0,r1,i0) _lti_f(_jit,r0,r1,i0) +static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define lti_d(r0,r1,i0) _lti_d(_jit,r0,r1,i0) +static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ler_f(r0,r1,r2) ler_d(r0,r1,r2) +#define ler_d(r0,r1,r2) _ler_d(_jit,r0,r1,r2) +static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lei_f(r0,r1,i0) _lei_f(_jit,r0,r1,i0) +static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define lei_d(r0,r1,i0) _lei_d(_jit,r0,r1,i0) +static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define eqr_f(r0,r1,r2) eqr_d(r0,r1,r2) +#define eqr_d(r0,r1,r2) _eqr_d(_jit,r0,r1,r2) +static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define eqi_f(r0,r1,i0) _eqi_f(_jit,r0,r1,i0) +static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define eqi_d(r0,r1,i0) _eqi_d(_jit,r0,r1,i0) +static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ger_f(r0,r1,r2) ger_d(r0,r1,r2) +#define ger_d(r0,r1,r2) _ger_d(_jit,r0,r1,r2) +static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define gei_f(r0,r1,i0) _gei_f(_jit,r0,r1,i0) +static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define gei_d(r0,r1,i0) _gei_d(_jit,r0,r1,i0) +static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define gtr_f(r0,r1,r2) gtr_d(r0,r1,r2) +#define gtr_d(r0,r1,r2) _gtr_d(_jit,r0,r2,r1) +static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define gti_f(r0,r1,i0) _gti_f(_jit,r0,r1,i0) +static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define gti_d(r0,r1,i0) _gti_d(_jit,r0,r1,i0) +static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ner_f(r0,r1,r2) ner_d(r0,r1,r2) +#define ner_d(r0,r1,r2) _ner_d(_jit,r0,r1,r2) +static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define nei_f(r0,r1,i0) _nei_f(_jit,r0,r1,i0) +static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define nei_d(r0,r1,i0) _nei_d(_jit,r0,r1,i0) +static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define unltr_f(r0,r1,r2) unltr_d(r0,r1,r2) +#define unltr_d(r0,r1,r2) _unltr_d(_jit,r0,r1,r2) +static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define unlti_f(r0,r1,i0) _unlti_f(_jit,r0,r1,i0) +static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define unlti_d(r0,r1,i0) _unlti_d(_jit,r0,r1,i0) +static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define unler_f(r0,r1,r2) unler_d(r0,r1,r2) +#define unler_d(r0,r1,r2) _unler_d(_jit,r0,r1,r2) +static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define unlei_f(r0,r1,i0) _unlei_f(_jit,r0,r1,i0) +static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define unlei_d(r0,r1,i0) _unlei_d(_jit,r0,r1,i0) +static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define uneqr_f(r0,r1,r2) uneqr_d(r0,r1,r2) +#define uneqr_d(r0,r1,r2) _uneqr_d(_jit,r0,r1,r2) +static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define uneqi_f(r0,r1,i0) _uneqi_f(_jit,r0,r1,i0) +static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define uneqi_d(r0,r1,i0) _uneqi_d(_jit,r0,r1,i0) +static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define unger_f(r0,r1,r2) unger_d(r0,r1,r2) +#define unger_d(r0,r1,r2) _unger_d(_jit,r0,r1,r2) +static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ungei_f(r0,r1,i0) _ungei_f(_jit,r0,r1,i0) +static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define ungei_d(r0,r1,i0) _ungei_d(_jit,r0,r1,i0) +static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ungtr_f(r0,r1,r2) ungtr_d(r0,r1,r2) +#define ungtr_d(r0,r1,r2) _ungtr_d(_jit,r0,r1,r2) +static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ungti_f(r0,r1,i0) _ungti_f(_jit,r0,r1,i0) +static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define ungti_d(r0,r1,i0) _ungti_d(_jit,r0,r1,i0) +static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ltgtr_f(r0,r1,r2) ltgtr_d(r0,r1,r2) +#define ltgtr_d(r0,r1,r2) _ltgtr_d(_jit,r0,r1,r2) +static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ltgti_f(r0,r1,i0) _ltgti_f(_jit,r0,r1,i0) +static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define ltgti_d(r0,r1,i0) _ltgti_d(_jit,r0,r1,i0) +static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ordr_f(r0,r1,r2) ordr_d(r0,r1,r2) +#define ordr_d(r0,r1,r2) _ordr_d(_jit,r0,r1,r2) +static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define ordi_f(r0,r1,i0) _ordi_f(_jit,r0,r1,i0) +static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define ordi_d(r0,r1,i0) _ordi_d(_jit,r0,r1,i0) +static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define unordr_f(r0,r1,r2) unordr_d(r0,r1,r2) +#define unordr_d(r0,r1,r2) _unordr_d(_jit,r0,r1,r2) +static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define unordi_f(r0,r1,i0) _unordi_f(_jit,r0,r1,i0) +static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); +#define unordi_d(r0,r1,i0) _unordi_d(_jit,r0,r1,i0) +static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +#define ldr_f(r0,r1) LDFS(r0,r1) +#define ldi_f(r0,i0) _ldi_f(_jit,r0,i0) +static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxr_f(r0,r1,r2) LDXFS(r0,r1,r2) +#define ldxi_f(r0,r1,i0) _ldxi_f(_jit,r0,r1,i0) +static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldr_d(r0,r1) LDFD(r0,r1) +#define ldi_d(r0,i0) _ldi_d(_jit,r0,i0) +static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxi_d(r0,r1,i0) _ldxi_d(_jit,r0,r1,i0) +static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define ldxr_d(r0,r1,r2) LDXFD(r0,r1,r2) +#define str_f(r0,r1) STFS(r0,r1) +#define sti_f(i0,r0) _sti_f(_jit,i0,r0) +static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t); +#define stxr_f(r0,r1,r2) _stxr_f(_jit,r0,r1,r2) +static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1) +static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define str_d(r0,r1) STFD(r0,r1) +#define sti_d(i0,r0) _sti_d(_jit,i0,r0) +static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t); +#define stxr_d(r0,r1,r2) _stxr_d(_jit,r0,r1,r2) +static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define stxi_d(i0,r0,r1) _stxi_d(_jit,i0,r0,r1) +static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bltr_f(i0,r0,r1) bltr_d(i0,r0,r1) +#define bltr_d(i0,r0,r1) _bltr_d(_jit,i0,r0,r1) +static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define blti_f(i0,r0,i1) _blti_f(_jit,i0,r0,i1) +static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define blti_d(i0,r0,i1) _blti_d(_jit,i0,r0,i1) +static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bler_f(i0,r0,r1) bler_d(i0,r0,r1) +#define bler_d(i0,r0,r1) _bler_d(_jit,i0,r0,r1) +static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define blei_f(i0,r0,i1) _blei_f(_jit,i0,r0,i1) +static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define blei_d(i0,r0,i1) _blei_d(_jit,i0,r0,i1) +static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define beqr_f(i0,r0,r1) beqr_d(i0,r0,r1) +#define beqr_d(i0,r0,r1) _beqr_d(_jit,i0,r0,r1) +static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define beqi_f(i0,r0,i1) _beqi_f(_jit,i0,r0,i1) +static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define beqi_d(i0,r0,i1) _beqi_d(_jit,i0,r0,i1) +static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bger_f(i0,r0,r1) bger_d(i0,r0,r1) +#define bger_d(i0,r0,r1) _bger_d(_jit,i0,r0,r1) +static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bgei_f(i0,r0,i1) _bgei_f(_jit,i0,r0,i1) +static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bgei_d(i0,r0,i1) _bgei_d(_jit,i0,r0,i1) +static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bgtr_f(i0,r0,r1) bgtr_d(i0,r0,r1) +#define bgtr_d(i0,r0,r1) _bgtr_d(_jit,i0,r0,r1) +static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bgti_f(i0,r0,i1) _bgti_f(_jit,i0,r0,i1) +static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bgti_d(i0,r0,i1) _bgti_d(_jit,i0,r0,i1) +static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bner_f(i0,r0,r1) bner_d(i0,r0,r1) +#define bner_d(i0,r0,r1) _bner_d(_jit,i0,r0,r1) +static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bnei_f(i0,r0,i1) _bnei_f(_jit,i0,r0,i1) +static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bnei_d(i0,r0,i1) _bnei_d(_jit,i0,r0,i1) +static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bunltr_f(i0,r0,r1) bunltr_d(i0,r0,r1) +#define bunltr_d(i0,r0,r1) _bunltr_d(_jit,i0,r0,r1) +static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bunlti_f(i0,r0,i1) _bunlti_f(_jit,i0,r0,i1) +static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bunlti_d(i0,r0,i1) _bunlti_d(_jit,i0,r0,i1) +static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bunler_f(i0,r0,r1) bunler_d(i0,r0,r1) +#define bunler_d(i0,r0,r1) _bunler_d(_jit,i0,r0,r1) +static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bunlei_f(i0,r0,i1) _bunlei_f(_jit,i0,r0,i1) +static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bunlei_d(i0,r0,i1) _bunlei_d(_jit,i0,r0,i1) +static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define buneqr_f(i0,r0,r1) buneqr_d(i0,r0,r1) +#define buneqr_d(i0,r0,r1) _buneqr_d(_jit,i0,r0,r1) +static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define buneqi_f(i0,r0,i1) _buneqi_f(_jit,i0,r0,i1) +static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define buneqi_d(i0,r0,i1) _buneqi_d(_jit,i0,r0,i1) +static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bunger_f(i0,r0,r1) bunger_d(i0,r0,r1) +#define bunger_d(i0,r0,r1) _bunger_d(_jit,i0,r0,r1) +static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bungei_f(i0,r0,i1) _bungei_f(_jit,i0,r0,i1) +static jit_word_t _bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bungei_d(i0,r0,i1) _bungei_d(_jit,i0,r0,i1) +static jit_word_t _bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bungtr_f(i0,r0,r1) bungtr_d(i0,r0,r1) +#define bungtr_d(i0,r0,r1) _bungtr_d(_jit,i0,r0,r1) +static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bungti_f(i0,r0,i1) _bungti_f(_jit,i0,r0,i1) +static jit_word_t _bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bungti_d(i0,r0,i1) _bungti_d(_jit,i0,r0,i1) +static jit_word_t _bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bltgtr_f(i0,r0,r1) bltgtr_d(i0,r0,r1) +#define bltgtr_d(i0,r0,r1) _bltgtr_d(_jit,i0,r0,r1) +static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bltgti_f(i0,r0,i1) _bltgti_f(_jit,i0,r0,i1) +static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bltgti_d(i0,r0,i1) _bltgti_d(_jit,i0,r0,i1) +static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bordr_f(i0,r0,r1) bordr_d(i0,r0,r1) +#define bordr_d(i0,r0,r1) _bordr_d(_jit,i0,r0,r1) +static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bordi_f(i0,r0,i1) _bordi_f(_jit,i0,r0,i1) +static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bordi_d(i0,r0,i1) _bordi_d(_jit,i0,r0,i1) +static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#define bunordr_f(i0,r0,r1) bunordr_d(i0,r0,r1) +#define bunordr_d(i0,r0,r1) _bunordr_d(_jit,i0,r0,r1) +static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bunordi_f(i0,r0,i1) _bunordi_f(_jit,i0,r0,i1) +static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*); +#define bunordi_d(i0,r0,i1) _bunordi_d(_jit,i0,r0,i1) +static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*); +#endif + +#if CODE +static void +_M7(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(r2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTREG2(r2, r3); + inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)| + (r3<<20)|(r2<<13)|(f1<<6)|_p, INST_M); + SETFREG(f1); + SETREG(r3); +} + +static void +_M8(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(im > -256 && im < 255); + assert(!(f1 & ~0x7fL)); + TSTREG1(r3); + inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)| + (((im>>8)&1L)<<27)|(r3<<20)|((im&0x7fLL)<<13)|(f1<<6)|_p, INST_M); + SETFREG(f1); + SETREG(r3); +} + +static void +_M9(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTREG1(r3); + inst((6L<<37)|(x6<<30)|(ht<<28)|(r3<<20)|(f1<<6)|_p, INST_M); + SETFREG(f1); +} + +static void +_M10(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(im > -256 && im < 255); + TSTREG1(r3); + TSTFREG1(f2); + inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)| + (((im>>8)&1L)<<27)|(r3<<20)|(f2<<13)|((im&0x7fL)<<6)|_p, INST_M); + SETREG(r3); +} + +static void +_M11(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTREG1(r3); + inst((6L<<37)|(x6<<30)|(ht<<28)|(1L<<27)| + (r3<<20)|(f2<<13)|(f1<<6)|_p, INST_M); + SETFREG(f1); + SETFREG(f2); +} + +static void +_M12(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(ht & ~0x3L)); + assert(!(r3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTREG1(r3); + inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)| + (1L<<27)|(r3<<20)|(f2<<13)|(f1<<6)|_p, INST_M); + SETFREG(f1); + SETFREG(f2); + SETREG(r3); +} + +static void +_M18(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t r2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(r2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTREG1(r2); + inst((6L<<37)|(x6<<30)|(1L<<27)|(r2<<13)|(f1<<6)|_p, INST_M); + SETFREG(f1); +} + +static void +_M19(jit_state_t *_jit, jit_word_t _p, + jit_word_t x6, jit_word_t f2, jit_word_t r1) +{ + assert(!(_p & ~0x3fL)); + assert(!(x6 & ~0x3fL)); + assert(!(f2 & ~0x7fL)); + assert(!(r1 & ~0x7fL)); + TSTFREG1(f2); + inst((4L<<37)|(x6<<30)|(1L<<27)|(f2<<13)|(r1<<6)|_p, INST_M); + SETREG(r1); +} + +static void +F1_(jit_state_t *_jit, jit_word_t _p, + jit_word_t op, jit_word_t x, jit_word_t sf, + jit_word_t f4, jit_word_t f3, jit_word_t f2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(op & ~0xfL)); + assert(!(x & ~0x1L)); + assert(!(sf & ~0x3L)); + assert(!(f4 & ~0x7fL)); + assert(!(f3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTFREG3(f2, f3, f4); + inst((op<<37)|(x<<36)|(sf<<34)|(f4<<27)| + (f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F); + SETFREG(f1); +} + +static void +F4_(jit_state_t *_jit, jit_word_t _p, + jit_word_t rb, jit_word_t sf, jit_word_t ra, jit_word_t p2, + jit_word_t f3, jit_word_t f2, jit_word_t ta, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(rb & ~0x1L)); + assert(!(sf & ~0x3L)); + assert(!(ra & ~0x1L)); + assert(!(p2 & ~0x3fL)); + assert(!(f3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(!(ta & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTFREG2(f2, f3); + inst((4L<<37)|(rb<<36)|(sf<<34)|(ra<<33)|(p2<<27)| + (f3<<20)|(f2<<13)|(ta<<12)|(p1<<6)|_p, INST_F); +} + +static void +F5_(jit_state_t *_jit, jit_word_t _p, + jit_word_t p2, jit_word_t fc, jit_word_t f2, jit_word_t ta, jit_word_t p1) +{ + assert(!(_p & ~0x3fL)); + assert(!(p2 & ~0x3fL)); + assert(!(fc & ~0x1ffL)); + assert(!(f2 & ~0x7fL)); + assert(!(ta & ~0x1L)); + assert(!(p1 & ~0x3fL)); + TSTFREG1(f2); + inst((5L<<37)|(((fc>>7)&3L)<<33)|(p2<<27)| + ((fc&0x7fL)<<20)|(f2<<13)|(ta<<12)|(p1<<6)|_p, INST_F); +} + +static void +F6x_(jit_state_t *_jit, jit_word_t _p, + jit_word_t op, jit_word_t q, jit_word_t sf, + jit_word_t p2, jit_word_t f3, jit_word_t f2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(op & ~0xfL)); + assert(!(q & ~0x1L)); + assert(!(sf & ~0x3L)); + assert(!(p2 & ~0x3fL)); + assert(!(f3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTFREG2(f2, f3); + inst((op<<37)|(q<<36)|(sf<<34)|(1L<<33)| + (p2<<27)|(f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F); + SETFREG(f1); +} + +static void +F8_(jit_state_t *_jit, jit_word_t _p, + jit_word_t op, jit_word_t sf, jit_word_t x6, + jit_word_t f3, jit_word_t f2, jit_word_t f1) +{ + assert(!(_p & ~0x3fL)); + assert(!(op & ~0xfL)); + assert(!(sf & ~0x3L)); + assert(!(x6 & ~0x3fL)); + assert(!(f3 & ~0x7fL)); + assert(!(f2 & ~0x7fL)); + assert(!(f1 & ~0x7fL)); + TSTFREG2(f2, f3); + inst((op<<37)|(sf<<34)|(x6<<27)|(f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F); + SETFREG(f1); +} + +static void +F12_(jit_state_t *_jit, jit_word_t _p, + jit_word_t sf, jit_word_t x6, jit_word_t omsk, jit_word_t amsk) +{ + assert(!(_p & ~0x3fL)); + assert(!(sf & ~0x3L)); + assert(!(x6 & ~0x3fL)); + assert(!(omsk & ~0x7fL)); + assert(!(amsk & ~0x7fL)); + /* no registers referenced */ + inst((sf<<34)|(x6<<27)|(omsk<<20)|(amsk<<13), INST_F); +} + +static void +F14x_(jit_state_t* _jit, jit_word_t _p, + jit_word_t sf, jit_word_t x, jit_word_t x6, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(sf & ~0x3L)); + assert(!(x & ~0x1L)); + assert(!(x6 & ~0x3fL)); + assert(!(im & ~0x1ffffL)); + /* no registers referenced */ + inst((((im>>20)&1L)<<36)|(sf<<34)|(x<<33)| + (x6<<27)|((im&0xffffL)<<6)|_p, INST_F); +} + +static void +F16_(jit_state_t* _jit, jit_word_t _p, + jit_word_t y, jit_word_t im) +{ + assert(!(_p & ~0x3fL)); + assert(!(y & ~0x1L)); + assert(!(im & ~0x1ffffL)); + /* no registers referenced */ + inst((((im>>20)&1L)<<36)|(y<<27)|(1L<<26)|((im&0xffffL)<<6)|_p, INST_F); +} + +#define fpr_opi(name, type, size) \ +static void \ +_##name##i_##type(jit_state_t *_jit, \ + jit_int32_t r0, jit_int32_t r1, \ + jit_float##size##_t *i0) \ +{ \ + jit_int32_t reg = jit_get_reg(jit_class_fpr); \ + movi_##type(rn(reg), i0); \ + name##r_##type(r0, r1, rn(reg)); \ + jit_unget_reg(reg); \ +} +#define fpr_bopi(name, type, size) \ +static jit_word_t \ +_b##name##i_##type(jit_state_t *_jit, \ + jit_word_t i0, jit_int32_t r0, \ + jit_float##size##_t *i1) \ +{ \ + jit_word_t word; \ + jit_int32_t reg = jit_get_reg(jit_class_fpr); \ + movi_##type(rn(reg), i1); \ + word = b##name##r_##type(i0, r0, rn(reg)); \ + jit_unget_reg(reg); \ + return (word); \ +} +#define fopi(name) fpr_opi(name, f, 32) +#define fbopi(name) fpr_bopi(name, f, 32) +#define dopi(name) fpr_opi(name, d, 64) +#define dbopi(name) fpr_bopi(name, d, 64) + +fopi(add) +fopi(sub) +fopi(mul) +fopi(div) +dopi(add) +dopi(sub) +dopi(mul) +dopi(div) + +/* translation from gcc -O0 */ +static void +_divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t t0, t1, t2, t3; + t0 = jit_get_reg(jit_class_fpr); + t1 = jit_get_reg(jit_class_fpr); + t2 = jit_get_reg(jit_class_fpr); + t3 = jit_get_reg(jit_class_fpr); + FRCPA(rn(t0), PR_6, r1, r2); + FNMA_p(rn(t1), r2, rn(t0), 1, SF_S1, PR_6); + FMA_p(rn(t2), rn(t0), rn(t1), rn(t0), SF_S1, PR_6); + FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6); + FMA_p(rn(t2), rn(t2), rn(t1), rn(t2), SF_S1, PR_6); + FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6); + FMA_p(rn(t1), rn(t2), rn(t1), rn(t2), SF_S1, PR_6); + FMPY_S_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6); + FNMA_p(rn(t3), r2, rn(t2), r1, SF_S1, PR_6); + FMA_S_p(r0, rn(t3), rn(t1), 1, SF_S0, PR_6); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + +static void +_divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t t0, t1, t2, t3; + t0 = jit_get_reg(jit_class_fpr); + t1 = jit_get_reg(jit_class_fpr); + t2 = jit_get_reg(jit_class_fpr); + t3 = jit_get_reg(jit_class_fpr); + FRCPA(rn(t0), PR_6, r1, r2); + FNMA_p(rn(t1), r2, rn(t0), 1, SF_S1, PR_6); + FMA_p(rn(t2), rn(t0), rn(t1), rn(t0), SF_S1, PR_6); + FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6); + FMA_p(rn(t2), rn(t2), rn(t1), rn(t2), SF_S1, PR_6); + FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6); + FMA_p(rn(t1), rn(t2), rn(t1), rn(t2), SF_S1, PR_6); + FMPY_D_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6); + FNMA_p(rn(t3), r2, rn(t2), r1, SF_S1, PR_6); + FMA_D_p(r0, rn(t3), rn(t1), 1, SF_S0, PR_6); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + +static void +_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + SETF_SIG(rn(reg), r1); + FCVT_XF(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + FCVT_FX_TRUNC(rn(reg), r1); + GETF_SIG(r0, rn(reg)); + FNORM(r0, r0); + jit_unget_reg(reg); +} + +static void +_ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LT(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} +fopi(lt) +dopi(lt) + +static void +_ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LE(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} +fopi(le) +dopi(le) + +static void +_eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_EQ(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} +fopi(eq) +dopi(eq) + +static void +_ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LE(PR_6, PR_7, r2, r1); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} +fopi(ge) +dopi(ge) + +static void +_gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LT(PR_6, PR_7, r2, r1); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} +fopi(gt) +dopi(gt) + +static void +_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_EQ(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} +fopi(ne) +dopi(ne) + +static void +_unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LE(PR_6, PR_7, r2, r1); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} +fopi(unlt) +dopi(unlt) + +static void +_unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LT(PR_6, PR_7, r2, r1); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} +fopi(unle) +dopi(unle) + +static void +_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + MOVI(r0, 1); + FCMP_LT(PR_8, PR_9, r1, r2); + FCMP_LT(PR_6, PR_7, r2, r1); + MOV_p(r0, GR_0, PR_8); /* !(r1 < r2) && !(r2 < r1) */ + MOV_p(r0, GR_0, PR_6); +} +fopi(uneq) +dopi(uneq) + +static void +_unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LT(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} +fopi(unge) +dopi(unge) + +static void +_ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_LE(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} +fopi(ungt) +dopi(ungt) + +static void +_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + MOV(r0, GR_0); + FCMP_LE(PR_8, PR_9, r1, r2); + FCMP_LE(PR_6, PR_7, r2, r1); + MOVI_p(r0, 1, PR_9); /* !(r1 >= r2) || !(r2 >= r1) */ + MOVI_p(r0, 1, PR_7); +} +fopi(ltgt) +dopi(ltgt) + +static void +_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_UNORD(PR_6, PR_7, r1, r2); + MOV_p(r0, GR_0, PR_6); + MOVI_p(r0, 1, PR_7); +} +fopi(ord) +dopi(ord) + +static void +_unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + FCMP_UNORD(PR_6, PR_7, r1, r2); + MOVI_p(r0, 1, PR_6); + MOV_p(r0, GR_0, PR_7); +} +fopi(unord) +dopi(unord) + +static void +_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_f(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r1, i0); + ldr_f(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldr_d(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r1, i0); + ldr_d(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_f(rn(reg), r0); + jit_unget_reg(reg); +} + +static void +_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r0, r1); + str_f(rn(reg), r2); + jit_unget_reg(reg); +} + +static void +_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_f(rn(reg), r1); + jit_unget_reg(reg); +} + +static void +_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_d(rn(reg), r0); + jit_unget_reg(reg); +} + +static void +_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addr(rn(reg), r0, r1); + str_d(rn(reg), r2); + jit_unget_reg(reg); +} + +static void +_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_d(rn(reg), r1); + jit_unget_reg(reg); +} + +static void +_sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t d; + /* @arg0 = r1 */ + sync(); + d = ((jit_word_t)sqrtf - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(0, d); + else + /* FIXME displacement likely wrong (in either case) */ + BRL_CALL(0, d); + /* r0 = @ret */ +} + +static void +_sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t d; + /* @arg0 = r1 */ + sync(); + d = ((jit_word_t)sqrt - _jit->pc.w) >> 4; + if (d < -16777216 && d > 16777215) + BRI_CALL(0, d); + else + /* FIXME displacement likely wrong (in either case) */ + BRL_CALL(0, d); + /* r0 = @ret */ +} + +static jit_word_t +_bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LT(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} +fbopi(lt) +dbopi(lt) + +static jit_word_t +_bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LE(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} +fbopi(le) +dbopi(le) + +static jit_word_t +_beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_EQ(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} +fbopi(eq) +dbopi(eq) + +static jit_word_t +_bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LE(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} +fbopi(ge) +dbopi(ge) + +static jit_word_t +_bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LT(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} +fbopi(gt) +dbopi(gt) + +static jit_word_t +_bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_EQ(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} +fbopi(ne) +dbopi(ne) + +static jit_word_t +_bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LE(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} +fbopi(unlt) +dbopi(unlt) + +static jit_word_t +_bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LT(PR_6, PR_7, r1, r0); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} +fbopi(unle) +dbopi(unle) + +static jit_word_t +_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + FCMP_UNORD(PR_8, PR_9, r0, r1); + /* junord L1 */ + BRI_COND(2, PR_8); + sync(); + FCMP_EQ(PR_6, PR_7, r0, r1); + /* jne L2 */ + BRI_COND(2, PR_7); + sync(); + w = _jit->pc.w; + /* L1: */ + BRI((i0 - w) >> 4); /* unconditional jump to patch */ + sync(); + /* L2: */ + return (w); +} +fbopi(uneq) +dbopi(uneq) + +static jit_word_t +_bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LT(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} +fbopi(unge) +dbopi(unge) + +static jit_word_t +_bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_LE(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} +fbopi(ungt) +dbopi(ungt) + +static jit_word_t +_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + FCMP_EQ(PR_8, PR_9, r0, r1); + /* jeq L1 */ + BRI_COND(3, PR_8); + sync(); + FCMP_UNORD(PR_6, PR_7, r0, r1); + /* jord L1 */ + BRI_COND(2, PR_7); + sync(); + w = _jit->pc.w; + BRI((i0 - w) >> 4); /* unconditional jump to patch */ + /* L1 */ + sync(); + return (w); +} +fbopi(ltgt) +dbopi(ltgt) + +static jit_word_t +_bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_UNORD(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_7); + return (w); +} +fbopi(ord) +dbopi(ord) + +static jit_word_t +_bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + sync(); + w = _jit->pc.w; + FCMP_UNORD(PR_6, PR_7, r0, r1); + BRI_COND((i0 - w) >> 4, PR_6); + return (w); +} +fbopi(unord) +dbopi(unord) +#endif diff --git a/lib/jit_ia64.c b/lib/jit_ia64.c new file mode 100644 index 000000000..e54b13d1b --- /dev/null +++ b/lib/jit_ia64.c @@ -0,0 +1,1305 @@ +/* + * Copyright (C) 2013 Free Software Foundation, Inc. + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Authors: + * Paulo Cesar Pereira de Andrade + */ + +#include +#include + +#define rc(value) jit_class_##value +#define rn(reg) (jit_regno(_rvs[jit_regno(reg)].spec)) + +#define stack_framesize 16 + +/* + * Prototypes + */ +#define patch(instr, node) _patch(_jit, instr, node) +static void _patch(jit_state_t*,jit_word_t,jit_node_t*); + +#define PROTO 1 +# include "jit_ia64-cpu.c" +# include "jit_ia64-fpu.c" +#undef PROTO + +/* + * Initialization + */ +jit_register_t _rvs[] = { + /* Always 0 */ + { 0, "r0" }, + /* Global Pointer */ + { rc(sav)|1, "r1" }, + /* Used when a register cannot be allocated */ + { 2, "r2" }, + /* First scratch register */ + { rc(gpr)|3, "r3" }, + /* Use r4 as lightning fp register */ + { rc(sav)|4, "r4" }, + /* Do not touch callee save registers not automatically spill/reloaded */ + { rc(sav)|5, "r5" }, { rc(sav)|6, "r6" }, + { rc(sav)|7, "r7" }, + /* Do not touch return register for the sake of simplicity, besides + * having JIT_R0 being the same as JIT_RET usually an optimization */ + { 8, "r8" }, + /* Return registers, use as temporaries */ + { rc(gpr)|9, "r9" }, + { rc(gpr)|10, "r10" }, { rc(gpr)|11, "r11" }, + /* Stack pointer */ + { rc(sav)|12, "r12" }, + /* Thread pointer */ + { rc(sav)|13, "r13" }, + /* (Usually) assembly temporaries */ + { rc(gpr)|31, "r31" }, { rc(gpr)|30, "r30" }, + { rc(gpr)|29, "r29" }, { rc(gpr)|28, "r28" }, + { rc(gpr)|27, "r27" }, { rc(gpr)|26, "r26" }, + { rc(gpr)|25, "r25" }, { rc(gpr)|24, "r24" }, + { rc(gpr)|23, "r23" }, { rc(gpr)|22, "r22" }, + { rc(gpr)|21, "r21" }, { rc(gpr)|20, "r20" }, + { rc(gpr)|19, "r19" }, { rc(gpr)|18, "r18" }, + /* JIT_R4-JIT_R0 */ + { rc(gpr)|17, "r17" }, { rc(gpr)|16, "r16" }, + { rc(gpr)|15, "r15" }, { rc(gpr)|14, "r14" }, + /* Do not allow allocating r32-r41 as temoraries for the sake of + * avoiding the need of extra complexity in the non backend code */ + { rc(arg)|32, "r32" }, { rc(arg)|33, "r33" }, + { rc(arg)|34, "r34" }, { rc(arg)|35, "r35" }, + { rc(arg)|36, "r36" }, { rc(arg)|37, "r37" }, + { rc(arg)|38, "r38" }, { rc(arg)|39, "r39" }, + /* JIT_V0-JIT_V3 */ + { rc(gpr)|40, "r40" }, { rc(gpr)|41, "r41" }, + { rc(gpr)|42, "r42" }, { rc(gpr)|43, "r43" }, + /* Temporaries/locals */ + { rc(gpr)|44, "r44" }, { rc(gpr)|45, "r45" }, + { rc(gpr)|46, "r46" }, { rc(gpr)|47, "r47" }, + { rc(gpr)|48, "r48" }, { rc(gpr)|49, "r49" }, + { rc(gpr)|50, "r50" }, { rc(gpr)|51, "r51" }, + { rc(gpr)|52, "r52" }, { rc(gpr)|53, "r53" }, + { rc(gpr)|54, "r54" }, { rc(gpr)|55, "r55" }, + { rc(gpr)|56, "r56" }, { rc(gpr)|57, "r57" }, + { rc(gpr)|58, "r58" }, { rc(gpr)|59, "r59" }, + { rc(gpr)|60, "r60" }, { rc(gpr)|61, "r61" }, + { rc(gpr)|62, "r62" }, { rc(gpr)|63, "r63" }, + { rc(gpr)|64, "r64" }, { rc(gpr)|65, "r65" }, + { rc(gpr)|66, "r66" }, { rc(gpr)|67, "r67" }, + { rc(gpr)|68, "r68" }, { rc(gpr)|69, "r69" }, + { rc(gpr)|70, "r70" }, { rc(gpr)|71, "r71" }, + { rc(gpr)|72, "r72" }, { rc(gpr)|73, "r73" }, + { rc(gpr)|74, "r74" }, { rc(gpr)|75, "r75" }, + { rc(gpr)|76, "r76" }, { rc(gpr)|77, "r77" }, + { rc(gpr)|78, "r78" }, { rc(gpr)|79, "r79" }, + { rc(gpr)|80, "r80" }, { rc(gpr)|81, "r81" }, + { rc(gpr)|82, "r82" }, { rc(gpr)|83, "r83" }, + { rc(gpr)|84, "r84" }, { rc(gpr)|85, "r85" }, + { rc(gpr)|86, "r86" }, { rc(gpr)|87, "r87" }, + { rc(gpr)|88, "r88" }, { rc(gpr)|89, "r89" }, + { rc(gpr)|90, "r90" }, { rc(gpr)|91, "r91" }, + { rc(gpr)|92, "r92" }, { rc(gpr)|93, "r93" }, + { rc(gpr)|94, "r94" }, { rc(gpr)|95, "r95" }, + { rc(gpr)|96, "r96" }, { rc(gpr)|97, "r97" }, + { rc(gpr)|98, "r98" }, { rc(gpr)|99, "r99" }, + { rc(gpr)|100, "r100"}, { rc(gpr)|101, "r101"}, + { rc(gpr)|102, "r102"}, { rc(gpr)|103, "r103"}, + { rc(gpr)|104, "r104"}, { rc(gpr)|105, "r105"}, + { rc(gpr)|106, "r106"}, { rc(gpr)|107, "r107"}, + { rc(gpr)|108, "r108"}, { rc(gpr)|109, "r109"}, + { rc(gpr)|110, "r110"}, { rc(gpr)|111, "r111"}, + { rc(gpr)|112, "r112"}, { rc(gpr)|113, "r113"}, + { rc(gpr)|114, "r114"}, { rc(gpr)|115, "r115"}, + /* Do not enable these because no matter what, want 12 free registers, + * 4 for prolog and epilog and 8 for outgoing arguments */ + { 116, "r116"}, { 117, "r117"}, + { 118, "r118"}, { 119, "r119"}, + { 120, "r120"}, { 121, "r121"}, + { 122, "r122"}, { 123, "r123"}, + { 124, "r124"}, { 125, "r125"}, + { 126, "r126"}, { 127, "r127"}, + /* Always 0.0 */ + { 0, "f0" }, + /* Always 1.0 */ + { 1, "f1" }, + /* Do not touch callee save registers not automatically spill/reloaded */ + { rc(sav)|2, "f2" }, { rc(sav)|3, "f3" }, + { rc(sav)|4, "f4" }, { rc(sav)|5, "f5" }, + /* Scratch */ + { rc(fpr)|6, "f6" }, { rc(fpr)|7, "f7" }, + /* Do not allocate for the sake of simplification */ + { 8, "f8" }, + /* Scratch - Argument/return registers */ + { rc(fpr)|9, "f9" }, + { rc(fpr)|10, "f10" }, { rc(fpr)|11, "f11" }, + { rc(fpr)|12, "f12" }, { rc(fpr)|13, "f13" }, + { rc(fpr)|14, "f14" }, { rc(fpr)|15, "f15" }, + /* Do not touch callee save registers not automatically spill/reloaded */ + { rc(sav)|16, "f16" }, { rc(sav)|17, "f17" }, + { rc(sav)|18, "f18" }, { rc(sav)|19, "f19" }, + { rc(sav)|20, "f20" }, { rc(sav)|21, "f21" }, + { rc(sav)|22, "f22" }, { rc(sav)|23, "f23" }, + { rc(sav)|24, "f24" }, { rc(sav)|25, "f25" }, + { rc(sav)|26, "f26" }, { rc(sav)|27, "f27" }, + { rc(sav)|28, "f28" }, { rc(sav)|29, "f29" }, + { rc(sav)|30, "f30" }, { rc(sav)|31, "f31" }, + /* Scratch */ + { rc(fpr)|32, "f32" }, { rc(fpr)|33, "f33" }, + { rc(fpr)|34, "f34" }, { rc(fpr)|35, "f35" }, + { rc(fpr)|36, "f36" }, { rc(fpr)|37, "f37" }, + { rc(fpr)|38, "f38" }, { rc(fpr)|39, "f39" }, + { rc(fpr)|40, "f40" }, { rc(fpr)|41, "f41" }, + { rc(fpr)|42, "f42" }, { rc(fpr)|43, "f43" }, + { rc(fpr)|44, "f44" }, { rc(fpr)|45, "f45" }, + { rc(fpr)|46, "f46" }, { rc(fpr)|47, "f47" }, + { rc(fpr)|48, "f48" }, { rc(fpr)|49, "f49" }, + { rc(fpr)|50, "f50" }, { rc(fpr)|51, "f51" }, + { rc(fpr)|52, "f52" }, { rc(fpr)|53, "f53" }, + { rc(fpr)|54, "f54" }, { rc(fpr)|55, "f55" }, + { rc(fpr)|56, "f56" }, { rc(fpr)|57, "f57" }, + { rc(fpr)|58, "f58" }, { rc(fpr)|59, "f59" }, + { rc(fpr)|60, "f60" }, { rc(fpr)|61, "f61" }, + { rc(fpr)|62, "f62" }, { rc(fpr)|63, "f63" }, + { rc(fpr)|64, "f64" }, { rc(fpr)|65, "f65" }, + { rc(fpr)|66, "f66" }, { rc(fpr)|67, "f67" }, + { rc(fpr)|68, "f68" }, { rc(fpr)|69, "f69" }, + { rc(fpr)|70, "f70" }, { rc(fpr)|71, "f71" }, + { rc(fpr)|72, "f72" }, { rc(fpr)|73, "f73" }, + { rc(fpr)|74, "f74" }, { rc(fpr)|75, "f75" }, + { rc(fpr)|76, "f76" }, { rc(fpr)|77, "f77" }, + { rc(fpr)|78, "f78" }, { rc(fpr)|79, "f79" }, + { rc(fpr)|80, "f80" }, { rc(fpr)|81, "f81" }, + { rc(fpr)|82, "f82" }, { rc(fpr)|83, "f83" }, + { rc(fpr)|84, "f84" }, { rc(fpr)|85, "f85" }, + { rc(fpr)|86, "f86" }, { rc(fpr)|87, "f87" }, + { rc(fpr)|88, "f88" }, { rc(fpr)|89, "f89" }, + { rc(fpr)|90, "f90" }, { rc(fpr)|91, "f91" }, + { rc(fpr)|92, "f92" }, { rc(fpr)|93, "f93" }, + { rc(fpr)|94, "f94" }, { rc(fpr)|95, "f95" }, + { rc(fpr)|96, "f96" }, { rc(fpr)|97, "f97" }, + { rc(fpr)|98, "f98" }, { rc(fpr)|99, "f99" }, + { rc(fpr)|100, "f100"}, { rc(fpr)|101, "f101"}, + { rc(fpr)|102, "f102"}, { rc(fpr)|103, "f103"}, + { rc(fpr)|104, "f104"}, { rc(fpr)|105, "f105"}, + { rc(fpr)|106, "f106"}, { rc(fpr)|107, "f107"}, + { rc(fpr)|108, "f108"}, { rc(fpr)|109, "f109"}, + { rc(fpr)|110, "f110"}, { rc(fpr)|111, "f111"}, + { rc(fpr)|112, "f112"}, { rc(fpr)|113, "f113"}, + { rc(fpr)|114, "f114"}, { rc(fpr)|115, "f115"}, + { rc(fpr)|116, "f116"}, { rc(fpr)|117, "f117"}, + { rc(fpr)|118, "f118"}, { rc(fpr)|119, "f119"}, +#if 0 + { rc(fpr)|120, "f120"}, { rc(fpr)|121, "f121"}, + { rc(fpr)|122, "f122"}, { rc(fpr)|123, "f123"}, + { rc(fpr)|124, "f124"}, { rc(fpr)|125, "f125"}, + { rc(fpr)|126, "f126"}, { rc(fpr)|127, "f127"}, +#endif + /* Fake registers to patch in movr and movi arguments */ + { rc(arg)|120, "o0" }, { rc(arg)|121, "o1" }, + { rc(arg)|122, "o2" }, { rc(arg)|123, "o3" }, + { rc(arg)|124, "o4" }, { rc(arg)|125, "o5" }, + { rc(arg)|126, "o6" }, { rc(arg)|127, "o7" }, + { _NOREG, "" }, +}; +int missing_count; + +/* + * Implementation + */ +void +jit_get_cpu(void) +{ +} + +void +_jit_init(jit_state_t *_jit) +{ + _jitc->reglen = jit_size(_rvs) - 1; + jit_regset_new(&_jitc->gprs); + jit_regset_new(&_jitc->fprs); + jit_carry = _NOREG; +} + +void +_jit_prolog(jit_state_t *_jit) +{ + jit_int32_t offset; + + if (_jitc->function) + jit_epilog(); + assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); + jit_regset_set_ui(&_jitc->regsav, 0); + offset = _jitc->functions.offset; + if (offset >= _jitc->functions.length) { + jit_realloc((jit_pointer_t *)&_jitc->functions.ptr, + _jitc->functions.length * sizeof(jit_function_t), + (_jitc->functions.length + 16) * sizeof(jit_function_t)); + _jitc->functions.length += 16; + } + _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++; + _jitc->function->self.size = stack_framesize; + _jitc->function->self.argi = _jitc->function->self.argf = + _jitc->function->self.aoff = _jitc->function->self.alen = + _jitc->function->self.aoff = 0; + _jitc->function->self.call = jit_call_default; + jit_alloc((jit_pointer_t *)&_jitc->function->regoff, + _jitc->reglen * sizeof(jit_int32_t)); + + _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog); + jit_link(_jitc->function->prolog); + _jitc->function->prolog->w.w = offset; + _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog); + /* u: label value + * v: offset in blocks vector + * w: offset in functions vector + */ + _jitc->function->epilog->w.w = offset; + + jit_regset_new(&_jitc->function->regset); +} + +jit_int32_t +_jit_allocai(jit_state_t *_jit, jit_int32_t length) +{ + assert(_jitc->function); + switch (length) { + case 0: case 1: break; + case 2: _jitc->function->self.aoff &= -2; break; + case 3: case 4: _jitc->function->self.aoff &= -4; break; + default: _jitc->function->self.aoff &= -8; break; + } + _jitc->function->self.aoff -= length; + return (_jitc->function->self.aoff); +} + +void +_jit_ret(jit_state_t *_jit) +{ + jit_node_t *instr; + + assert(_jitc->function); + + /* jump to epilog */ + instr = jit_jmpi(); + jit_patch_at(instr, _jitc->function->epilog); +} + +void +_jit_retr(jit_state_t *_jit, jit_int32_t u) +{ + jit_movr(JIT_RET, u); + jit_ret(); +} + +void +_jit_reti(jit_state_t *_jit, jit_word_t u) +{ + jit_movi(JIT_RET, u); + jit_ret(); +} + +void +_jit_retr_f(jit_state_t *_jit, jit_int32_t u) +{ + jit_movr_f(JIT_FRET, u); + jit_ret(); +} + +void +_jit_reti_f(jit_state_t *_jit, jit_float32_t u) +{ + jit_movi_f(JIT_FRET, u); + jit_ret(); +} + +void +_jit_retr_d(jit_state_t *_jit, jit_int32_t u) +{ + jit_movr_d(JIT_FRET, u); + jit_ret(); +} + +void +_jit_reti_d(jit_state_t *_jit, jit_float64_t u) +{ + jit_movi_d(JIT_FRET, u); + jit_ret(); +} + +void +_jit_epilog(jit_state_t *_jit) +{ + assert(_jitc->function); + assert(_jitc->function->epilog->next == NULL); + jit_link(_jitc->function->epilog); + _jitc->function = NULL; +} + +jit_node_t * +_jit_arg(jit_state_t *_jit) +{ + jit_int32_t offset; + + assert(_jitc->function); + if (_jitc->function->self.argi < 8) + offset = _jitc->function->self.argi++; + else { + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); + } + return (jit_new_node_w(jit_code_arg, offset)); +} + +jit_bool_t +_jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset) +{ + return (offset >= 0 && offset < 8); +} + +jit_node_t * +_jit_arg_f(jit_state_t *_jit) +{ + jit_int32_t offset; + + assert(_jitc->function); + if (_jitc->function->self.argi < 8) + offset = _jitc->function->self.argi++; + else { + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); + } + return (jit_new_node_w(jit_code_arg_f, offset)); +} + +jit_node_t * +_jit_arg_d(jit_state_t *_jit) +{ + jit_int32_t offset; + + assert(_jitc->function); + if (_jitc->function->self.argi < 8) + offset = _jitc->function->self.argi++; + else { + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); + } + return (jit_new_node_w(jit_code_arg_d, offset)); +} + +void +_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_extr_c(u, _R32 + v->u.w); + else + jit_ldxi_c(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_extr_uc(u, _R32 + v->u.w); + else + jit_ldxi_uc(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_extr_s(u, _R32 + v->u.w); + else + jit_ldxi_s(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_extr_us(u, _R32 + v->u.w); + else + jit_ldxi_us(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_extr_i(u, _R32 + v->u.w); + else + jit_ldxi_i(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_extr_ui(u, _R32 + v->u.w); + else + jit_ldxi_ui(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w < 8) + jit_movr(u, _R32 + v->u.w); + else + jit_ldxi(u, JIT_FP, v->u.w); +} + +void +_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ +/* + if (v->u.w < 8) + jit_movr_f(u, _R32 + v->u.w); + else + jit_ldxi_f(u, JIT_FP, v->u.w); +*/ +} + +void +_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ +/* + if (v->u.w < 8) + jit_movr_d(u, _R32 + v->u.w); + else + jit_ldxi_d(u, JIT_FP, v->u.w); +*/ +} + +void +_jit_pushargr(jit_state_t *_jit, jit_int32_t u) +{ + assert(_jitc->function); + if (_jitc->function->call.argi < 8) { + jit_movr(_OUT0 + _jitc->function->call.argi, u); + ++_jitc->function->call.argi; + } + else { + jit_stxi(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_word_t); + } +} + +void +_jit_pushargi(jit_state_t *_jit, jit_word_t u) +{ + jit_int32_t regno; + assert(_jitc->function); + if (_jitc->function->call.argi < 8) { + jit_movi(_OUT0 + _jitc->function->call.argi, u); + ++_jitc->function->call.argi; + } + else { + regno = jit_get_reg(jit_class_gpr); + jit_movi(regno, u); + jit_stxi(_jitc->function->call.size, JIT_SP, regno); + _jitc->function->call.size += sizeof(jit_word_t); + jit_unget_reg(regno); + } +} + +void +_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) +{ + assert(_jitc->function); +} + +void +_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) +{ + jit_int32_t regno; + assert(_jitc->function); + /* FIXME move to OUTn or stack */ + regno = jit_get_reg(jit_class_fpr); + jit_movi_f(regno, u); + jit_unget_reg(regno); +} + +void +_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) +{ + assert(_jitc->function); +} + +void +_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) +{ + jit_int32_t regno; + assert(_jitc->function); + /* FIXME move to OUTn or stack */ + regno = jit_get_reg(jit_class_fpr); + jit_movi_d(regno, u); + jit_unget_reg(regno); +} + +jit_bool_t +_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno) +{ + /* Argument registers are allocated from the pool of unused registers */ + return (0); +} + +void +_jit_finishr(jit_state_t *_jit, jit_int32_t r0) +{ + jit_node_t *call; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; + call = jit_callr(r0); + call->v.w = _jitc->function->call.argi; + call->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; +} + +jit_node_t * +_jit_finishi(jit_state_t *_jit, jit_pointer_t i0) +{ + jit_node_t *node; + node = jit_calli(i0); + node->v.w = _jitc->function->call.argi; + node->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; + return (node); +} + +void +_jit_retval_c(jit_state_t *_jit, jit_int32_t r0) +{ + jit_extr_c(r0, JIT_RET); +} + +void +_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0) +{ + jit_extr_uc(r0, JIT_RET); +} + +void +_jit_retval_s(jit_state_t *_jit, jit_int32_t r0) +{ + jit_extr_s(r0, JIT_RET); +} + +void +_jit_retval_us(jit_state_t *_jit, jit_int32_t r0) +{ + jit_extr_us(r0, JIT_RET); +} + +void +_jit_retval_i(jit_state_t *_jit, jit_int32_t r0) +{ + jit_extr_i(r0, JIT_RET); +} + +void +_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0) +{ + jit_extr_ui(r0, JIT_RET); +} + +void +_jit_retval_l(jit_state_t *_jit, jit_int32_t r0) +{ + jit_movr(r0, JIT_RET); +} + +void +_jit_retval_f(jit_state_t *_jit, jit_int32_t r0) +{ + jit_movr_f(r0, JIT_FRET); +} + +void +_jit_retval_d(jit_state_t *_jit, jit_int32_t r0) +{ + jit_movr_d(r0, JIT_FRET); +} + +jit_pointer_t +_emit_code(jit_state_t *_jit) +{ + jit_node_t *node; + jit_node_t *temp; + jit_word_t word; + jit_int32_t value; + jit_int32_t offset; + struct { + jit_node_t *node; + jit_word_t word; + jit_int32_t patch_offset; + jit_word_t prolog_offset; + } undo; + + _jitc->function = NULL; + + jit_reglive_setup(); + + undo.word = 0; + undo.node = NULL; + undo.patch_offset = 0; + + undo.prolog_offset = 0; + /* code may start with a jump so add an initial function descriptor */ + il(_jit->pc.w + 16); /* addr */ + il(0); /* gp */ +#define case_rr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.w)); \ + break +#define case_rw(name, type) \ + case jit_code_##name##i##type: \ + name##i##type(rn(node->u.w), node->v.w); \ + break +#define case_wr(name, type) \ + case jit_code_##name##i##type: \ + name##i##type(node->u.w, rn(node->v.w)); \ + break +#define case_rrr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), \ + rn(node->v.w), rn(node->w.w)); \ + break +#define case_rrrr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ + rn(node->v.w), rn(node->w.w)); \ + break +#define case_rrw(name, type) \ + case jit_code_##name##i##type: \ + name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ + break +#define case_rrrw(name, type) \ + case jit_code_##name##i##type: \ + name##i##type(rn(node->u.q.l), rn(node->u.q.h), \ + rn(node->v.w), node->w.w); \ + break +#define case_rrf(name, type, size) \ + case jit_code_##name##i##type: \ + assert(node->flag & jit_flag_data); \ + name##i##type(rn(node->u.w), rn(node->v.w), \ + (jit_float##size##_t *)node->w.n->u.w); \ + break +#define case_wrr(name, type) \ + case jit_code_##name##i##type: \ + name##i##type(node->u.w, rn(node->v.w), rn(node->w.w)); \ + break +#define case_brr(name, type) \ + case jit_code_##name##r##type: \ + temp = node->u.n; \ + assert(temp->code == jit_code_label || \ + temp->code == jit_code_epilog); \ + if (temp->flag & jit_flag_patch) \ + name##r##type(temp->u.w, rn(node->v.w), \ + rn(node->w.w)); \ + else { \ + word = name##r##type(_jit->pc.w, \ + rn(node->v.w), rn(node->w.w)); \ + patch(word, node); \ + } \ + break +#define case_brw(name, type) \ + case jit_code_##name##i##type: \ + temp = node->u.n; \ + assert(temp->code == jit_code_label || \ + temp->code == jit_code_epilog); \ + if (temp->flag & jit_flag_patch) \ + name##i##type(temp->u.w, \ + rn(node->v.w), node->w.w); \ + else { \ + word = name##i##type(_jit->pc.w, \ + rn(node->v.w), node->w.w); \ + patch(word, node); \ + } \ + break +#define case_brf(name, type, size) \ + case jit_code_##name##i##type: \ + temp = node->u.n; \ + assert(temp->code == jit_code_label || \ + temp->code == jit_code_epilog); \ + if (temp->flag & jit_flag_patch) \ + name##i##type(temp->u.w, rn(node->v.w), \ + (jit_float##size##_t *)node->w.n->u.w); \ + else { \ + word = name##i##type(_jit->pc.w, rn(node->v.w), \ + (jit_float##size##_t *)node->w.n->u.w); \ + patch(word, node); \ + } \ + break + for (node = _jitc->head; node; node = node->next) { + if (_jit->pc.uc >= _jitc->code.end && !jit_remap()) + return (NULL); + + value = jit_classify(node->code); + jit_regarg_set(node, value); + switch (node->code) { + case jit_code_note: case jit_code_name: + sync(); + node->u.w = _jit->pc.w; + break; + case jit_code_label: + sync(); + /* remember label is defined */ + node->flag |= jit_flag_patch; + node->u.w = _jit->pc.w; + break; + case_rrr(add,); + case_rrw(add,); + case_rrr(addc,); + case_rrw(addc,); + case_rrr(addx,); + case_rrw(addx,); + case_rrr(sub,); + case_rrw(sub,); + case_rrr(subx,); + case_rrw(subx,); + case_rrr(subc,); + case_rrw(subc,); + case_rrr(mul,); + case_rrw(mul,); + case_rrrr(qmul,); + case_rrrw(qmul,); + case_rrrr(qmul, _u); + case_rrrw(qmul, _u); + case_rrr(div,); + case_rrw(div,); + case_rrr(div, _u); + case_rrw(div, _u); + case_rrr(rem,); + case_rrw(rem,); + case_rrr(rem, _u); + case_rrw(rem, _u); + case_rrrr(qdiv,); + case_rrrw(qdiv,); + case_rrrr(qdiv, _u); + case_rrrw(qdiv, _u); + case_rrr(and,); + case_rrw(and,); + case_rrr(or,); + case_rrw(or,); + case_rrr(xor,); + case_rrw(xor,); + case_rrr(lsh,); + case_rrw(lsh,); + case_rrr(rsh,); + case_rrw(rsh,); + case_rrr(rsh, _u); + case_rrw(rsh, _u); + case_rr(neg,); + case_rr(com,); + case_rr(mov,); + case jit_code_movi: + if (node->flag & jit_flag_node) { + temp = node->v.n; + if (temp->code == jit_code_data || + (temp->code == jit_code_label && + (temp->flag & jit_flag_patch))) + movi(rn(node->u.w), temp->u.w); + else { + assert(temp->code == jit_code_label || + temp->code == jit_code_epilog); + word = movi_p(rn(node->u.w), node->v.w); + patch(word, node); + } + } + else + movi(rn(node->u.w), node->v.w); + break; + case_rr(hton,); + case_rr(ext, _c); + case_rr(ext, _uc); + case_rr(ext, _s); + case_rr(ext, _us); + case_rr(ext, _i); + case_rr(ext, _ui); + case_rr(trunc, _f_i); + case_rr(trunc, _d_i); + case_rr(trunc, _f_l); + case_rr(trunc, _d_l); + case_rrr(lt,); + case_rrw(lt,); + case_rrr(lt, _u); + case_rrw(lt, _u); + case_rrr(le,); + case_rrw(le,); + case_rrr(le, _u); + case_rrw(le, _u); + case_rrr(eq,); + case_rrw(eq,); + case_rrr(ge,); + case_rrw(ge,); + case_rrr(ge, _u); + case_rrw(ge, _u); + case_rrr(gt,); + case_rrw(gt,); + case_rrr(gt, _u); + case_rrw(gt, _u); + case_rrr(ne,); + case_rrw(ne,); + case_rr(ld, _c); + case_rw(ld, _c); + case_rr(ld, _uc); + case_rw(ld, _uc); + case_rr(ld, _s); + case_rw(ld, _s); + case_rr(ld, _us); + case_rw(ld, _us); + case_rr(ld, _i); + case_rw(ld, _i); + case_rr(ld, _ui); + case_rw(ld, _ui); + case_rr(ld, _l); + case_rw(ld, _l); + case_rrr(ldx, _c); + case_rrw(ldx, _c); + case_rrr(ldx, _uc); + case_rrw(ldx, _uc); + case_rrr(ldx, _s); + case_rrw(ldx, _s); + case_rrr(ldx, _us); + case_rrw(ldx, _us); + case_rrr(ldx, _i); + case_rrw(ldx, _i); + case_rrr(ldx, _ui); + case_rrw(ldx, _ui); + case_rrr(ldx, _l); + case_rrw(ldx, _l); + case_rr(st, _c); + case_wr(st, _c); + case_rr(st, _s); + case_wr(st, _s); + case_rr(st, _i); + case_wr(st, _i); + case_rr(st, _l); + case_wr(st, _l); + case_rrr(stx, _c); + case_wrr(stx, _c); + case_rrr(stx, _s); + case_wrr(stx, _s); + case_rrr(stx, _i); + case_wrr(stx, _i); + case_rrr(stx, _l); + case_wrr(stx, _l); + case_brr(blt,); + case_brw(blt,); + case_brr(blt, _u); + case_brw(blt, _u); + case_brr(ble,); + case_brw(ble,); + case_brr(ble, _u); + case_brw(ble, _u); + case_brr(beq,); + case_brw(beq,); + case_brr(bge,); + case_brw(bge,); + case_brr(bge, _u); + case_brw(bge, _u); + case_brr(bgt,); + case_brw(bgt,); + case_brr(bgt, _u); + case_brw(bgt, _u); + case_brr(bne,); + case_brw(bne,); + case_brr(bms,); + case_brw(bms,); + case_brr(bmc,); + case_brw(bmc,); + case_brr(boadd,); + case_brw(boadd,); + case_brr(boadd, _u); + case_brw(boadd, _u); + case_brr(bxadd,); + case_brw(bxadd,); + case_brr(bxadd, _u); + case_brw(bxadd, _u); + case_brr(bosub,); + case_brw(bosub,); + case_brr(bosub, _u); + case_brw(bosub, _u); + case_brr(bxsub,); + case_brw(bxsub,); + case_brr(bxsub, _u); + case_brw(bxsub, _u); + case_rrr(add, _f); + case_rrf(add, _f, 32); + case_rrr(sub, _f); + case_rrf(sub, _f, 32); + case_rrr(mul, _f); + case_rrf(mul, _f, 32); + case_rrr(div, _f); + case_rrf(div, _f, 32); + case_rr(ext, _f); + case_rr(abs, _f); + case_rr(neg, _f); + case_rr(sqrt, _f); + case_rr(ld, _f); + case_rw(ld, _f); + case_rrr(ldx, _f); + case_rrw(ldx, _f); + case_rr(st, _f); + case_wr(st, _f); + case_rrr(stx, _f); + case_wrr(stx, _f); + case_rr(mov, _f); + case jit_code_movi_f: + assert(node->flag & jit_flag_data); + movi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w); + break; + case_rr(ext, _d_f); + case_rrr(lt, _f); + case_rrf(lt, _f, 32); + case_rrr(le, _f); + case_rrf(le, _f, 32); + case_rrr(eq, _f); + case_rrf(eq, _f, 32); + case_rrr(ge, _f); + case_rrf(ge, _f, 32); + case_rrr(gt, _f); + case_rrf(gt, _f, 32); + case_rrr(ne, _f); + case_rrf(ne, _f, 32); + case_rrr(unlt, _f); + case_rrf(unlt, _f, 32); + case_rrr(unle, _f); + case_rrf(unle, _f, 32); + case_rrr(uneq, _f); + case_rrf(uneq, _f, 32); + case_rrr(unge, _f); + case_rrf(unge, _f, 32); + case_rrr(ungt, _f); + case_rrf(ungt, _f, 32); + case_rrr(ltgt, _f); + case_rrf(ltgt, _f, 32); + case_rrr(ord, _f); + case_rrf(ord, _f, 32); + case_rrr(unord, _f); + case_rrf(unord, _f, 32); + case_brr(blt, _f); + case_brf(blt, _f, 32); + case_brr(ble, _f); + case_brf(ble, _f, 32); + case_brr(beq, _f); + case_brf(beq, _f, 32); + case_brr(bge, _f); + case_brf(bge, _f, 32); + case_brr(bgt, _f); + case_brf(bgt, _f, 32); + case_brr(bne, _f); + case_brf(bne, _f, 32); + case_brr(bunlt, _f); + case_brf(bunlt, _f, 32); + case_brr(bunle, _f); + case_brf(bunle, _f, 32); + case_brr(buneq, _f); + case_brf(buneq, _f, 32); + case_brr(bunge, _f); + case_brf(bunge, _f, 32); + case_brr(bungt, _f); + case_brf(bungt, _f, 32); + case_brr(bltgt, _f); + case_brf(bltgt, _f, 32); + case_brr(bord, _f); + case_brf(bord, _f, 32); + case_brr(bunord, _f); + case_brf(bunord, _f, 32); + case_rrr(add, _d); + case_rrf(add, _d, 64); + case_rrr(sub, _d); + case_rrf(sub, _d, 64); + case_rrr(mul, _d); + case_rrf(mul, _d, 64); + case_rrr(div, _d); + case_rrf(div, _d, 64); + case_rr(ext, _d); + case_rr(abs, _d); + case_rr(neg, _d); + case_rr(sqrt, _d); + case_rr(ld, _d); + case_rw(ld, _d); + case_rrr(ldx, _d); + case_rrw(ldx, _d); + case_rr(st, _d); + case_wr(st, _d); + case_rrr(stx, _d); + case_wrr(stx, _d); + case_rr(mov, _d); + case jit_code_movi_d: + assert(node->flag & jit_flag_data); + movi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w); + break; + case_rr(ext, _f_d); + case_rrr(lt, _d); + case_rrf(lt, _d, 64); + case_rrr(le, _d); + case_rrf(le, _d, 64); + case_rrr(eq, _d); + case_rrf(eq, _d, 64); + case_rrr(ge, _d); + case_rrf(ge, _d, 64); + case_rrr(gt, _d); + case_rrf(gt, _d, 64); + case_rrr(ne, _d); + case_rrf(ne, _d, 64); + case_rrr(unlt, _d); + case_rrf(unlt, _d, 64); + case_rrr(unle, _d); + case_rrf(unle, _d, 64); + case_rrr(uneq, _d); + case_rrf(uneq, _d, 64); + case_rrr(unge, _d); + case_rrf(unge, _d, 64); + case_rrr(ungt, _d); + case_rrf(ungt, _d, 64); + case_rrr(ltgt, _d); + case_rrf(ltgt, _d, 64); + case_rrr(ord, _d); + case_rrf(ord, _d, 64); + case_rrr(unord, _d); + case_rrf(unord, _d, 64); + case_brr(blt, _d); + case_brf(blt, _d, 64); + case_brr(ble, _d); + case_brf(ble, _d, 64); + case_brr(beq, _d); + case_brf(beq, _d, 64); + case_brr(bge, _d); + case_brf(bge, _d, 64); + case_brr(bgt, _d); + case_brf(bgt, _d, 64); + case_brr(bne, _d); + case_brf(bne, _d, 64); + case_brr(bunlt, _d); + case_brf(bunlt, _d, 64); + case_brr(bunle, _d); + case_brf(bunle, _d, 64); + case_brr(buneq, _d); + case_brf(buneq, _d, 64); + case_brr(bunge, _d); + case_brf(bunge, _d, 64); + case_brr(bungt, _d); + case_brf(bungt, _d, 64); + case_brr(bltgt, _d); + case_brf(bltgt, _d, 64); + case_brr(bord, _d); + case_brf(bord, _d, 64); + case_brr(bunord, _d); + case_brf(bunord, _d, 64); + case jit_code_jmpr: + jmpr(rn(node->u.w)); + break; + case jit_code_jmpi: + if (_jit->pc.uc == _jit->code.ptr + 16) + _jitc->jump = 1; + temp = node->u.n; + assert(temp->code == jit_code_label || + temp->code == jit_code_epilog); + if (temp->flag & jit_flag_patch) + jmpi(temp->u.w); + else { + word = jmpi_p(_jit->pc.w); + patch(word, node); + } + break; + case jit_code_callr: + callr(rn(node->u.w)); + break; + case jit_code_calli: + if (node->flag & jit_flag_node) { + temp = node->u.n; + assert(temp->code == jit_code_label || + temp->code == jit_code_epilog); + word = calli_p(temp->u.w); + if (!(temp->flag & jit_flag_patch)) + patch(word, node); + } + else + calli(node->u.w); + break; + case jit_code_prolog: + jit_regset_set_ui(&_jitc->gprs, 0); + jit_regset_set_ui(&_jitc->fprs, 0); + sync(); + _jitc->function = _jitc->functions.ptr + node->w.w; + undo.node = node; + undo.word = _jit->pc.w; + undo.patch_offset = _jitc->patches.offset; + undo.prolog_offset = _jitc->prolog.offset; + restart_function: + _jitc->again = 0; + if (_jitc->jump) { + /* remember prolog to hide offset adjustment for a jump + * to the start of a function, what is expected to be + * a common practice as first jit instruction */ + if (_jitc->prolog.offset >= _jitc->prolog.length) { + _jitc->prolog.length += 16; + jit_realloc((jit_pointer_t *)&_jitc->prolog.ptr, + (_jitc->prolog.length - 16) * + sizeof(jit_word_t), + _jitc->prolog.length * sizeof(jit_word_t)); + } + _jitc->prolog.ptr[_jitc->prolog.offset++] = _jit->pc.w; + /* function descriptor */ + il(_jit->pc.w + 16); /* addr */ + il(0); /* gp */ + } + prolog(node); + break; + case jit_code_epilog: + assert(_jitc->function == _jitc->functions.ptr + node->w.w); + if (_jitc->again) { + for (temp = undo.node->next; + temp != node; temp = temp->next) { + if (temp->code == jit_code_label || + temp->code == jit_code_epilog) + temp->flag &= ~jit_flag_patch; + } + temp->flag &= ~jit_flag_patch; + node = undo.node; + _jit->pc.w = undo.word; + _jitc->patches.offset = undo.patch_offset; + _jitc->prolog.offset = undo.prolog_offset; + _jitc->ioff = 0; + jit_regset_set_ui(&_jitc->gprs, 0); + jit_regset_set_ui(&_jitc->fprs, 0); + goto restart_function; + } + /* remember label is defined */ + sync(); + node->flag |= jit_flag_patch; + node->u.w = _jit->pc.w; + epilog(node); + jit_regset_set_ui(&_jitc->gprs, 0); + jit_regset_set_ui(&_jitc->fprs, 0); + _jitc->function = NULL; + break; + case jit_code_live: + case jit_code_arg: + case jit_code_arg_f: case jit_code_arg_d: + break; + default: + abort(); + } + if (jit_carry != _NOREG) { + switch (node->code) { + case jit_code_note: + case jit_code_addcr: case jit_code_addci: + case jit_code_addxr: case jit_code_addxi: + case jit_code_subcr: case jit_code_subci: + case jit_code_subxr: case jit_code_subxi: + break; + default: + jit_unget_reg(jit_carry); + jit_carry = _NOREG; + break; + } + } + jit_regarg_clr(node, value); + /* update register live state */ + jit_reglive(node); + } + sync(); +#undef case_brf +#undef case_brw +#undef case_brr +#undef case_wrr +#undef case_rrrw +#undef case_rrf +#undef case_rrw +#undef case_rrrr +#undef case_rrr +#undef case_wr +#undef case_rw +#undef case_rr + + for (offset = 0; offset < _jitc->patches.offset; offset++) { + node = _jitc->patches.ptr[offset].node; + word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w; + patch_at(node, _jitc->patches.ptr[offset].inst, word); + } + + word = sysconf(_SC_PAGE_SIZE); + __clear_cache(_jit->code.ptr, (void *)((_jit->pc.w + word) & -word)); + + return (_jit->code.ptr); +} + +#define CODE 1 +# include "jit_ia64-cpu.c" +# include "jit_ia64-fpu.c" +#undef CODE + +/* Use r2 that is reserved to not require a jit_get_reg call, also note + * that addil needs a register that first in 2 bits, so, if using a + * register other than r2 must be less than r8 (or check for a smaller + * immediate, i.e. i0 >= -8192 && i0 <= 8191) */ +void +_emit_ldxi(jit_state_t *_jit, jit_gpr_t r0, jit_gpr_t r1, jit_word_t i0) +{ + assert(i0 >= -2097152 && i0 < 2097151); + addi(GR_2, rn(r1), i0); + ldr(rn(r0), GR_2); +} + +void +_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_gpr_t r1) +{ + assert(i0 >= -2097152 && i0 < 2097151); + addi(GR_2, rn(r0), i0); + str(GR_2, rn(r1)); +} + +void +_emit_ldxi_d(jit_state_t *_jit, jit_fpr_t r0, jit_gpr_t r1, jit_word_t i0) +{ + assert(i0 >= -2097152 && i0 < 2097151); + addi(GR_2, rn(r1), i0); + ldr_d(rn(r0), GR_2); +} + +void +_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_fpr_t r1) +{ + assert(i0 >= -2097152 && i0 < 2097151); + addi(GR_2, rn(r0), i0); + str_d(GR_2, rn(r1)); +} + +static void +_patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node) +{ + jit_int32_t flag; + + assert(node->flag & jit_flag_node); + if (node->code == jit_code_movi) + flag = node->v.n->flag; + else + flag = node->u.n->flag; + assert(!(flag & jit_flag_patch)); + if (_jitc->patches.offset >= _jitc->patches.length) { + jit_realloc((jit_pointer_t *)&_jitc->patches.ptr, + _jitc->patches.length * sizeof(jit_patch_t), + (_jitc->patches.length + 1024) * sizeof(jit_patch_t)); + _jitc->patches.length += 1024; + } + _jitc->patches.ptr[_jitc->patches.offset].inst = instr; + _jitc->patches.ptr[_jitc->patches.offset].node = node; + ++_jitc->patches.offset; +} diff --git a/lib/jit_mips-cpu.c b/lib/jit_mips-cpu.c index 25c1a7f8e..b804f5056 100644 --- a/lib/jit_mips-cpu.c +++ b/lib/jit_mips-cpu.c @@ -2578,7 +2578,7 @@ _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) SUBU(rn(t1), r0, r1); /* t1 = r0 - r1 */ SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */ SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */ - MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */ + MOVZ(rn(t1), rn(t2), rn(t0)); /* if (t0 == 0) t1 = t2 */ w = _jit->pc.w; BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1); /* delay slot */ diff --git a/lib/jit_mips.c b/lib/jit_mips.c index 952c1ba74..881bef439 100644 --- a/lib/jit_mips.c +++ b/lib/jit_mips.c @@ -90,14 +90,6 @@ jit_register_t _rvs[] = { { _NOREG, "" }, }; -/* Could also: - * o reserve a register for carry (overkill) - * o use MTLO/MFLO (performance hit) - * So, keep a register allocated after setting carry, and implicitly - * deallocate it if it can no longer be tracked - */ -static jit_int32_t jit_carry; - /* * Implementation */ @@ -110,6 +102,12 @@ void _jit_init(jit_state_t *_jit) { _jitc->reglen = jit_size(_rvs) - 1; +/* Could also: + * o reserve a register for carry (overkill) + * o use MTLO/MFLO (performance hit) + * So, keep a register allocated after setting carry, and implicitly + * deallocate it if it can no longer be tracked + */ jit_carry = _NOREG; } diff --git a/lib/lightning.c b/lib/lightning.c index 79327dee7..2c9b7899a 100644 --- a/lib/lightning.c +++ b/lib/lightning.c @@ -224,7 +224,15 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) jit_allocai(sizeof(jit_word_t)); _jitc->again = 1; } +#if DEBUG + /* emit_stxi must not need temporary registers */ + assert(!_jitc->getreg); + _jitc->getreg = 1; +#endif emit_stxi(_jitc->function->regoff[regno], JIT_FP, regno); +#if DEBUG + _jitc->getreg = 0; +#endif } else { if (!_jitc->function->regoff[regno]) { @@ -232,7 +240,15 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) jit_allocai(sizeof(jit_float64_t)); _jitc->again = 1; } +#if DEBUG + /* emit_stxi must not need temporary registers */ + assert(!_jitc->getreg); + _jitc->getreg = 1; +#endif emit_stxi_d(_jitc->function->regoff[regno], JIT_FP, regno); +#if DEBUG + _jitc->getreg = 0; +#endif } jit_regset_setbit(&_jitc->regsav, regno); regarg: @@ -277,10 +293,19 @@ _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno) regno = jit_regno(regno); if (jit_regset_tstbit(&_jitc->regsav, regno)) { if (_jitc->emit) { +#if DEBUG + /* emit_ldxi must not need a temporary register */ + assert(!_jitc->getreg); + _jitc->getreg = 1; +#endif if (jit_class(_rvs[regno].spec) & jit_class_gpr) emit_ldxi(regno, JIT_FP, _jitc->function->regoff[regno]); else emit_ldxi_d(regno, JIT_FP, _jitc->function->regoff[regno]); +#if DEBUG + /* emit_ldxi must not need a temporary register */ + _jitc->getreg = 0; +#endif } else jit_load(regno); @@ -290,6 +315,153 @@ _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno) jit_regset_clrbit(&_jitc->regarg, regno); } +#if __ia64__ +void +jit_regset_com(jit_regset_t *u, jit_regset_t *v) +{ + u->rl = ~v->rl; u->rh = ~v->rh; + u->fl = ~v->fl; u->fh = ~v->fh; +} + +void +jit_regset_and(jit_regset_t *u, jit_regset_t *v, jit_regset_t *w) +{ + u->rl = v->rl & w->rl; u->rh = v->rh & w->rh; + u->fl = v->fl & w->fl; u->fh = v->fh & w->fh; +} + +void +jit_regset_ior(jit_regset_t *u, jit_regset_t *v, jit_regset_t *w) +{ + u->rl = v->rl | w->rl; u->rh = v->rh | w->rh; + u->fl = v->fl | w->fl; u->fh = v->fh | w->fh; +} + +void +jit_regset_xor(jit_regset_t *u, jit_regset_t *v, jit_regset_t *w) +{ + u->rl = v->rl ^ w->rl; u->rh = v->rh ^ w->rh; + u->fl = v->fl ^ w->fl; u->fh = v->fh ^ w->fh; +} + +void +jit_regset_set(jit_regset_t *u, jit_regset_t *v) +{ + u->rl = v->rl; u->rh = v->rh; + u->fl = v->fl; u->fh = v->fh; +} + +void +jit_regset_set_mask(jit_regset_t *u, jit_int32_t v) +{ + jit_bool_t w = !!(v & (v - 1)); + + assert(v >= 0 && v <= 256); + if (v == 0) + u->rl = u->rh = u->fl = u->fh = -1LL; + else if (v <= 64) { + u->rl = w ? (1LL << v) - 1 : -1LL; + u->rh = u->fl = u->fh = 0; + } + else if (v <= 128) { + u->rl = -1LL; + u->rh = w ? (1LL << (v - 64)) - 1 : -1LL; + u->fl = u->fh = 0; + } + else if (v <= 192) { + u->rl = u->rh = -1LL; + u->fl = w ? (1LL << (v - 128)) - 1 : -1LL; + u->fh = 0; + } + else { + u->rl = u->rh = u->fl = -1LL; + u->fh = w ? (1LL << (v - 128)) - 1 : -1LL; + } +} + +jit_bool_t +jit_regset_cmp_ui(jit_regset_t *u, jit_word_t v) +{ + return !((u->rl == v && u->rh == 0 && u->fl == 0 && u->fh == 0)); +} + +void +jit_regset_set_ui(jit_regset_t *u, jit_word_t v) +{ + u->rl = v; + u->rh = u->fl = u->fh = 0; +} + +jit_bool_t +jit_regset_set_p(jit_regset_t *u) +{ + return (u->rl || u->rh || u->fl || u->fh); +} + +void +jit_regset_clrbit(jit_regset_t *set, jit_int32_t bit) +{ + assert(bit >= 0 && bit <= 255); + if (bit < 64) + set->rl &= ~(1LL << bit); + else if (bit < 128) + set->rh &= ~(1LL << (bit - 64)); + else if (bit < 192) + set->fl &= ~(1LL << (bit - 128)); + else + set->fh &= ~(1LL << (bit - 192)); +} + +void +jit_regset_setbit(jit_regset_t *set, jit_int32_t bit) +{ + assert(bit >= 0 && bit <= 255); + if (bit < 64) + set->rl |= 1LL << bit; + else if (bit < 128) + set->rh |= 1LL << (bit - 64); + else if (bit < 192) + set->fl |= 1LL << (bit - 128); + else + set->fh |= 1LL << (bit - 192); +} + +jit_bool_t +jit_regset_tstbit(jit_regset_t *set, jit_int32_t bit) +{ + assert(bit >= 0 && bit <= 255); + if (bit < 64) + return (!!(set->rl & (1LL << bit))); + else if (bit < 128) + return (!!(set->rh & (1LL << (bit - 64)))); + else if (bit < 192) + return (!!(set->fl & (1LL << (bit - 128)))); + return (!!(set->fh & (1LL << (bit - 192)))); +} + +unsigned long +jit_regset_scan1(jit_regset_t *set, jit_int32_t offset) +{ + assert(offset >= 0 && offset <= 255); + for (; offset < 64; offset++) { + if (set->rl & (1LL << offset)) + return (offset); + } + for (; offset < 128; offset++) { + if (set->rh & (1LL << (offset - 64))) + return (offset); + } + for (; offset < 192; offset++) { + if (set->fl & (1LL << (offset - 128))) + return (offset); + } + for (; offset < 256; offset++) { + if (set->fh & (1LL << (offset - 192))) + return (offset); + } + return (ULONG_MAX); +} +#else unsigned long jit_regset_scan1(jit_regset_t *set, jit_int32_t offset) { @@ -300,6 +472,7 @@ jit_regset_scan1(jit_regset_t *set, jit_int32_t offset) } return (ULONG_MAX); } +#endif void _jit_save(jit_state_t *_jit, jit_int32_t reg) @@ -661,10 +834,15 @@ _jit_clear_state(jit_state_t *_jit) jit_free((jit_pointer_t *)&_jitc->data_info.ptr); #endif -#if __powerpc64__ +#if __powerpc64__ || __ia64__ jit_free((jit_pointer_t *)&_jitc->prolog.ptr); #endif +#if __ia64__ + jit_regset_del(&_jitc->gprs); + jit_regset_del(&_jitc->fprs); +#endif + jit_free((jit_pointer_t *)&_jitc); } @@ -2689,4 +2867,6 @@ _patch_register(jit_state_t *_jit, jit_node_t *node, jit_node_t *link, # include "jit_ppc.c" #elif defined(__sparc__) # include "jit_sparc.c" +#elif defined(__ia64__) +# include "jit_ia64.c" #endif