From 3356b9d93a59c0aaa7c1303bea70cc10b87d7827 Mon Sep 17 00:00:00 2001 From: pcpa Date: Sat, 1 Jun 2013 01:53:33 -0300 Subject: [PATCH] Add functional hppa port. All tests pass. * include/lightning/jit_hppa.h, lib/jit_hppa-cpu.c, lib/jit_hppa-fpu.c, lib/jit_hppa.c: New files implementing the hppa port. Built on Debian Linux PA-RISC 2.0, 32 bit. * check/float.tst: Add preprocessor for hppa expected values when converting NaN and +-Inf to an integer. * check/ldst.inc: Ensure double load/store tests use an 8 byte aligned address by default. * lib/lightning.c: Correct a bug found during tests in the new port, where qmul* and qdiv* were not properly setting one of the result registers as modified in the function, what would be a problem if the only "write" usage were the qmul* or qdiv*. * check/varargs.tst, check/varargs.ok: Add one extra interleaved integer/double test to validate proper code generation in the extra case. * check/lightning.c, configure.ac, include/lightning.h, include/lightning/Makefile.am, include/lightning/jit_private.h, lib/Makefile.am, lib/jit_disasm.c: Update for the hppa port. --- ChangeLog | 27 + check/float.tst | 4 +- check/ldst.inc | 1 + check/lightning.c | 5 + check/varargs.ok | 1 + check/varargs.tst | 118 ++ configure.ac | 2 + include/lightning.h | 2 + include/lightning/Makefile.am | 4 + include/lightning/jit_hppa.h | 123 ++ include/lightning/jit_private.h | 4 + lib/Makefile.am | 3 + lib/jit_disasm.c | 2 +- lib/jit_hppa-cpu.c | 2695 +++++++++++++++++++++++++++++++ lib/jit_hppa-fpu.c | 924 +++++++++++ lib/jit_hppa.c | 1186 ++++++++++++++ lib/lightning.c | 16 +- 17 files changed, 5111 insertions(+), 6 deletions(-) create mode 100644 include/lightning/jit_hppa.h create mode 100644 lib/jit_hppa-cpu.c create mode 100644 lib/jit_hppa-fpu.c create mode 100644 lib/jit_hppa.c diff --git a/ChangeLog b/ChangeLog index f56d322d8..1c0afba75 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,30 @@ +2013-06-01 Paulo Andrade + + * include/lightning/jit_hppa.h, lib/jit_hppa-cpu.c, + lib/jit_hppa-fpu.c, lib/jit_hppa.c: New files implementing + the hppa port. Built on Debian Linux PA-RISC 2.0, 32 bit. + + * check/float.tst: Add preprocessor for hppa expected + values when converting NaN and +-Inf to an integer. + + * check/ldst.inc: Ensure double load/store tests use an + 8 byte aligned address by default. + + * lib/lightning.c: Correct a bug found during tests in + the new port, where qmul* and qdiv* were not properly + setting one of the result registers as modified in the + function, what would be a problem if the only "write" + usage were the qmul* or qdiv*. + + * check/varargs.tst, check/varargs.ok: Add one extra + interleaved integer/double test to validate proper code + generation in the extra case. + + * check/lightning.c, configure.ac, include/lightning.h, + include/lightning/Makefile.am, + include/lightning/jit_private.h, lib/Makefile.am, + lib/jit_disasm.c: Update for the hppa port. + 2013-04-27 Paulo Andrade * check/varargs.tst: Correct misplaced .align directive diff --git a/check/float.tst b/check/float.tst index 65ab3c671..f905dbeeb 100644 --- a/check/float.tst +++ b/check/float.tst @@ -14,14 +14,14 @@ ok: # define x80 0x8000000000000000 #endif -#if __mips__ || __sparc__ +#if __mips__ || __sparc__ || __hppa__ # define wnan x7f #elif __arm__ # define wnan 0 #else # define wnan x80 #endif -#if __mips__ || __arm__ || __ppc__ || __sparc__ +#if __mips__ || __arm__ || __ppc__ || __sparc__ || __hppa__ # define wpinf x7f #else # define wpinf x80 diff --git a/check/ldst.inc b/check/ldst.inc index 51eb2a47f..c2bc59a83 100644 --- a/check/ldst.inc +++ b/check/ldst.inc @@ -63,6 +63,7 @@ .data 512 ok: .c "ok\n" +.align 8 t0: c0: .c 0 diff --git a/check/lightning.c b/check/lightning.c index 40adeb328..bf1e126ae 100644 --- a/check/lightning.c +++ b/check/lightning.c @@ -3974,6 +3974,11 @@ main(int argc, char *argv[]) opt_short += snprintf(cmdline + opt_short, sizeof(cmdline) - opt_short, " -D__ia64__=1"); +#endif +#if defined(__hppa__) + opt_short += snprintf(cmdline + opt_short, + sizeof(cmdline) - opt_short, + " -D__hppa__=1"); #endif if ((parser.fp = popen(cmdline, "r")) == NULL) error("cannot execute %s", cmdline); diff --git a/check/varargs.ok b/check/varargs.ok index 5dcccb0e4..e10328339 100644 --- a/check/varargs.ok +++ b/check/varargs.ok @@ -1,3 +1,4 @@ 0 1 2 3 4 5 6 7 8 9 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 0 0.0 1 1.0 2 2.0 3 3.0 4 4.0 5 5.0 6 6.0 7 7.0 8 8.0 9 9.0 +0.0 0 1.0 1 2.0 2 3.0 3 4.0 4 5.0 5 6.0 6 7.0 7 8.0 8 9.0 9 diff --git a/check/varargs.tst b/check/varargs.tst index e838c7a66..11131d9b2 100644 --- a/check/varargs.tst +++ b/check/varargs.tst @@ -15,6 +15,10 @@ idfmt: .c "%d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f\n" ldfmt: .c "%d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf\n" +difmt: +.c "%.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d\n" +dlfmt: +.c "%lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d\n" .align 8 buff: .size 256 @@ -276,5 +280,119 @@ outid: ellipsis finishi @printf + /* + sprintf(buff, + "%.1f %d %.1f %d %.1f %d %.1f %d %.1f %d " + "%.1f %d %.1f %d %.1f %d %.1f %d %.1f %d\n", + 0.0, 0, 1.0, 1, 2.0, 2, 3.0, 3, 4.0, 4, + 5, 5.0, 6.0, 6, 7.0, 7, 8.0, 8, 9.0, 9); + */ + prepare + pushargi buff + pushargi difmt + ellipsis + pushargi_d 0.0 + pushargi 0 + pushargi_d 1.0 + pushargi 1 + pushargi_d 2.0 + pushargi 2 + pushargi_d 3.0 + pushargi 3 + pushargi_d 4.0 + pushargi 4 + pushargi_d 5.0 + pushargi 5 + pushargi_d 6.0 + pushargi 6 + pushargi_d 7.0 + pushargi 7 + pushargi_d 8.0 + pushargi 8 + pushargi_d 9.0 + pushargi 9 + finishi @sprintf + + /* + sscanf(buff, + "%lf %d %lf %d %lf %d %lf %d %lf %d " + "%lf %d %lf %d %lf %d %lf %d %lf %d \n", + dchk+0, ichk+0, dchk+1, ichk+1, dchk+2, + ichk+2, dchk+3, ichk+3, dchk+4, ichk+4, + dchk+5, ichk+5, dchk+6, ichk+6, dchk+7, + ichk+7, dchk+8, ichk+8, dchk+9, ichk+9); + */ + movi %v0 dchk + movi %v1 ichk + prepare + pushargi buff + pushargi dlfmt + ellipsis + pushargr %v0 /* 0 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 1 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 2 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 3 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 4 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 5 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 6 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 7 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 8 */ + addi %v0 %v0 8 + pushargr %v1 + addi %v1 %v1 4 + pushargr %v0 /* 9 */ + pushargr %v1 + finishi @sscanf + + movi %v0 ichk + movi %v1 dchk + movi %r0 0 + movi_d %f0 0.0 +loopdi: + ldr_i %r1 %v0 + beqr check_d %r0 %r1 + calli @abort +check_d: + ldr_d %f1 %v1 + beqr_d nextdi %f0 %f1 + calli @abort +nextdi: + addi %r0 %r0 1 + addi_d %f0 %f0 1.0 + bgei outdi %r0 10 + addi %v0 %v0 4 + addi %v1 %v1 8 + jmpi loopdi +outdi: + + prepare + pushargi buff + ellipsis + finishi @printf + ret epilog diff --git a/configure.ac b/configure.ac index f32e53228..8d606151c 100644 --- a/configure.ac +++ b/configure.ac @@ -74,6 +74,7 @@ case "$target_cpu" in *powerpc*) cpu=ppc ;; *sparc*) cpu=sparc ;; ia64) cpu=ia64 ;; + hppa*) cpu=hppa ;; *) ;; esac AM_CONDITIONAL(cpu_arm, [test cpu-$cpu = cpu-arm]) @@ -82,6 +83,7 @@ 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]) +AM_CONDITIONAL(cpu_hppa, [test cpu-$cpu = cpu-hppa]) # Test x87 if both, x87 and sse2 available ac_cv_test_x86_x87= diff --git a/include/lightning.h b/include/lightning.h index 7cbaf3011..e836aaf9e 100644 --- a/include/lightning.h +++ b/include/lightning.h @@ -76,6 +76,8 @@ typedef jit_int32_t jit_fpr_t; # include #elif defined(__ia64__) # include +#elif defined(__hppa__) +# include #endif #define jit_flag_node 0x00000001 /* patch node not absolute */ diff --git a/include/lightning/Makefile.am b/include/lightning/Makefile.am index 23e232b48..7c77c4971 100644 --- a/include/lightning/Makefile.am +++ b/include/lightning/Makefile.am @@ -41,3 +41,7 @@ if cpu_ia64 lightning_include_HEADERS = \ jit_ia64.h endif +if cpu_hppa +lightning_include_HEADERS = \ + jit_hppa.h +endif diff --git a/include/lightning/jit_hppa.h b/include/lightning/jit_hppa.h new file mode 100644 index 000000000..a4d6c8ce0 --- /dev/null +++ b/include/lightning/jit_hppa.h @@ -0,0 +1,123 @@ +/* + * 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_hppa_h +#define _jit_hppa_h + +#define JIT_HASH_CONSTS 1 +#define JIT_NUM_OPERANDS 3 + +/* + * Types + */ +typedef enum { +#define jit_arg_reg_p(i) (i >= 0 && i <= 4) +#define jit_arg_f_reg_p(i) (i >= 0 && i <= 4) + _R0, /* Always zero */ + _R1, /* ADDIL implicit target */ + _R2, /* B,L implicit target */ +#define jit_r_num() 4 +#define jit_r(n) ((n) < 4 ? _R4 + (n) : _R10 + (n)) +#define jit_v_num() 4 +#define jit_v(n) ((n) < 4 ? _R7 + (n) : _R11 + (n)) +#define jit_f_num() 8 +#define jit_f(n) (_F12 - (n)) +#define JIT_FP _R3 +#define JIT_R0 _R4 +#define JIT_R1 _R5 +#define JIT_R2 _R6 +#define JIT_V0 _R7 +#define JIT_V1 _R8 +#define JIT_V2 _R9 + _R3, + _R19, + _R20, + _R21, + _R22, + _R29, /* ret1 */ + _R28, /* ret0 */ + _R4, + _R5, + _R6, + _R7, + _R8, + _R9, + _R10, + _R11, + _R12, + _R13, + _R14, + _R15, + _R16, + _R17, + _R18, + _R23, /* arg3 */ + _R24, /* arg2 */ + _R25, /* arg1 */ + _R26, /* arg0 */ + _R27, /* Data Pointer */ + _R30, /* Stack Pointer */ + _R31, /* Link register */ +#define JIT_F0 _F12 +#define JIT_F1 _F13 +#define JIT_F2 _F14 +#define JIT_F3 _F15 +#define JIT_F4 _F16 +#define JIT_F5 _F17 + /* Caller Saves */ + _F31, + _F30, + _F29, + _F28, + _F27, + _F26, + _F25, + _F24, + _F23, + _F22, + _F11, + _F10, + _F9, + _F8, + /* Arguments */ + _F7, /* farg3 */ + _F6, /* farg2 */ + _F5, /* farg1 */ + _F4, /* farg0 */ + /* Callee Saves */ + _F21, + _F20, + _F19, + _F18, + _F17, + _F16, + _F15, + _F14, + _F13, + _F12, + /* Floating-Pointer Status and Exception */ + _F0, + _F1, + _F2, + _F3, +#define JIT_NOREG _NOREG + _NOREG, +} jit_reg_t; + +typedef jit_int64_t jit_regset_t; + +#endif /* _jit_hppa */ diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h index b6740e45f..9c7eecfe1 100644 --- a/include/lightning/jit_private.h +++ b/include/lightning/jit_private.h @@ -77,6 +77,10 @@ # define JIT_SP _R12 # define JIT_RET _R8 # define JIT_FRET _F8 +#elif defined(__hppa__) +# define JIT_SP _R30 +# define JIT_RET _R28 +# define JIT_FRET _F4 #endif #define jit_size(vector) (sizeof(vector) / sizeof((vector)[0])) diff --git a/lib/Makefile.am b/lib/Makefile.am index 6b5dbc2bf..2cbe04732 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_hppa.c \ + jit_hppa-cpu.c \ + jit_hppa-fpu.c \ jit_ia64.c \ jit_ia64-cpu.c \ jit_ia64-fpu.c \ diff --git a/lib/jit_disasm.c b/lib/jit_disasm.c index 6366ac733..829220c8b 100644 --- a/lib/jit_disasm.c +++ b/lib/jit_disasm.c @@ -89,7 +89,7 @@ jit_init_debug(void) # endif # if defined(__sparc__) disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG; -#endif +# endif disasm_info.print_address_func = disasm_print_address; if (bfd_get_file_flags(disasm_bfd) & HAS_SYMS) { diff --git a/lib/jit_hppa-cpu.c b/lib/jit_hppa-cpu.c new file mode 100644 index 000000000..71a684ccc --- /dev/null +++ b/lib/jit_hppa-cpu.c @@ -0,0 +1,2695 @@ +/* + * 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 +typedef struct idiv { + int quo; + int rem; +} idiv_t; + +typedef struct udiv { + unsigned int quo; + unsigned int rem; +} udiv_t; + +/* 16 spill bytes; -52 for first actual stack argument */ +#define params_offset -32 +/* Assume all callee save registers may need to be spilled */ +#define alloca_offset 192 +#define _R0_REGNO 0 +#define _R1_REGNO 1 +#define _RP_REGNO 2 +#define _FP_REGNO 3 +#define _R19_REGNO 19 +#define _R23_REGNO 23 +#define _R24_REGNO 24 +#define _R25_REGNO 25 +#define _R26_REGNO 26 +#define _R28_REGNO 28 +#define _R29_REGNO 29 +#define _SP_REGNO 30 +#define _R31_REGNO 31 +#define _CR11_REGNO 11 +#define ii(v) *_jit->pc.ui++ = v +#define f1(o,b,t,i) _f1(_jit,o,b,t,i) +static void _f1(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f2(o,b,r,i,j) _f2(_jit,o,b,r,i,j) +static void _f2(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f3(o,b,t,i,j) _f3(_jit,o,b,t,i,j) +static void _f3(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f4(o,b,x,s,u,y,c,z,m,t) _f4(_jit,o,b,x,s,u,y,c,z,m,t) +static void _f4(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f5(o,b,i,s,a,y,c,z,m,t) _f5(_jit,o,b,i,s,a,y,c,z,m,t) +static void _f5(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f6(o,b,r,s,a,x,c,y,m,i) _f6(_jit,o,b,r,s,a,x,c,y,m,i) +static void _f6(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f7(o,r,i) _f7(_jit,o,r,i) +static void _f7(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define f8(o,r2,r1,cf,e1,x,e2,y,d,t) _f8(_jit,o,r2,r1,cf,e1,x,e2,y,d,t) +static void _f8(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f9(o,r,t,cf,e1,im) _f9(_jit,o,r,t,cf,e1,im) +static void _f9(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f10(o,r2,r1,u,v,w,x,sa,y,t) _f10(_jit,o,r2,r1,u,v,w,x,sa,y,t) +static void _f10(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f11(o,r2,r1,c,x,y,z,u,t) _f11(_jit,o,r2,r1,c,x,y,z,u,t) +static void _f11(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f12(o,r,t,c,x,se,y,c1,z,clen) _f12(_jit,o,r,t,c,x,se,y,c1,z,clen) +static void _f12(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f13(o,t,r,c,x,nz,c1,clen) _f13(_jit,o,t,r,c,x,nz,c1,clen) +static void _f13(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f13x(o,t,i,c,x,nz,c1,clen) _f13x(_jit,o,t,i,c,x,nz,c1,clen) +static void _f13x(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f14(o,r2,r1,c,x,cp,y,cpos,t) _f14(_jit,o,r2,r1,c,x,cp,y,cpos,t) +static void _f14(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f15(o,r,t,c,c1,p,se,pos,clen) _f15(_jit,o,r,t,c,c1,p,se,pos,clen) +static void _f15(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f16(o,t,r,c,c1,cp,nz,cpos,clen) _f16(_jit,o,t,r,c,c1,cp,nz,cpos,clen) +static void _f16(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f16x(o,t,i,c,c1,cp,nz,cpos,clen) _f16x(_jit,o,t,i,c,c1,cp,nz,cpos,clen) +static void _f16x(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f17(o,r2,r1,c,i,n) _f17(_jit,o,r2,r1,c,i,n) +static void _f17(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f17x(o,r2,r1,c,i,n) _f17x(_jit,o,r2,r1,c,i,n) +static void _f17x(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f18(o,p,r,c,i,n) _f18(_jit,o,p,r,c,i,n) +static void _f18(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f19(o,b,s,i,n) _f19(_jit,o,b,s,i,n) +static void _f19(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f20(o,t,i,g,n) _f20(_jit,o,t,i,g,n) +static void _f20(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f21(o,t,x,y,n) _f21(_jit,o,t,x,y,n) +static void _f21(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define f22(o,b,x,r,n,p) _f22(_jit,o,b,x,r,n,p) +static void _f22(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f23(o,a,b,c,d,e,f,g,h) _f23(_jit,o,a,b,c,d,e,f,g,h) +static void _f23(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f24(o,b,x,s,y,m,r) _f24(_jit,o,b,x,s,y,m,r) +static void _f24(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f25(o,b,i,s,y,m,r) _f25(_jit,o,b,i,s,y,m,r) +static void _f25(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f26(o,b,x,s,y,m,r) _f26(_jit,o,b,x,s,y,m,r) +static void _f26(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f27(o,i,j) _f27(_jit,o,i,j) +static void _f27(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f28(o,i) _f28(_jit,o,i) +static void _f28(jit_state_t*,jit_int32_t,jit_int32_t) maybe_unused; +#define f29(o,r,x,s,y,t) _f29(_jit,o,r,x,s,y,t) +static void _f29(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f30(o,b,r,s,x,y,t) _f30(_jit,o,b,r,s,x,y,t) +static void _f30(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f31(o,t,r,v,x,y) _f31(_jit,o,t,r,v,x,y) +static void _f31(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f33(o,x,r,y,z,u) _f33(_jit,o,x,r,y,z,u) +static void _f33(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f34(o,o1,x,sf,n,o2) _f34(_jit,o,o1,x,sf,n,o2) +static void _f34(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f35(o,op,x,sf,n,t) _f35(_jit,o,op,x,sf,n,t) +static void _f35(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f36(o,r,o1,x,sf,n,o2) _f36(_jit,o,r,o1,x,sf,n,o2) +static void _f36(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f37(o,r2,r1,o1,x,sf,n,o2) _f37(_jit,o,r2,r1,o1,x,sf,n,o2) +static void _f37(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f38(o,s,u,n) _f38(_jit,o,s,u,n) +static void _f38(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +/* nulify next instruction if condition is met with addition */ +#define ADD_CF_NV 0 /* never */ +#define ADD_CF_EQ 2 /* O1 == -O2 (word) */ +#define ADD_CF_LT 4 /* O1 < -O2 (signed)*/ +#define ADD_CF_LE 6 /* O1 <= -O2 (signed) */ +#define ADD_CF_NUV 8 /* O1 + O2 does not overflow (unsigned) */ +#define ADD_CF_ZNV 10 /* O1 + O2 is zero or no overflow (unsigned) */ +#define ADD_CF_SV 12 /* O1 + O2 overflows (signed) */ +#define ADD_CF_OD 14 /* O1 + O2 is odd */ +#define ADD_CF_TR 1 /* always */ +#define ADD_CF_NE 3 /* O1 != -O2 */ +#define ADD_CF_GE 5 /* O1 >= -O2 (signed) */ +#define ADD_CF_GT 7 /* O1 > -O2 (signed) */ +#define ADD_CF_UV 9 /* O1 + O2 overflows (unsigned) */ +#define ADD_CF_VNZ 11 /* O1 + O2 is nonzero and overflows (unsigned) */ +#define ADD_CF_NSV 13 /* O1 + O2 does not overflow (signed) */ +#define ADD_CF_EV 15 /* O1 + O2 is even */ +#define ADD_EN_NONE 6 /* none */ +#define ADD_EN_C 7 /* with carry */ +#define ADD_EN_L 10 /* logical */ +#define ADD_EN_TSV 12 /* trap on signed overflow */ +#define ADD_EN_C_TSV 13 /* with carry and trap on signed overflow */ +#define ADDI_OE_TC 0 /* trap on condition */ +#define ADDI_OE_TSV_TC 1 /* trap on signed overflow or condition */ +#define ADDI_OE_NONE 2 /* none */ +#define ADDI_OE_TSV 3 /* trap on signed overflow */ +#define ADD_(en,cf,r1,r2,t) f8(0x2,r2,r1,cf,en>>2,1,en&1,0,0,t) +#define ADD(r1,r2,t) ADD_(ADD_EN_NONE,ADD_CF_NV,r1,r2,t) +#define ADD_C(r1,r2,t) ADD_(ADD_EN_C,ADD_CF_NV,r1,r2,t) +#define ADD_L(r1,r2,t) ADD_(ADD_EN_L,ADD_CF_NV,r1,r2,t) +#define ADDB_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,0) +#define ADDB(r1,r2,t) ADDB_(ADD_CF_NV,r1,r2,t) +#define ADDB_EQ(r1,r2,t) ADDB_(ADD_CF_EQ,r1,r2,t) +#define ADDB_LT(r1,r2,t) ADDB_(ADD_CF_LT,r1,r2,t) +#define ADDB_LE(r1,r2,t) ADDB_(ADD_CF_LE,r1,r2,t) +#define ADDB_NUV(r1,r2,t) ADDB_(ADD_CF_NUV,r1,r2,t) +#define ADDB_ZNV(r1,r2,t) ADDB_(ADD_CF_ZNV,r1,r2,t) +#define ADDB_SV(r1,r2,t) ADDB_(ADD_CF_SV,r1,r2,t) +#define ADDB_OD(r1,r2,t) ADDB_(ADD_CF_OD,r1,r2,t) +#define ADDB_TR(r1,r2,t) ADDB_(ADD_CF_TR,r1,r2,t) +#define ADDB_NE(r1,r2,t) ADDB_(ADD_CF_NE,r1,r2,t) +#define ADDB_GE(r1,r2,t) ADDB_(ADD_CF_GE,r1,r2,t) +#define ADDB_GT(r1,r2,t) ADDB_(ADD_CF_GT,r1,r2,t) +#define ADDB_UV(r1,r2,t) ADDB_(ADD_CF_UV,r1,r2,t) +#define ADDB_VNZ(r1,r2,t) ADDB_(ADD_CF_VNZ,r1,r2,t) +#define ADDB_NSV(r1,r2,t) ADDB_(ADD_CF_NSV,r1,r2,t) +#define ADDB_EV(r1,r2,t) ADDB_(ADD_CF_EV,r2,r1,t) +#define ADDB_N_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,1) +#define ADDB_N(r1,r2,t) ADDB_N_(ADD_CF_NV,r1,r2,t) +#define ADDB_N_EQ(r1,r2,t) ADDB_N_(ADD_CF_EQ,r1,r2,t) +#define ADDB_N_LT(r1,r2,t) ADDB_N_(ADD_CF_LT,r1,r2,t) +#define ADDB_N_LE(r1,r2,t) ADDB_N_(ADD_CF_LE,r1,r2,t) +#define ADDB_N_NUV(r1,r2,t) ADDB_N_(ADD_CF_NUV,r1,r2,t) +#define ADDB_N_ZNV(r1,r2,t) ADDB_N_(ADD_CF_ZNV,r1,r2,t) +#define ADDB_N_SV(r1,r2,t) ADDB_N_(ADD_CF_SV,r1,r2,t) +#define ADDB_N_OD(r1,r2,t) ADDB_N_(ADD_CF_OD,r1,r2,t) +#define ADDB_N_TR(r1,r2,t) ADDB_N_(ADD_CF_TR,r1,r2,t) +#define ADDB_N_NE(r1,r2,t) ADDB_N_(ADD_CF_NE,r1,r2,t) +#define ADDB_N_GE(r1,r2,t) ADDB_N_(ADD_CF_GE,r1,r2,t) +#define ADDB_N_GT(r1,r2,t) ADDB_N_(ADD_CF_GT,r1,r2,t) +#define ADDB_N_UV(r1,r2,t) ADDB_N_(ADD_CF_UV,r1,r2,t) +#define ADDB_N_VNZ(r1,r2,t) ADDB_N_(ADD_CF_VNZ,r1,r2,t) +#define ADDB_N_NSV(r1,r2,t) ADDB_N_(ADD_CF_NSV,r1,r2,t) +#define ADDB_N_EV(r1,r2,t) ADDB_N_(ADD_CF_EV,r1,r2,t) +#define ADDI_(ec,cf,i,r,t) f9(0x2c|(ec>>1),r,t,cf,ec&1,i) +#define ADDI(i,r,t) ADDI_(ADDI_OE_NONE,ADD_CF_NV,i,r,t) +#define ADDIB_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,0) +#define ADDIB(i,r,t) ADDIB_(ADD_CF_NV,i,r,t) +#define ADDIB_EQ(i,r,t) ADDIB_(ADD_CF_EQ,i,r,t) +#define ADDIB_LT(i,r,t) ADDIB_(ADD_CF_LT,i,r,t) +#define ADDIB_LE(i,r,t) ADDIB_(ADD_CF_LE,i,r,t) +#define ADDIB_NUV(i,r,t) ADDIB_(ADD_CF_NUV,i,r,t) +#define ADDIB_ZNV(i,r,t) ADDIB_(ADD_CF_ZNV,i,r,t) +#define ADDIB_SV(i,r,t) ADDIB_(ADD_CF_SV,i,r,t) +#define ADDIB_OD(i,r,t) ADDIB_(ADD_CF_OD,i,r,t) +#define ADDIB_TR(i,r,t) ADDIB_(ADD_CF_TR,i,r,t) +#define ADDIB_NE(i,r,t) ADDIB_(ADD_CF_NE,i,r,t) +#define ADDIB_GE(i,r,t) ADDIB_(ADD_CF_GE,i,r,t) +#define ADDIB_GT(i,r,t) ADDIB_(ADD_CF_GT,i,r,t) +#define ADDIB_UV(i,r,t) ADDIB_(ADD_CF_UV,i,r,t) +#define ADDIB_VNZ(i,r,t) ADDIB_(ADD_CF_VNZ,i,r,t) +#define ADDIB_NSV(i,r,t) ADDIB_(ADD_CF_NSV,i,r,t) +#define ADDIB_EV(i,r,t) ADDIB_(ADD_CF_EV,i,r,t) +#define ADDIB_N_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,1) +#define ADDIB_N(i,r,t) ADDIB_N_(ADD_CF_NV,i,r,t) +#define ADDIB_N_EQ(i,r,t) ADDIB_N_(ADD_CF_EQ,i,r,t) +#define ADDIB_N_LT(i,r,t) ADDIB_N_(ADD_CF_LT,i,r,t) +#define ADDIB_N_LE(i,r,t) ADDIB_N_(ADD_CF_LE,i,r,t) +#define ADDIB_N_NUV(i,r,t) ADDIB_N_(ADD_CF_NUV,i,r,t) +#define ADDIB_N_ZNV(i,r,t) ADDIB_N_(ADD_CF_ZNV,i,r,t) +#define ADDIB_N_SV(i,r,t) ADDIB_N_(ADD_CF_SV,i,r,t) +#define ADDIB_N_OD(i,r,t) ADDIB_N_(ADD_CF_OD,i,r,t) +#define ADDIB_N_TR(i,r,t) ADDIB_N_(ADD_CF_TR,i,r,t) +#define ADDIB_N_NE(i,r,t) ADDIB_N_(ADD_CF_NE,i,r,t) +#define ADDIB_N_GE(i,r,t) ADDIB_N_(ADD_CF_GE,i,r,t) +#define ADDIB_N_GT(i,r,t) ADDIB_N_(ADD_CF_GT,i,r,t) +#define ADDIB_N_UV(i,r,t) ADDIB_N_(ADD_CF_UV,i,r,t) +#define ADDIB_N_VNZ(i,r,t) ADDIB_N_(ADD_CF_VNZ,i,r,t) +#define ADDIB_N_NSV(i,r,t) ADDIB_N_(ADD_CF_NSV,i,r,t) +#define ADDIB_N_EV(i,r,t) ADDIB_N_(ADD_CF_EV,0,i,r,t) +#define ADDIL(i,r) f7(0xa,r,i) +#define LOG_CC_NV 0 /* never */ +#define LOG_CC_EQ 1 /* all bits are 0 */ +#define LOG_CC_LT 2 /* leftmost bit is 1 */ +#define LOG_CC_LE 3 /* leftmost bit is 1 or all bits are 0 */ +#define LOG_CC_OD 7 /* rightmost bit is 1 */ +#define LOG_CC_TR 8 /* always */ +#define LOG_CC_NE 9 /* some bits are 1 */ +#define LOG_CC_GE 10 /* leftmost bit is 0 */ +#define LOG_CC_GT 11 /* leftmost bit is 0 or some bits are 1 */ +#define LOG_CC_EV 15 /* rightmost bit is 0 */ +#define AND_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,1,0,0,0,t) +#define AND(r1,r2,t) AND_(LOG_CC_NV,r1,r2,t) +#define ANDCM_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,0,0,0,0,t) +#define ANDCM(r1,r2,t) ANDCM_(LOG_CC_NV,r1,r2,t) +#define B_(n,i,t) f20(0x3a,t,i,0,n) +#define B(i,t) B_(0,i,t) +#define B_N(i,t) B_(1,i,t) +#define B_L(i) B_(0,i,_RP_REGNO) +#define B_L_N(i) B_(1,i,_RP_REGNO) +#define BB_CC_LT 0 /* leftmost bit in word is 1 */ +#define BB_CC_GE 1 /* leftmost bit in word is 0 */ +#define BB_(c,r,i) f18(0x30,0,r,c,i,0) +#define BB_N_(c,r,i) f18(0x30,0,r,c,i,1) +#define BBI_(c,r,p,i) f18(0x31,p,r,c,i,0) +#define BBI_N_(c,r,p,i) f18(0x31,p,r,c,i,1) +#define BB(c,r,i) BB_(c,r,i) +#define BBI_LT(r,p,i) BBI_(BB_CC_LT,r,p,i) +#define BBI_GE(r,p,i) BBI_(BB_CC_GE,r,p,i) +#define BB_N(c,r,i) BB_(c,r,i) +#define BBI_N_LT(r,p,i) BBI_N_(BB_CC_LT,r,p,i) +#define BBI_N_GE(r,p,i) BBI_N_(BB_CC_GE,r,p,i) +#define BE(i,s,b) f19(0x38,b,s,i,0) +#define BE_L(i,s,b) f19(0x39,b,s,i,0) +#define BLR(x,t) f21(0x3a,t,x,2,0) +#define BLR_N(x,t) f21(0x3a,t,x,2,1) +#define BREAK(i,j) f27(0,j,i) +#define BV(x,b) f21(0x3a,b,x,6,0) +#define BV_N(x,b) f21(0x3a,b,x,6,1) +#define BVE(b) f22(0x3a,b,6,0,0,0) +#define BVE_L(b) f22(0x3a,b,7,0,0,0) +#define II_C_NONE 0 +#define II_C_M (1<<5) +#define II_C_S (1<<13) +#define II_C_SM (II_C_S|II_C_M) +#define II_AU_NONE 0 +#define II_AU_PRE ((1<<13)|II_C_M) +#define II_AU_POS II_C_M +#define LD_CC_H_NONE 0 /* No hint */ +#define LD_CC_H_SPL 2 /* Spatial Locality */ +#define CLRBTS() f23(0x3a,0,0,2,0,0,1,0,1) +#define CS_CC_NV 0 /* never */ +#define CS_CC_EQ 2 /* O1 = O2 */ +#define CS_CC_LT 4 /* O1 < O2 (signed) */ +#define CS_CC_LE 6 /* O1 <= O2 (signed) */ +#define CS_CC_ULT 8 /* O1 < O2 (unsigned) */ +#define CS_CC_ULE 10 /* O1 <= O2 (unsigned) */ +#define CS_CC_SV 12 /* O1 - O2 overflows (signed) */ +#define CS_CC_OD 14 /* O1 - O2 is odd */ +#define CS_CC_TR 1 /* always */ +#define CS_CC_NE 3 /* O1 != O2 */ +#define CS_CC_GE 5 /* O1 >= O2 (signed) */ +#define CS_CC_GT 7 /* O1 > O2 (signed) */ +#define CS_CC_UGE 9 /* O1 >= O2 (unsigned) */ +#define CS_CC_UGT 11 /* O1 > O2 (unsigned) */ +#define CS_CC_NSV 13 /* O1 - O2 does not overflows (signed) */ +#define CS_CC_EV 15 /* O1 - O2 is even */ +#define CMPB_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,0) +#define CMPB(r1,r2,i) CMPB_(CS_CC_NV,r1,r2,i) +#define CMPB_EQ(r1,r2,i) CMPB_(CS_CC_EQ,r1,r2,i) +#define CMPB_LT(r1,r2,i) CMPB_(CS_CC_LT,r1,r2,i) +#define CMPB_LE(r1,r2,i) CMPB_(CS_CC_LE,r1,r2,i) +#define CMPB_ULT(r1,r2,i) CMPB_(CS_CC_ULT,r1,r2,i) +#define CMPB_ULE(r1,r2,i) CMPB_(CS_CC_ULE,r1,r2,i) +#define CMPB_SV(r1,r2,i) CMPB_(CS_CC_SV,r1,r2,i) +#define CMPB_OD(r1,r2,i) CMPB_(CS_CC_OD,r1,r2,i) +#define CMPB_TR(r1,r2,i) CMPB_(CS_CC_TR,r1,r2,i) +#define CMPB_NE(r1,r2,i) CMPB_(CS_CC_NE,r1,r2,i) +#define CMPB_GE(r1,r2,i) CMPB_(CS_CC_GE,r1,r2,i) +#define CMPB_GT(r1,r2,i) CMPB_(CS_CC_GT,r1,r2,i) +#define CMPB_UGE(r1,r2,i) CMPB_(CS_CC_UGE,r1,r2,i) +#define CMPB_UGT(r1,r2,i) CMPB_(CS_CC_UGT,r1,r2,i) +#define CMPB_NSV(r1,r2,i) CMPB_(CS_CC_NSV,r1,r2,i) +#define CMPB_EV(r1,r2,i) CMPB_(CS_CC_EV,r1,r2,i) +#define CMPB_N_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,1) +#define CMPB_N(r1,r2,i) CMPB_N_(CS_CC_NV,r1,r2,i) +#define CMPB_EQ_N(r1,r2,i) CMPB_N_(CS_CC_EQ,r1,r2,i) +#define CMPB_LT_N(r1,r2,i) CMPB_N_(CS_CC_LT,r1,r2,i) +#define CMPB_LE_N(r1,r2,i) CMPB_N_(CS_CC_LE,r1,r2,i) +#define CMPB_ULT_N(r1,r2,i) CMPB_N_(CS_CC_ULT,r1,r2,i) +#define CMPB_ULE_N(r1,r2,i) CMPB_N_(CS_CC_ULE,r1,r2,i) +#define CMPB_SV_N(r1,r2,i) CMPB_N_(CS_CC_SV,r1,r2,i) +#define CMPB_OD_N(r1,r2,i) CMPB_N_(CS_CC_OD,r1,r2,i) +#define CMPB_TR_N(r1,r2,i) CMPB_N_(CS_CC_TR,r1,r2,i) +#define CMPB_NE_N(r1,r2,i) CMPB_N_(CS_CC_NE,r1,r2,i) +#define CMPB_GE_N(r1,r2,i) CMPB_N_(CS_CC_GE,r1,r2,i) +#define CMPB_GT_N(r1,r2,i) CMPB_N_(CS_CC_GT,r1,r2,i) +#define CMPB_UGE_N(r1,r2,i) CMPB_N_(CS_CC_UGE,r1,r2,i) +#define CMPB_UGT_N(r1,r2,i) CMPB_N_(CS_CC_UGT,r1,r2,i) +#define CMPB_NSV_N(r1,r2,i) CMPB_N_(CS_CC_NSV,r1,r2,i) +#define CMPB_EV_N(r1,r2,i) CMPB_N_(CS_CC_EV,r1,r2,i) +#define CMPCLR_(c,r1,r2,i) f8(0x2,r2,r1,c,2,0,0,2,0,i) +#define CMPCLR(r1,r2,i) CMPCLR_(CS_CC_NV,r1,r2,i) +#define CMPCLR_EQ(r1,r2,i) CMPCLR_(CS_CC_EQ,r1,r2,i) +#define CMPCLR_LT(r1,r2,i) CMPCLR_(CS_CC_LT,r1,r2,i) +#define CMPCLR_LE(r1,r2,i) CMPCLR_(CS_CC_LE,r1,r2,i) +#define CMPCLR_ULT(r1,r2,i) CMPCLR_(CS_CC_ULT,r1,r2,i) +#define CMPCLR_ULE(r1,r2,i) CMPCLR_(CS_CC_ULE,r1,r2,i) +#define CMPCLR_SV(r1,r2,i) CMPCLR_(CS_CC_SV,r1,r2,i) +#define CMPCLR_OD(r1,r2,i) CMPCLR_(CS_CC_OD,r1,r2,i) +#define CMPCLR_TR(r1,r2,i) CMPCLR_(CS_CC_TR,r1,r2,i) +#define CMPCLR_NE(r1,r2,i) CMPCLR_(CS_CC_NE,r1,r2,i) +#define CMPCLR_GE(r1,r2,i) CMPCLR_(CS_CC_GE,r1,r2,i) +#define CMPCLR_GT(r1,r2,i) CMPCLR_(CS_CC_GT,r1,r2,i) +#define CMPCLR_UGE(r1,r2,i) CMPCLR_(CS_CC_UGE,r1,r2,i) +#define CMPCLR_UGT(r1,r2,i) CMPCLR_(CS_CC_UGT,r1,r2,i) +#define CMPCLR_NSV(r1,r2,i) CMPCLR_(CS_CC_NSV,r1,r2,i) +#define CMPCLR_EV(r1,r2,i) CMPCLR_(CS_CC_EV,r1,r2,i) +#define CMPIB_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,0) +#define CMPIB_NONE(i,r,t) CMPIB_(CS_CC_NV,i,r,t) +#define CMPIB_EQ(i,r,t) CMPIB_(CS_CC_EQ,i,r,t) +#define CMPIB_LT(i,r,t) CMPIB_(CS_CC_LT,i,r,t) +#define CMPIB_LE(i,r,t) CMPIB_(CS_CC_LE,i,r,t) +#define CMPIB_ULT(i,r,t) CMPIB_(CS_CC_ULT,i,r,t) +#define CMPIB_ULE(i,r,t) CMPIB_(CS_CC_ULE,i,r,t) +#define CMPIB_SV(i,r,t) CMPIB_(CS_CC_SV,i,r,t) +#define CMPIB_OD(i,r,t) CMPIB_(CS_CC_OD,i,r,t) +#define CMPIB(i,r,t) CMPIB_(CS_CC_TR,i,r,t) +#define CMPIB_NE(i,r,t) CMPIB_(CS_CC_NE,i,r,t) +#define CMPIB_GE(i,r,t) CMPIB_(CS_CC_GE,i,r,t) +#define CMPIB_GT(i,r,t) CMPIB_(CS_CC_GT,i,r,t) +#define CMPIB_UGE(i,r,t) CMPIB_(CS_CC_UGE,i,r,t) +#define CMPIB_UGT(i,r,t) CMPIB_(CS_CC_UGT,i,r,t) +#define CMPIB_NSV(i,r,t) CMPIB_(CS_CC_NSV,i,r,t) +#define CMPIB_EV(i,r,t) CMPIB_(CS_CC_EV,i,r,t) +#define CMPIB_N_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,1) +#define CMPIB_NONE_N(i,r,t) CMPIB_N_(CS_CC_NV,i,r,t) +#define CMPIB_EQ_N(i,r,t) CMPIB_N_(CS_CC_EQ,i,r,t) +#define CMPIB_LT_N(i,r,t) CMPIB_N_(CS_CC_LT,i,r,t) +#define CMPIB_LE_N(i,r,t) CMPIB_N_(CS_CC_LE,i,r,t) +#define CMPIB_ULT_N(i,r,t) CMPIB_N_(CS_CC_ULT,i,r,t) +#define CMPIB_ULE_N(i,r,t) CMPIB_N_(CS_CC_ULE,i,r,t) +#define CMPIB_SV_N(i,r,t) CMPIB_N_(CS_CC_SV,i,r,t) +#define CMPIB_OD_N(i,r,t) CMPIB_N_(CS_CC_OD,i,r,t) +#define CMPIB_N(i,r,t) CMPIB_N_(CS_CC_TR,i,r,t) +#define CMPIB_NE_N(i,r,t) CMPIB_N_(CS_CC_NE,i,r,t) +#define CMPIB_GE_N(i,r,t) CMPIB_N_(CS_CC_GE,i,r,t) +#define CMPIB_GT_N(i,r,t) CMPIB_N_(CS_CC_GT,i,r,t) +#define CMPIB_UGE_N(i,r,t) CMPIB_N_(CS_CC_UGE,i,r,t) +#define CMPIB_UGT_N(i,r,t) CMPIB_N_(CS_CC_UGT,i,r,t) +#define CMPIB_NSV_N(i,r,t) CMPIB_N_(CS_CC_NSV,i,r,t) +#define CMPIB_EV_N(i,r,t) CMPIB_N_(CS_CC_EV,i,r,t) +#define CMPICLR_(c,i,r,t) f9(0x24,r,t,c,0,i) +#define CMPICLR(i,r,t) CMPICLR_(CS_CC_NV,i,r,t) +#define CMPICLR_EQ(i,r,t) CMPICLR_(CS_CC_EQ,i,r,t) +#define CMPICLR_LT(i,r,t) CMPICLR_(CS_CC_LT,i,r,t) +#define CMPICLR_LE(i,r,t) CMPICLR_(CS_CC_LE,i,r,t) +#define CMPICLR_ULT(i,r,t) CMPICLR_(CS_CC_ULT,i,r,t) +#define CMPICLR_ULE(i,r,t) CMPICLR_(CS_CC_ULE,i,r,t) +#define CMPICLR_SV(i,r,t) CMPICLR_(CS_CC_SV,i,r,t) +#define CMPICLR_OD(i,r,t) CMPICLR_(CS_CC_OD,i,r,t) +#define CMPICLR_TR(i,r,t) CMPICLR_(CS_CC_TR,i,r,t) +#define CMPICLR_NE(i,r,t) CMPICLR_(CS_CC_NE,i,r,t) +#define CMPICLR_GE(i,r,t) CMPICLR_(CS_CC_GE,i,r,t) +#define CMPICLR_GT(i,r,t) CMPICLR_(CS_CC_GT,i,r,t) +#define CMPICLR_UGE(i,r,t) CMPICLR_(CS_CC_UGE,i,r,t) +#define CMPICLR_UGT(i,r,t) CMPICLR_(CS_CC_UGT,i,r,t) +#define CMPICLR_NSV(i,r,t) CMPICLR_(CS_CC_NSV,i,r,t) +#define CMPICLR_EV(i,r,t) CMPICLR_(CS_CC_EV,i,r,t) +#define COPR(u,s) f38(0x0c,s,u,0) +#define UI_CF_NONE 0 /* never */ +#define UI_CF_SBZ 2 /* some byte zero */ +#define UI_CF_SHZ 3 /* some halfword zero */ +#define UI_CF_SDC 4 /* some digit carry */ +#define UI_CF_SBC 6 /* some byte carry */ +#define UI_CF_SHC 7 /* some halfword carry */ +#define UI_TR_SHC 8 /* always */ +#define UI_CF_NBZ 10 /* no byte zero */ +#define UI_CF_NHZ 11 /* no halfword zero */ +#define UI_CF_NDC 12 /* no digit carry */ +#define UI_CF_NBC 14 /* no byte carry */ +#define UI_CF_NHC 15 /* no halfword carry */ +#define DCOR_(e1,cf,r,t) f8(0x2,r,0,cf,2,1,1,e1,0,t) +#define DCOR(r,t) DCOR_(2,UI_CF_NONE,r,t) +#define DCOR_I(r,t) DCOR_(3,UI_CF_NONE,r,t) +#define SED_C_NEVER 0 /* never */ +#define SED_C_EQ 1 /* all bits 0 */ +#define SED_C_LT 2 /* lefmost bits 1 */ +#define SED_C_OD 3 /* rightmost bit 1 */ +#define SED_C_TR 4 /* always */ +#define SED_C_NE 5 /* some bit 1 */ +#define SED_C_GE 6 /* lefmost bits 1 */ +#define SED_C_EV 7 /* rightmost bit 0 */ +#define DEPW(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,1,0,len) +#define DEPW_Z(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,0,0,len) +#define DEPWR(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,1,31-(pos),len) +#define DEPWR_Z(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,0,31-(pos),len) +#define SHLWI(r,sa,t) DEPWR_Z(r,31-(sa),32-(sa),t) +#define DEPWI(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,1,0,len) +#define DEPWI_Z(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,0,0,len) +#define DEPWRI(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,1,31-(pos),len) +#define DEPWRI_Z(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,0,31-(pos),len) +#define DIAG(i) f28(0x5,i) +#define DS(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,1,0,0,1,0,t) +#define EXTRW(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,1,0,0,0,len) +#define EXTRW_U(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,0,0,0,0,len) +#define EXTRWR(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,1,pos,len) +#define SHRWI(r,sa,t) EXTRWR(r,31-(sa),32-(sa),t) +#define EXTRWR_U(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,0,pos,len) +#define SHRWI_U(r,sa,t) EXTRWR_U(r,31-(sa),32-(sa),t) +#define FDC(x,s,b) f24(0x1,b,x,s,0x4a,0,0) +#define FDC_M(x,s,b) f24(0x1,b,x,s,0x4a,1,0) +#define FDCI(i,s,b) f25(0x1,b,i,s,0xca,0,0) +#define FDCE(x,s,b) f24(0x1,b,x,s,0x4b,0,0) +#define FDCE_M(x,s,b) f24(0x1,b,x,s,0x4b,1,0) +#define FIC(x,s,b) f26(0x1,b,x,s,0xa,0,0) +#define FIC_M(x,s,b) f26(0x1,b,x,s,0xa,1,0) +#define FICI(x,s,b) f25(0x1,b,x,s,0x4f,0,0) +#define FICI_M(x,s,b) f25(0x1,b,x,s,0x4f,1,0) +#define FICE(x,s,b) f26(0x1,b,x,s,0xb,0,0) +#define FICE_M(x,s,b) f26(0x1,b,x,s,0xb,1,0) +#define HADD_(c,r1,r2,t) f8(0x2,r2,r1,0,0,1,1,c,0,t) +#define HADD(r1,r2,t) HADD_(3,r1,r2,t) +#define HADD_SS(r1,r2,t) HADD_(1,r1,r2,t) +#define HADD_US(r1,r2,t) HADD_(0,r1,r2,t) +#define HAVG(r1,r2,t) f8(0x2,r2,r1,0,0,1,0,3,0,t) +#define HSHL(r,sa,t) f10(0x3e,0,r,1,0,0,2,sa,0,t) +#define HSHLADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,1,1,sa,0,t) +#define HSHR(r,sa,t) f10(0x3e,r,0,1,2,0,3,sa,0,t) +#define HSHR_U(r,sa,t) f10(0x3e,r,0,1,2,0,2,sa,0,t) +#define HSHRADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,0,1,sa,0,t) +#define HSUB_(c,r1,r2,t) f8(0x2,r2,r1,0,0,0,1,c,0,t) +#define HSUB(r1,r2,t) HSUB_(3,r1,r2,t) +#define HSUB_SS(r1,r2,t) HSUB_(1,r1,r2,t) +#define HSUB_US(r1,r2,t) HSUB_(0,r1,r2,t) +#define IDTLBT(r1,r2) f26(0x1,r2,r1,0,0x60,0,0) +#define IITLBT(r1,r2) f26(0x1,r2,r1,0,0x20,0,0) +#define LCI(x,s,b,t) f24(0x1,b,x,s,0x4c,0,t) +#define LDBL(i,b,t) f1(0x10,b,t,i) +#define LDB(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,0,0,t) +#define LDBI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,0,0,t) +#define LDCD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,5,0,t) +#define LDCDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,5,0,t) +#define LDCW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,7,0,t) +#define LDCWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,7,0,t) +#define LDDL(i,b,t) f3(0x14,b,t,i,0) +#define LDD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,3,0,t) +#define LDDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,3,0,t) +#define LDDA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,4,0,t) +#define LDDAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,4,0,t) +#define LDHL(i,b,t) f1(0x11,b,t,i) +#define LDH(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,1,0,t) +#define LDHI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,1,0,t) +#define LDIL(i,t) f7(0x8,t,i) +#define LDO(i,b,t) f1(0xd,b,t,i) +#define LDI(i,t) LDO(i,0,t) +#define LDSID(s,b,t) f30(0x0,b,0,s,0,0x85,t) +#define LDWL(i,b,t) f1(0x12,b,t,i) +#define LDWL_MB(i,b,t) f1(0x13,b,t,i) /* pre-dec or post-inc */ +#define LDWL_MA(i,b,t) f2(0x17,b,t,i,2)/* post-dec or pre-inc */ +#define LDW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,2,0,t) +#define LDWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,2,0,t) +#define LDWA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,6,0,t) +#define LDWAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,6,0,t) +#define LPA(x,s,b,t) f24(0x1,b,x,s,0x4d,0,t) +#define MFSP(s,t) f29(0x0,0,0,s,0x25,t) +#define MIXH_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,1,0,0,t) +#define MIXH_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,1,0,0,t) +#define MIXW_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,0,0,0,t) +#define MIXW_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,0,0,0,t) +#define MOVB_(c,r1,r2,i) f17(0x32,r2,r1,c,i,0) +#define MOVB(r1,r2,i) MOVB_(SED_C_NEVER,r1,r2,i) +#define MOVB_EQ(r1,r2,i) MOVB_(SED_C_EQ,r1,r2,i) +#define MOVB_LT(r1,r2,i) MOVB_(SED_C_LT,r1,r2,i) +#define MOVB_OD(r1,r2,i) MOVB_(SED_C_OD,r1,r2,i) +#define MOVB_TR(r1,r2,i) MOVB_(SED_C_TR,r1,r2,i) +#define MOVB_NE(r1,r2,i) MOVB_(SED_C_NE,r1,r2,i) +#define MOVB_GE(r1,r2,i) MOVB_(SED_C_GE,r1,r2,i) +#define MOVB_EV(r1,r2,i) MOVB_(SED_C_EV,r1,r2,i) +#define MOVIB_(c,r,i,t) f17x(0x33,r,i,c,t,0) +#define MOVIB(i,r,t) MOVIB_(SED_C_NEVER,i,r,t) +#define MOVIB_EQ(i,r,t) MOVIB_(SED_C_EQ,i,r,t) +#define MOVIB_LT(i,r,t) MOVIB_(SED_C_LT,i,r,t) +#define MOVIB_OD(i,r,t) MOVIB_(SED_C_OD,i,r,t) +#define MOVIB_TR(i,r,t) MOVIB_(SED_C_TR,i,r,t) +#define MOVIB_NE(i,r,t) MOVIB_(SED_C_NE,i,r,t) +#define MOVIB_GE(i,r,t) MOVIB_(SED_C_GE,i,r,t) +#define MOVIB_EV(i,r,t) MOVIB_(SED_C_EV,i,r,t) +#define MTCTL(r,t) f31(0x0,t,r,0,0xc2,0) +#define MTSAR(r) MTCTL(r,_CR11_REGNO) +#define MTSARCM(r) f31(0x0,0xb,r,0,0xc6,0) +#define MTSM(r) f33(0x0,0,r,0,0xc3,0) +#define MTSP(r,s) f29(0x0,0,r,s,0xc1,0) +#define OR_(c,r1,r2,t) f8(0x2,r2,r1,c,0,1,0,1,0,t) +#define OR(r1,r2,t) OR_(LOG_CC_NV,r1,r2,t) +#define NOP() OR(_R0_REGNO,_R0_REGNO,_R0_REGNO) +#define COPY(r,t) OR(r,0,t) +#define PDC(x,s,b) f24(0x1,b,x,s,0x4e,0,0) +#define PDTLB(x,s,b) f24(0x1,b,x,s,0x48,0,0) +#define PDTLB_L(x,s,b) f24(0x1,b,x,s,0x58,0,0) +#define PDTLBE(x,s,b) f24(0x1,b,x,s,0x49,0,0) +#define PERMH(c,r,t) f10(0x3e,r,r,0,(c)&3,0,((c)>>2)&3,(((c)>>2)&6)|(((c)>>6)&3),0,t) +#define PITBL(x,s,b) f26(0x1,b,x,s,0x08,0,0) +#define PITBL_L(x,s,b) f26(0x1,b,x,s,0x18,0,0) +#define PITBLE(x,s,b) f26(0x1,b,x,s,0x09,0,0) +#define POPBTS(i) f23(0x3a,0,0,2,0,i,1,0,1) +#define PROBE_R(s,b,r,t) f24(0x1,b,r,s,0x46,0,t) +#define PROBE_W(s,b,r,t) f24(0x1,b,r,s,0x47,0,t) +#define PROBEI_R(s,b,i,t) f24(0x1,b,i,s,0x46,0,t) +#define PROBEI_W(s,b,i,t) f24(0x1,b,i,s,0x47,0,t) +#define PUSHBTS(r) f23(0x3a,0,r,2,0,0,0,0,1) +#define PUSHNOM() f23(0x3a,0,0,2,0,0,0,0,1) +#define RFI() f33(0x0,0,0,0,0x60,0) +#define RFI_R() f33(0x0,0,0,0,0x65,0) +#define RSM(i,t) f33(0x0,((i)&0x3e0)>>5,(i)&0x1f,0,0x73,t) +#define SHLADD_(e,cf,r1,sa,r2,t) f8(0x2,r2,r1,cf,e,1,0,sa,0,t) +#define SHLADD(r1,sa,r2,t) SHLADD_(1,ADD_CF_NV,r1,sa,r2,t) +#define SHLADD_L(r1,sa,r2,t) SHLADD_(2,ADD_CF_NV,r1,sa,r2,t) +#define SHLADD_TSV(r1,sa,r2,t) SHLADD_(3,ADD_CF_NV,r1,sa,r2,t) +#define SHRPD(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,1,0,t) +#define SHRPDI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,(63-(sa))>>5,1,(63-(sa))&0x1f,t) +#define SHRPW(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,0,0,t) +#define SHRPWI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,1,0,31-(sa),t) +#define SPOP0(sf,so) f34(0x4,(so)>>5,0,sf,0,(so)&0x1f) +#define SPOP1(sf,so,t) f35(0x4,so,1,sf,0,t) +#define SPOP2(sf,so,r) f36(0x4,r,(so)>>5,2,sf,0,(so)&0x1f) +#define SPOP3(sf,so,r1,r2) f37(0x4,r2,r1,(so)>>5,3,sf,0,(so)&0x1f) +#define SSM(i,t) f33(0x00,(i)>>5,(i)&0x1f,0,0x6b,t) +#define STBL(r,i,b) f1(0x18,b,r,i) +#define STBI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x8,0,i) +#define STDL(r,i,b) f3(0x1c,b,r,i,0) +#define STDI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xc,0,i) +#define STDA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xf,0,i) +#define STHL(r,i,b) f1(0x19,b,r,i) +#define STHI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x9,0,i) +#define STWL(r,i,b) f1(0x1a,b,r,i) +#define STWL_MA(r,i,b) f1(0x1b,b,r,i) /* pre-dec or post-inc */ +#define STWL_MB(r,i,b) f2(0x1f,b,r,i,2)/* post-dec or pre-inc */ +#define STWI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xa,0,i) +#define STWA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xe,0,i) +#define SUB_(e1,e2,cf,r1,r2,t) f8(0x2,r2,r1,cf,e1,0,e2,0,0,t) +#define SUB(r1,r2,t) SUB_(1,0,CS_CC_NV,r1,r2,t) +#define SUB_B(r1,r2,t) SUB_(1,1,CS_CC_NV,r1,r2,t) +#define SUB_SV(r1,r2,t) SUB_(1,0,CS_CC_SV,r1,r2,t) +#define SUB_NSV(r1,r2,t) SUB_(1,0,CS_CC_NSV,r1,r2,t) +/* actually, rsbi */ +#define SUBI_(e1,cf,i,r,t) f9(0x25,r,t,cf,e1,i) +#define SUBI(i,r,t) SUBI_(0,ADD_CF_NV,i,r,t) +#define SYNC() f33(0x0,0,0,0,0x20,0) +#define SYNCDMA() f33(0x0,0,1<<4,0,0x20,0) +#define UADDCM(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,2,0,1,2,0,t) +#define UXOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,1,2,0,t) +#define XOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,0,2,0,t) +#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 comr(r0,r1) UADDCM(_R0_REGNO,r1,r0) +#define negr(r0,r1) SUB(_R0_REGNO,r1,r0) +#define extr_c(r0,r1) EXTRWR(r1,31,8,r0) +#define extr_uc(r0,r1) EXTRWR_U(r1,31,8,r0) +#define extr_s(r0,r1) EXTRWR(r1,31,16,r0) +#define extr_us(r0,r1) EXTRWR_U(r1,31,16,r0) +#if __BYTE_ORDER == __BIG_ENDIAN +# define htonr(r0,r1) movr(r0,r1) +#else +# error need htonr implementation +#endif +#define addr(r0,r1,r2) ADD(r1,r2,r0) +#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) addr(r0,r1,r2) +#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) ADD_C(r1,r2,r0) +#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(r1,r2,r0) +#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) subr(r0,r1,r2) +#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) SUB_B(r1,r2,r0) +#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); +static long long __llmul(int, int); +#define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3) +static void _qmulr(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0) +static void _qmuli(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +#define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3) +static void _qmulr_u(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0) +static void _qmuli_u(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +static int __idiv(int, int); +#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); +static unsigned int __udiv(unsigned int, unsigned int); +#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); +static int __irem(int, int); +#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); +static unsigned int __urem(unsigned int, unsigned int); +#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); +static idiv_t __idivrem(int, int); +#define qdivr(r0,r1,r2,r3) _qdivr(_jit,r0,r1,r2,r3) +static void _qdivr(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0) +static void _qdivi(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +static udiv_t __udivrem(unsigned int, unsigned int); +#define qdivr_u(r0,r1,r2,r3) _qdivr_u(_jit,r0,r1,r2,r3) +static void _qdivr_u(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0) +static void _qdivi_u(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +#define andr(r0,r1,r2) AND(r1,r2,r0) +#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(r1,r2,r0) +#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(r1,r2,r0) +#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) _lshr(_jit,r0,r1,r2) +static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lshi(r0,r1,i0) SHLWI(r1,i0,r0) +#define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2) +static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define rshi(r0,r1,i0) SHRWI(r1,i0,r0) +#define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2) +static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define rshi_u(r0,r1,i0) SHRWI_U(r1,i0,r0) +#define cmpr(c,r0,r1,r2) _cmpr(_jit,c,r0,r1,r2) +static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define cmpi(c,ci,r0,r1,i0) _cmpi(_jit,c,ci,r0,r1,i0) +static void _cmpi(jit_state_t*,jit_word_t,jit_word_t, + jit_int32_t,jit_int32_t,jit_word_t); +#define ltr(r0,r1,r2) cmpr(CS_CC_GE,r0,r1,r2) +#define lti(r0,r1,i0) cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0) +#define ltr_u(r0,r1,r2) cmpr(CS_CC_UGE,r0,r1,r2) +#define lti_u(r0,r1,i0) cmpi(CS_CC_UGE,CS_CC_ULE,r0,r1,i0) +#define ler(r0,r1,r2) cmpr(CS_CC_GT,r0,r1,r2) +#define lei(r0,r1,i0) cmpi(CS_CC_GT,CS_CC_LT,r0,r1,i0) +#define ler_u(r0,r1,r2) cmpr(CS_CC_UGT,r0,r1,r2) +#define lei_u(r0,r1,i0) cmpi(CS_CC_UGT,CS_CC_ULT,r0,r1,i0) +#define eqr(r0,r1,r2) cmpr(CS_CC_NE,r0,r1,r2) +#define eqi(r0,r1,i0) cmpi(CS_CC_NE,CS_CC_NE,r0,r1,i0) +#define ger(r0,r1,r2) cmpr(CS_CC_LT,r0,r1,r2) +#define gei(r0,r1,i0) cmpi(CS_CC_LT,CS_CC_GT,r0,r1,i0) +#define ger_u(r0,r1,r2) cmpr(CS_CC_ULT,r0,r1,r2) +#define gei_u(r0,r1,i0) cmpi(CS_CC_ULT,CS_CC_UGT,r0,r1,i0) +#define gtr(r0,r1,r2) cmpr(CS_CC_LE,r0,r1,r2) +#define gti(r0,r1,i0) cmpi(CS_CC_LE,CS_CC_GE,r0,r1,i0) +#define gtr_u(r0,r1,r2) cmpr(CS_CC_ULE,r0,r1,r2) +#define gti_u(r0,r1,i0) cmpi(CS_CC_ULE,CS_CC_UGE,r0,r1,i0) +#define ner(r0,r1,r2) cmpr(CS_CC_EQ,r0,r1,r2) +#define nei(r0,r1,i0) cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0) +#define ldr_c(r0,r1) _ldr_c(_jit,r0,r1) +static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t); +#define ldi_c(r0,i0) _ldi_c(_jit,r0,i0) +static void _ldi_c(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 ldr_uc(r0,r1) LDBI(_R0_REGNO,r1,r0) +#define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0) +static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxr_uc(r0,r1,r2) LDB(r2,r1,r0) +#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 ldr_s(r0,r1) _ldr_s(_jit,r0,r1) +static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t); +#define ldi_s(r0,i0) _ldi_s(_jit,r0,i0) +static void _ldi_s(jit_state_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 ldr_us(r0,r1) LDHI(_R0_REGNO,r1,r0) +#define ldi_us(r0,i0) _ldi_us(_jit,r0,i0) +static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxr_us(r0,r1,r2) LDH(r2,r1,r0) +#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 ldr_i(r0,r1) ldr_ui(r0,r1) +#define ldr_ui(r0,r1) LDWI(_R0_REGNO,r1,r0) +#define ldi_i(r0,i0) ldi_ui(r0,i0) +#define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0) +static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxr_i(r0,r1,r2) ldxr_ui(r0,r1,r2) +#define ldxr_ui(r0,r1,r2) LDW(r2,r1,r0) +#define ldxi(r0,r1,i0) ldxi_ui(r0,r1,i0) +#define ldxi_i(r0,r1,i0) ldxi_ui(r0,r1,i0) +#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 str_c(r0,r1) STBI(r1,_R0_REGNO,r0) +#define sti_c(i0,r0) _sti_c(_jit,i0,r0) +static void _sti_c(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 str_s(r0,r1) STHI(r1,_R0_REGNO,r0) +#define sti_s(i0,r0) _sti_s(_jit,i0,r0) +static void _sti_s(jit_state_t*,jit_word_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 str_i(r0,r1) STWI(r1,_R0_REGNO,r0) +#define sti_i(i0,r0) _sti_i(_jit,i0,r0) +static void _sti_i(jit_state_t*,jit_word_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(i0,r0,r1) stxi_i(i0,r0,r1) +#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 bcmpr(c,i0,r0,r1) _bcmpr(_jit,c,i0,r0,r1) +static jit_word_t _bcmpr(jit_state_t*,jit_word_t, + jit_word_t,jit_int32_t,jit_int32_t); +#define bcmpi(c,ci,i0,r0,i1) _bcmpi(_jit,c,ci,i0,r0,i1) +static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t, + jit_word_t,jit_int32_t,jit_word_t); +#define bltr(i0,r0,r1) bcmpr(CS_CC_LT,i0,r0,r1) +#define blti(i0,r0,r1) bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1) +#define bltr_u(i0,r0,r1) bcmpr(CS_CC_ULT,i0,r0,r1) +#define blti_u(i0,r0,r1) bcmpi(CS_CC_ULT,CS_CC_UGT,i0,r0,r1) +#define bler(i0,r0,r1) bcmpr(CS_CC_LE,i0,r0,r1) +#define blei(i0,r0,r1) bcmpi(CS_CC_LE,CS_CC_GE,i0,r0,r1) +#define bler_u(i0,r0,r1) bcmpr(CS_CC_ULE,i0,r0,r1) +#define blei_u(i0,r0,r1) bcmpi(CS_CC_ULE,CS_CC_UGE,i0,r0,r1) +#define beqr(i0,r0,r1) bcmpr(CS_CC_EQ,i0,r0,r1) +#define beqi(i0,r0,r1) bcmpi(CS_CC_EQ,CS_CC_EQ,i0,r0,r1) +#define bger(i0,r0,r1) bcmpr(CS_CC_GE,i0,r0,r1) +#define bgei(i0,r0,r1) bcmpi(CS_CC_GE,CS_CC_LE,i0,r0,r1) +#define bger_u(i0,r0,r1) bcmpr(CS_CC_UGE,i0,r0,r1) +#define bgei_u(i0,r0,r1) bcmpi(CS_CC_UGE,CS_CC_ULE,i0,r0,r1) +#define bgtr(i0,r0,r1) bcmpr(CS_CC_GT,i0,r0,r1) +#define bgti(i0,r0,r1) bcmpi(CS_CC_GT,CS_CC_LT,i0,r0,r1) +#define bgtr_u(i0,r0,r1) bcmpr(CS_CC_UGT,i0,r0,r1) +#define bgti_u(i0,r0,r1) bcmpi(CS_CC_UGT,CS_CC_ULT,i0,r0,r1) +#define bner(i0,r0,r1) bcmpr(CS_CC_NE,i0,r0,r1) +#define bnei(i0,r0,r1) bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1) +#define bmxr(c,i0,r0,r1) _bmxr(_jit,c,i0,r0,r1) +static jit_word_t _bmxr(jit_state_t*,jit_bool_t, + jit_word_t,jit_int32_t,jit_int32_t); +#define bmxi(c,i0,r0,i1) _bmxi(_jit,c,i0,r0,i1) +static jit_word_t _bmxi(jit_state_t*,jit_bool_t, + jit_word_t,jit_int32_t,jit_word_t); +#define bmcr(r0,r1,r2) bmxr(0,r0,r1,r2) +#define bmci(r0,r1,r2) bmxi(0,r0,r1,r2) +#define bmsr(r0,r1,r2) bmxr(1,r0,r1,r2) +#define bmsi(r0,r1,r2) bmxi(1,r0,r1,r2) +#define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1) +static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1) +static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1) +static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1) +static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1) +static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1) +static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1) +static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1) +static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1) +static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1) +static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1) +static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1) +static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1) +static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1) +static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1) +static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1) +static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_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(i,l) _patch_at(_jit,i,l) +static void _patch_at(jit_state_t*,jit_word_t,jit_word_t); +#endif + +#if CODE +/* from binutils bfd/libhppa.h */ +static inline int +sign_extend (int x, int len) +{ + int signbit = (1 << (len - 1)); + int mask = (signbit << 1) - 1; + return ((x & mask) ^ signbit) - signbit; +} + +static inline int +sign_unext (int x, int len) +{ + int len_ones; + + len_ones = (1 << len) - 1; + + return x & len_ones; +} + +static inline int +low_sign_unext (int x, int len) +{ + int temp; + int sign; + + sign = (x >> (len-1)) & 1; + + temp = sign_unext (x, len-1); + + return (temp << 1) | sign; +} + +static inline int +re_assemble_3 (int as3) +{ + return (( (as3 & 4) << (13-2)) + | ((as3 & 3) << (13+1))); +} + +static inline int +re_assemble_12 (int as12) +{ + return (( (as12 & 0x800) >> 11) + | ((as12 & 0x400) >> (10 - 2)) + | ((as12 & 0x3ff) << (1 + 2))); +} + +static inline int +re_assemble_16 (int as16) +{ + int s, t; + + /* Unusual 16-bit encoding, for wide mode only. */ + t = (as16 << 1) & 0xffff; + s = (as16 & 0x8000); + return (t ^ s ^ (s >> 1)) | (s >> 15); +} + +static inline int +re_assemble_17 (int as17) +{ + return (( (as17 & 0x10000) >> 16) + | ((as17 & 0x0f800) << (16 - 11)) + | ((as17 & 0x00400) >> (10 - 2)) + | ((as17 & 0x003ff) << (1 + 2))); +} + +static inline int +re_assemble_21 (int as21) +{ + return (( (as21 & 0x100000) >> 20) + | ((as21 & 0x0ffe00) >> 8) + | ((as21 & 0x000180) << 7) + | ((as21 & 0x00007c) << 14) + | ((as21 & 0x000003) << 12)); +} + +static inline int +re_assemble_22 (int as22) +{ + return (( (as22 & 0x200000) >> 21) + | ((as22 & 0x1f0000) << (21 - 16)) + | ((as22 & 0x00f800) << (16 - 11)) + | ((as22 & 0x000400) >> (10 - 2)) + | ((as22 & 0x0003ff) << (1 + 2))); +} + +static void +_f1(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t t, jit_int32_t i) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(t & ~0x1f)); + assert(i >= -8192 && i <= 8191); + ii((o<<26)|(b<<21)|(t<<16)|(re_assemble_16(i))); +} + +static void +_f2(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(t & ~0x1f)); + assert(i >= -32768 && i <= 32767); + assert(!(j & ~0x3)); + ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i))); +} + +static void +_f3(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(t & ~0x1f)); + assert(i >= -32768 && i <= 32767); + assert(!(j & ~0x1)); + ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i))); +} + +static void +_f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, + jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y, + jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(s & ~0x3)); + assert(!(u & ~0x1)); + assert(!(y & ~0x1)); + assert(!(c & ~0x3)); + assert(!(z & ~0xf)); + assert(!(m & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(u<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t); +} + +static void +_f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, + jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y, + jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(s & ~0x3)); + assert(!(a & ~0x1)); + assert(!(y & ~0x1)); + assert(!(c & ~0x3)); + assert(!(z & ~0xf)); + assert(!(m & ~0x1)); + assert(i >= -16 && i <= 15); + ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)| + (s<<14)|(a<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t); +} + +static void +_f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, + jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x, + jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(s & ~0x3)); + assert(!(a & ~0x1)); + assert(!(x & ~0x1)); + assert(!(c & ~0x3)); + assert(!(y & ~0xf)); + assert(!(m & ~0x1)); + assert(i >= -16 && i <= 15); + ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(a<<13)| + (x<<12)|(c<<10)|(y<<6)|(m<<5)|low_sign_unext(i,5)); +} + +static void +_f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(i & 0x7ff)); + ii((o<<26)|(r<<21)|re_assemble_21(i>>11)); +} + +static void +_f8(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r2, jit_int32_t r1, jit_int32_t cf, + jit_int32_t e1, jit_int32_t x, jit_int32_t e2, + jit_int32_t e3, jit_int32_t d, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r2 & ~0x1f)); + assert(!(r1 & ~0x1f)); + assert(!(cf & ~0xf)); + assert(!(e1 & ~0x3)); + assert(!(x & ~0x1)); + assert(!(e2 & ~0x3)); + assert(!(e3 & ~0x3)); + assert(!(d & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r2<<21)|(r1<<16)|(cf<<12)| + (e1<<10)|(x<<9)|(e2<<8)|(e3<<6)|(d<<5)|t); +} + +static void +_f9(jit_state_t *_jit, + jit_int32_t o, jit_int32_t r, jit_int32_t t, + jit_int32_t cf, jit_int32_t e1, jit_int32_t i) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(t & ~0x1f)); + assert(!(cf & ~0xf)); + assert(!(e1 & ~0x1)); + assert(i >= -2048 && i <= 2047); + ii((o<<26)|(r<<21)|(t<<16)|(cf<<12)|(e1<<11)|low_sign_unext(i,11)); +} + +static void +_f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2, + jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w, + jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r2 & ~0x1f)); + assert(!(r1 & ~0x1f)); + assert(!(u & ~0x1)); + assert(!(v & ~0x3)); + assert(!(w & ~0x1)); + assert(!(x & ~0x3)); + assert(!(sa & ~0xf)); + assert(!(y & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r2<<21)|(r1<<16)|(u<<15)| + (v<<13)|(w<<12)|(x<<10)|(sa<<6)|(y<<5)|t); +} + +static void +_f11(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x, + jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r1 & ~0x1f)); + assert(!(r2 & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(x & ~0x3)); + assert(!(y & ~0x1)); + assert(!(z & ~0x1)); + assert(!(u & ~0xf)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<11)|(y<<10)|(z<<9)|(u<<5)|t); +} + +static void +_f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, + jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se, + jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(t & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(x & ~0x3)); + assert(!(se & ~0x1)); + assert(!(y & ~0x1)); + assert(!(c1 & ~0x1)); + assert(!(z & ~0x7)); + assert(!((32-clen) & ~0x1f)); + ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(x<<11)| + (se<<10)|(y<<9)|(c1<<8)|(z<<5)|(32-clen)); +} + +static void +_f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t, + jit_int32_t r, jit_int32_t c, jit_int32_t x, + jit_int32_t nz, jit_int32_t c1, jit_int32_t clen) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(!(r & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(x & ~0x3)); + assert(!(nz & ~0x1)); + assert(!(c1 & ~0x1)); + assert(!((32-clen) & ~0x1f)); + ii((o<<26)|(t<<21)|(r<<16)|(c<<13)| + (x<<11)|(nz<<10)|(c1<<8)|(32-clen)); +} + +static void +_f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t, + jit_int32_t i, jit_int32_t c, jit_int32_t x, + jit_int32_t nz, jit_int32_t c1, jit_int32_t clen) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(i >= -16 && i <= 15); + assert(!(c & ~0x7)); + assert(!(x & ~0x3)); + assert(!(nz & ~0x1)); + assert(!((32-clen) & ~0x1f)); + ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)| + (c<<13)|(x<<11)|(nz<<10)|(c1<<8)|(32-clen)); +} + +static void +_f14(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x, + jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r1 & ~0x1f)); + assert(!(r2 & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(x & ~0x3)); + assert(!(cp & ~0x1)); + assert(!(y & ~0x1)); + assert(!(cpos & ~0x1f)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<12)|(cp<<11)|(y<<10)|(cpos<<5)|t); +} + +static void +_f15(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1, + jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(t & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(c1 & ~0x1)); + assert(!(p & ~0x1)); + assert(!(se & ~0x1)); + assert(!(pos & ~0x1f)); + assert(!((32-clen) & ~0x1f)); + ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(c1<<12)| + (p<<11)|(se<<10)|(pos<<5)|(32-clen)); +} + +static void +_f16(jit_state_t *_jit, jit_int32_t o, + jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1, + jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(!(r & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(c1 & ~0x1)); + assert(!(cp & ~0x1)); + assert(!(nz & ~0x1)); + assert(!(cpos & ~0x1f)); + assert(!((32-clen) & ~0x3f)); + ii((o<<26)|(t<<21)|(r<<16)|(c<<13)| + (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen)); +} + +static void +_f16x(jit_state_t *_jit, jit_int32_t o, + jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1, + jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(i >= -16 && i <= 15); + assert(!(c & ~0x7)); + assert(!(c1 & ~0x1)); + assert(!(cp & ~0x1)); + assert(!(nz & ~0x1)); + assert(!(cpos & ~0x1f)); + assert(!((32-clen) & ~0x3f)); + ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|(c<<13)| + (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen)); +} + +static void +_f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2, + jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(r2 & ~0x1f)); + assert(!(r1 & ~0x1f)); + assert(!(c & ~0x7)); + assert(i >= -2048 && i <= 2047); + assert(!(n & ~0x1)); + ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|re_assemble_12(i)|(n<<1)); +} + +static void +_f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, + jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(i >= -16 && i <= 15); + assert(!(c & ~0x7)); + assert(t >= -2048 && t <= 2047); + assert(!(n & ~0x1)); + ii((o<<26)|(r<<21)| + (low_sign_unext(i,5)<<16)|(c<<13)|re_assemble_12(t)|(n<<1)); +} + +static void +_f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p, + jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(p & ~0x1f)); + assert(!(r & ~0x1f)); + assert(!(c & ~0x1)); + assert(i >= -2048 && i <= 2047); + assert(!(n & ~0x1)); + ii((o<<26)|(p<<21)|(r<<16)|(c<<15)|(1<<14)|re_assemble_12(i)|(n<<1)); +} + +static void +_f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, + jit_int32_t s, jit_int32_t i, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(s & ~0x7)); + assert(i >= -65536 && i <= 65535); + assert(!(n & ~0x1)); + ii((o<<26)|(b<<21)|re_assemble_3(s)|re_assemble_17(i)|(n<<1)); +} + +static void +_f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t, + jit_int32_t i, jit_int32_t g, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(i >= -32768 && i <= 32767); + assert(!(g & ~0x7)); + assert(!(n & ~0x1)); + ii((o<<26)|(t<<21)|(g<<13)|re_assemble_17(i)|(n<<1)); +} + +static void +_f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t, + jit_int32_t x, jit_int32_t y, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(y & ~0x7)); + assert(!(n & ~0x1)); + ii((o<<26)|(t<<21)|(x<<16)|(y<<13)|(n<<1)); +} + +static void +_f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, + jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(x & ~0x7)); + assert(!(r & ~0x3f)); + assert(!(n & ~0x1)); + assert(!(p & ~0x1)); + ii((o<<26)|(b<<21)|(x<<13)|(1<<12)|(r<<2)|(n<<1)|p); +} + +static void +_f23(jit_state_t *_jit, jit_int32_t o, + jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d, + jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h) +{ + assert(!(o & ~0x3f)); + assert(!(a & ~0x1f)); + assert(!(b & ~0x1f)); + assert(!(c & ~0x7)); + assert(!(d & ~0x1)); + assert(!(e & ~0x1ff)); + assert(!(f & ~0x1)); + assert(!(g & ~0x1)); + assert(!(h & ~0x1)); + ii((o<<26)|(a<<21)|(b<<16)|(c<<13)|(d<<12)|(e<<3)|(f<<2)|(g<<1)|h); +} + +static void +_f24(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t x, jit_int32_t s, + jit_int32_t y, jit_int32_t m,jit_int32_t r) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(s & ~0x3)); + assert(!(y & ~0xff)); + assert(!(m & ~0x1)); + assert(!(r & ~0x1f)); + ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(y<<6)|(m<<5)|r); +} + +static void +_f25(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t i, jit_int32_t s, + jit_int32_t y, jit_int32_t m, jit_int32_t r) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(i >= -16 && i <= 15); + assert(!(s & ~0x3)); + assert(!(y & ~0xff)); + assert(!(m & ~0x1)); + assert(!(r & ~0x1f)); + ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(s<<14)|(y<<6)|(m<<5)|r); +} + +static void +_f26(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t x, jit_int32_t s, + jit_int32_t y, jit_int32_t m,jit_int32_t r) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(s & ~0x7)); + assert(!(y & ~0x7f)); + assert(!(m & ~0x1)); + assert(!(r & ~0x1f)); + ii((o<<26)|(b<<21)|(x<<16)|(s<<13)|(y<<6)|(m<<5)|r); +} + +static void +_f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j) +{ + assert(!(o & ~0x3f)); + assert(i >= -4096 && i < 4095); + assert(j >= -16 && j < 15); + ii((o<<26)|(i<<13)|j); +} + +static void +_f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i) +{ + assert(!(o & ~0x3f)); + assert(!(i & ~0x1ffffff)); + ii((o<<26)|i); +} + +static void +_f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, + jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(s & ~0x7)); + assert(!(y & ~0xff)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r<<21)|(x<<16)|re_assemble_3(s)|(y<<5)|t); +} + +static void +_f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r, + jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(r & ~0x1f)); + assert(!(s & ~0x3)); + assert(!(x & ~0x1)); + assert(!(y & ~0xff)); + assert(!(t & ~0x1f)); + ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(x<<13)|(y<<5)|t); +} + +static void +_f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t, + jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y) +{ + assert(!(o & ~0x3f)); + assert(!(t & ~0x1f)); + assert(!(r & ~0x1f)); + assert(!(v & ~0x1f)); + assert(!(x & ~0xff)); + assert(!(y & ~0x1f)); + ii((o<<26)|(t<<21)|(r<<16)|(v<<14)|(x<<5)|y); +} + +static void +_f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x, + jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u) +{ + assert(!(o & ~0x3f)); + assert(!(x & ~0x1f)); + assert(!(r & ~0x1f)); + assert(!(y & ~0x7)); + assert(!(z & ~0xff)); + assert(!(u & ~0x1f)); + ii((o<<26)|(x<<21)|(r<<16)|(y<<13)|(z<<5)|u); +} + +static void +_f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1, + jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2) +{ + assert(!(o & ~0x3f)); + assert(!(o1 & ~0x7fff)); + assert(!(x & ~0x3)); + assert(!(sf & ~0x7)); + assert(!(n & ~0x1)); + assert(!(o2 & ~0x1f)); + ii((o<<26)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2); +} + +static void +_f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op, + jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(op & ~0x7fff)); + assert(!(x & ~0x3)); + assert(!(sf & ~0x7)); + assert(!(n & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(op<<11)|(x<<9)|(sf<<6)|(n<<5)|t); +} + +static void +_f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1, + jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(o1 & ~0x3ff)); + assert(!(x & ~0x3)); + assert(!(sf & ~0x7)); + assert(!(n & ~0x1)); + assert(!(o2 & ~0x1f)); + ii((o<<26)|(r<<21)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2); +} + +static void +_f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2, + jit_int32_t r1, jit_int32_t o1, jit_int32_t x, + jit_int32_t sf, jit_int32_t n, jit_int32_t o2) +{ + assert(!(o & ~0x3f)); + assert(!(r2 & ~0x1f)); + assert(!(r1 & ~0x1f)); + assert(!(o1 & ~0x1f)); + assert(!(x & ~0x3)); + assert(!(sf & ~0x7)); + assert(!(n & ~0x1)); + assert(!(o2 & ~0x1f)); + ii((o<<26)|(r2<<21)|(r1<<16)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2); +} + +static void +_f38(jit_state_t *_jit, jit_int32_t o, + jit_int32_t s, jit_int32_t u, jit_int32_t n) +{ + assert(!(o & ~0x3f)); + assert(!(s & ~0x3fffff)); + assert(!(u & ~0x7)); + assert(!(n & ~0x1)); + ii((o<<26)|((s>>5)<<9)|(u<<6)|(n<<1)|(s&0x1f)); +} + +static void +_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (r0 != r1) + COPY(r1, r0); +} + +static void +_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + if (i0 >= -8192 && i0 <= 8191) + LDI(i0, r0); + else if (!(i0 & 0x7ff)) + LDIL(i0, r0); + else { + LDIL(i0 & ~0x7ff, r0); + LDO(i0 & 0x7ff, r0, r0); + } +} + +static jit_word_t +_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_word_t w; + w = _jit->pc.w; + LDIL(i0 & ~0x7ff, r0); + LDO(i0 & 0x7ff, r0, r0); + 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 >= -2048 && i0 <= 2047) + ADDI(i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + addr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_addci(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); + addcr(r0, r1, 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; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + addxr(r0, r1, 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; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + subr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_subci(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); + subcr(r0, r1, 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; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + subxr(r0, r1, 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 t0, t1; + t0 = jit_get_reg(jit_class_fpr); + t1 = jit_get_reg(jit_class_fpr); + stxi(alloca_offset - 8, _FP_REGNO, r1); + ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8); + stxi(alloca_offset - 8, _FP_REGNO, r2); + ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8); + XMPYU(rn(t0), rn(t1), rn(t0)); + stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0)); + ldxi(r0, _FP_REGNO, alloca_offset - 4); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + +static void +_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (r0 != r1) { + movi(r0, i0); + mulr(r0, r1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + mulr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static long long +__llmul(int u, int v) +{ + return ((long long)u * (long long)v); +} + +static void +_qmulr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + movr(_R26_REGNO, r2); + movr(_R25_REGNO, r3); + calli((jit_word_t)__llmul); + movr(r0, _R29_REGNO); + movr(r1, _R28_REGNO); +} + +static void +_qmuli(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + movr(_R26_REGNO, r2); + movi(_R25_REGNO, i0); + calli((jit_word_t)__llmul); + movr(r0, _R29_REGNO); + movr(r1, _R28_REGNO); +} + +static void +_qmulr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_fpr); + t1 = jit_get_reg(jit_class_fpr); + stxi(alloca_offset - 8, _FP_REGNO, r2); + ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8); + stxi(alloca_offset - 8, _FP_REGNO, r3); + ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8); + XMPYU(rn(t0), rn(t1), rn(t0)); + stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0)); + ldxi(r0, _FP_REGNO, alloca_offset - 4); + ldxi(r1, _FP_REGNO, alloca_offset - 8); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + +static void +_qmuli_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + qmulr_u(r0, r1, r2, rn(reg)); + jit_unget_reg(reg); +} + +static int +__idiv(int u, int v) +{ + return (u / v); +} + +static void +_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + movr(_R26_REGNO, r1); + movr(_R25_REGNO, r2); + calli((jit_word_t)__idiv); + movr(r0, _R28_REGNO); +} + +static void +_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + movr(_R26_REGNO, r1); + movi(_R25_REGNO, i0); + calli((jit_word_t)__idiv); + movr(r0, _R28_REGNO); +} + +static unsigned int +__udiv(unsigned int u, unsigned int v) +{ + return (u / v); +} + +static void +_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + movr(_R26_REGNO, r1); + movr(_R25_REGNO, r2); + calli((jit_word_t)__udiv); + movr(r0, _R28_REGNO); +} + +static void +_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + movr(_R26_REGNO, r1); + movi(_R25_REGNO, i0); + calli((jit_word_t)__udiv); + movr(r0, _R28_REGNO); +} + +static int +__irem(int u, int v) +{ + return (u % v); +} + +static void +_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + movr(_R26_REGNO, r1); + movr(_R25_REGNO, r2); + calli((jit_word_t)__irem); + movr(r0, _R28_REGNO); +} + +static void +_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + movr(_R26_REGNO, r1); + movi(_R25_REGNO, i0); + calli((jit_word_t)__irem); + movr(r0, _R28_REGNO); +} + +static unsigned int +__urem(unsigned int u, unsigned int v) +{ + return (u % v); +} + +static void +_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + movr(_R26_REGNO, r1); + movr(_R25_REGNO, r2); + calli((jit_word_t)__urem); + movr(r0, _R28_REGNO); +} + +static void +_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + movr(_R26_REGNO, r1); + movi(_R25_REGNO, i0); + calli((jit_word_t)__urem); + movr(r0, _R28_REGNO); +} + +static idiv_t +__idivrem(int u, int v) +{ + idiv_t div; + div.quo = u / v; + div.rem = u % v; + return (div); +} + +static void +_qdivr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + movr(_R26_REGNO, r2); + movr(_R25_REGNO, r3); + calli((jit_word_t)__idivrem); + movr(r0, _R28_REGNO); + movr(r1, _R29_REGNO); +} + +static void +_qdivi(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + movr(_R26_REGNO, r2); + movi(_R25_REGNO, i0); + calli((jit_word_t)__idivrem); + movr(r0, _R28_REGNO); + movr(r1, _R29_REGNO); +} + +static udiv_t +__udivrem(unsigned int u, unsigned int v) +{ + udiv_t div; + div.quo = u / v; + div.rem = u % v; + return (div); +} + +static void +_qdivr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + movr(_R26_REGNO, r2); + movr(_R25_REGNO, r3); + calli((jit_word_t)__udivrem); + movr(r0, _R28_REGNO); + movr(r1, _R29_REGNO); +} + +static void +_qdivi_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + movr(_R26_REGNO, r2); + movi(_R25_REGNO, i0); + calli((jit_word_t)__udivrem); + movr(r0, _R28_REGNO); + movr(r1, _R29_REGNO); +} + +static void +_andi(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); + 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; + 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; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + xorr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2) +{ + SUBI(0x1f, r2, _R1_REGNO); + MTSAR(_R1_REGNO); + DEPW_Z(r1, 32, r0); +} + +static void +_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2) +{ + SUBI(0x1f, r2, _R1_REGNO); + MTSAR(_R1_REGNO); + EXTRW(r1, 32, r0); +} + +static void +_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2) +{ + SUBI(0x1f, r2, _R1_REGNO); + MTSAR(_R1_REGNO); + EXTRW_U(r1, 32, r0); +} + +static void +_cmpr(jit_state_t *_jit, jit_word_t c, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CMPCLR_(c, r1, r2, r0); + LDI(1, r0); +} + +static void +_cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -16 && i0 <= 15) + CMPICLR_(ci, i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + CMPCLR_(c, r1, rn(reg), r0); + jit_unget_reg(reg); + } + LDI(1, r0); +} + +static void +_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + ldr_uc(r0, r1); + extr_c(r0, r0); +} + +static void +_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + ldi_uc(r0, i0); + extr_c(r0, r0); +} + +static void +_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + ldxr_uc(r0, r1, r2); + extr_c(r0, r0); +} + +static void +_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + ldxi_uc(r0, r1, i0); + extr_c(r0, r0); +} + +static void +_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -8182 && i0 <= 8191) + LDBL(i0, _R0_REGNO, r0); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + LDBL(sign_extend(i0, 11), rn(reg), r0); + 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; + if (i0 >= -16 && i0 <= 15) + LDBI(i0, r1, r0); + else if (i0 >= -8182 && i0 <= 8191) + LDBL(i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_uc(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + ldr_us(r0, r1); + extr_s(r0, r0); +} + +static void +_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + ldi_us(r0, i0); + extr_s(r0, r0); +} + +static void +_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + ldxr_us(r0, r1, r2); + extr_s(r0, r0); +} + +static void +_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + ldxi_us(r0, r1, i0); + extr_s(r0, r0); +} + +static void +_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + if (i0 >= -8182 && i0 <= 8191) + LDHL(i0, _R0_REGNO, r0); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + LDHL(sign_extend(i0, 11), rn(reg), r0); + 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; + if (i0 >= -16 && i0 <= 15) + LDHI(i0, r1, r0); + else if (i0 >= -8182 && i0 <= 8191) + LDHL(i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_us(r0, r1, 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; + if (i0 >= -8182 && i0 <= 8191) + LDWL(i0, _R0_REGNO, r0); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + LDWL(sign_extend(i0, 11), rn(reg), r0); + 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; + if (i0 >= -16 && i0 <= 15) + LDWI(i0, r1, r0); + else if (i0 >= -8182 && i0 <= 8191) + LDWL(i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_ui(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; + if (i0 >= -8182 && i0 <= 8191) + STBL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + STBL(r0, sign_extend(i0, 11), rn(reg)); + 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; + if (i0 >= -16 && i0 <= 15) + STBI(r1, i0, r0); + else if (i0 >= -8182 && i0 <= 8191) + STBL(r1, i0, r0); + else { + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_c(rn(reg), r1); + jit_unget_reg(reg); + } +} + +static void +_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + if (i0 >= -8182 && i0 <= 8191) + STHL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + STHL(r0, sign_extend(i0, 11), rn(reg)); + 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; + if (i0 >= -16 && i0 <= 15) + STHI(r1, i0, r0); + else if (i0 >= -8182 && i0 <= 8191) + STHL(r1, i0, r0); + else { + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_s(rn(reg), r1); + jit_unget_reg(reg); + } +} + +static void +_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) +{ + jit_int32_t reg; + if (i0 >= -8182 && i0 <= 8191) + STWL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + STWL(r0, sign_extend(i0, 11), rn(reg)); + 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; + if (i0 >= -16 && i0 <= 15) + STWI(r1, i0, r0); + else if (i0 >= -8182 && i0 <= 8191) + STWL(r1, i0, r0); + else { + reg = jit_get_reg(jit_class_gpr); + addi(rn(reg), r0, i0); + str_i(rn(reg), r1); + jit_unget_reg(reg); + } +} + +static jit_word_t +_bcmpr(jit_state_t *_jit, jit_word_t c, + jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + w = _jit->pc.w; + CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2); + NOP(); + return (w); +} + +static jit_word_t +_bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci, + jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t w; + jit_int32_t reg; + if (i1 >= -16 && i1 <= 15) { + w = _jit->pc.w; + CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = _jit->pc.w; + CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2); + jit_unget_reg(reg); + } + NOP(); + return (w); +} + +static jit_word_t +_bmxr(jit_state_t *_jit, jit_bool_t c, + 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); + w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bmxi(jit_state_t *_jit, jit_bool_t c, + 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)); + w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + w = _jit->pc.w; + ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2); + NOP(); + return (w); +} + +static jit_word_t +_boaddi(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 >= -16 && i1 <= 15) { + w = _jit->pc.w; + ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2); + NOP(); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = boaddr(i0, r0, rn(reg)); + jit_unget_reg(reg); + } + return (w); +} + +static jit_word_t +_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + w = _jit->pc.w; + ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2); + NOP(); + return (w); +} + +static jit_word_t +_boaddi_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 >= -16 && i1 <= 15) { + w = _jit->pc.w; + ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2); + NOP(); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = boaddr_u(i0, r0, rn(reg)); + jit_unget_reg(reg); + } + return (w); +} + +static jit_word_t +_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + w = _jit->pc.w; + ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2); + NOP(); + return (w); +} + +static jit_word_t +_bxaddi(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 >= -16 && i1 <= 15) { + w = _jit->pc.w; + ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2); + NOP(); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bxaddr(i0, r0, rn(reg)); + jit_unget_reg(reg); + } + return (w); +} + +static jit_word_t +_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + w = _jit->pc.w; + ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2); + NOP(); + return (w); +} + +static jit_word_t +_bxaddi_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 >= -16 && i1 <= 15) { + w = _jit->pc.w; + ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2); + NOP(); + } + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i1); + w = bxaddr_u(i0, r0, rn(reg)); + jit_unget_reg(reg); + } + return (w); +} + +static jit_word_t +_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + SUB_NSV(r0, r1, r0); + w = _jit->pc.w; + /* null'ed if no signed overflow */ + B_N(((i0 - w) >> 2) - 2, _R0_REGNO); + NOP(); + return (w); +} + +static jit_word_t +_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + movi(_R1_REGNO, i1); + return (bosubr(i0, r0, _R1_REGNO)); +} + +static jit_word_t +_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + SUB(r0, r1, r0); + SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO); + return (bnei(i0, _R1_REGNO, 0)); +} + +static jit_word_t +_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + movi(_R1_REGNO, i1); + SUB(r0, _R1_REGNO, r0); + SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO); + return (bnei(i0, _R1_REGNO, 0)); +} + +static jit_word_t +_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + SUB_SV(r0, r1, r0); + w = _jit->pc.w; + /* null'ed if signed overflow */ + B_N(((i0 - w) >> 2) - 2, _R0_REGNO); + NOP(); + return (w); +} + +static jit_word_t +_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + movi(_R1_REGNO, i1); + return (bxsubr(i0, r0, _R1_REGNO)); +} + +static jit_word_t +_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + SUB(r0, r1, r0); + SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO); + return (beqi(i0, _R1_REGNO, 0)); +} + +static jit_word_t +_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + movi(_R1_REGNO, i1); + SUB(r0, _R1_REGNO, r0); + SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO); + return (beqi(i0, _R1_REGNO, 0)); +} + +static void +_jmpr(jit_state_t *_jit, jit_int32_t r0) +{ + BV_N(_R0_REGNO, r0); +} + +static void +_jmpi(jit_state_t *_jit, jit_word_t i0) +{ + jit_word_t w; + w = ((i0 - _jit->pc.w) >> 2) - 2; + if (w >= -32768 && w <= 32767) + B_N(w, _R0_REGNO); + else { + movi(_R1_REGNO, w); + BV_N(_R0_REGNO, _R1_REGNO); + } +} + +static jit_word_t +_jmpi_p(jit_state_t *_jit, jit_word_t i0) +{ + jit_word_t w; + w = movi_p(_R1_REGNO, i0); + jmpr(_R1_REGNO); + return (w); +} + +static void +_callr(jit_state_t *_jit, jit_int32_t r0) +{ + if (r0 != _R1_REGNO) + COPY(r0, _R1_REGNO); + /* inline $$dyncall */ + BBI_N_GE(_R1_REGNO, 30, 4); /* if (r1 & 2) { */ + DEPWRI(0, 31, 2, _R1_REGNO); /* r1 &= ~2; */ + LDWI(4, _R1_REGNO, _R19_REGNO); /* r19 = r1[1]; */ + LDWI(0, _R1_REGNO, _R1_REGNO); /* r1 = r1[0]; */ + /* } */ + BVE_L(_R1_REGNO); + STWL(_RP_REGNO, -24, _SP_REGNO); +} + +static void +_calli(jit_state_t *_jit, jit_word_t i0) +{ + jit_word_t w; + if (i0 & 2) { + i0 &= -4; + movi(_R1_REGNO, i0); + LDWI(4, _R1_REGNO, _R19_REGNO); + LDWI(0, _R1_REGNO, _R1_REGNO); + BVE_L(_R1_REGNO); + STWL(_RP_REGNO, -24, _SP_REGNO); + } + else { + w = ((i0 - _jit->pc.w) >> 2) - 2; + if (w >= -32768 && w <= 32767) + B_L_N(w); + else { + movi(_R1_REGNO, w); + BLR_N(_R1_REGNO, _RP_REGNO); + } + NOP(); + } +} + +static jit_word_t +_calli_p(jit_state_t *_jit, jit_word_t i0) +{ + jit_word_t w; + w = movi_p(_R1_REGNO, i0); + callr(_R1_REGNO); + return (w); +} + +static jit_int32_t gr[] = { + _R4, _R5, _R6, _R7, _R8, + _R9, _R10, _R11, _R12, _R13, + _R14, _R15, _R16, _R17, _R18 +}; + +static jit_int32_t fr[] = { + _F12, _F13, _F14, _F15, _F16, + _F17, _F18, _F19, _F20, _F21 +}; + +static void +_prolog(jit_state_t *_jit, jit_node_t *node) +{ + jit_int32_t regno; + jit_word_t offset; + + _jitc->function->stack = ((_jitc->function->self.aoff - + _jitc->function->self.alen - + _jitc->function->self.size) + 63) & -64; + + /* Save stack frame (FIXME Only required if non leaf) */ + STWL(_RP_REGNO, -20, _SP_REGNO); + + /* Create stack frame */ + COPY(_FP_REGNO, _R1_REGNO); + COPY(_SP_REGNO, _FP_REGNO); + STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO); + + /* Save any modified callee save registers */ + offset = alloca_offset - 140; + for (regno = 0; regno < jit_size(gr); regno++, offset += 4) { + if (jit_regset_tstbit(&_jitc->function->regset, gr[regno])) + stxi(offset, _FP_REGNO, rn(gr[regno])); + } + for (regno = 0; regno < jit_size(fr); regno++, offset += 8) { + if (jit_regset_tstbit(&_jitc->function->regset, fr[regno])) + stxi_d(offset, _FP_REGNO, rn(fr[regno])); + } +} + +static void +_epilog(jit_state_t *_jit, jit_node_t *node) +{ + jit_int32_t regno; + jit_word_t offset; + + /* Restore any modified callee save registers */ + offset = alloca_offset - 140; + for (regno = 0; regno < jit_size(gr); regno++, offset += 4) { + if (jit_regset_tstbit(&_jitc->function->regset, gr[regno])) + ldxi(rn(gr[regno]), _FP_REGNO, offset); + } + for (regno = 0; regno < jit_size(fr); regno++, offset += 8) { + if (jit_regset_tstbit(&_jitc->function->regset, fr[regno])) + ldxi_d(rn(fr[regno]), _FP_REGNO, offset); + } + + /* Restore stack frame (FIXME Only required if non leaf) */ + LDWL(-20, _FP_REGNO, _RP_REGNO); + LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO); + LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO); + BV_N(_R0_REGNO, _RP_REGNO); +} + +static void +_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label) +{ + jit_word_t w; + union { + jit_uint32_t *i; + jit_word_t w; + } u; + u.w = instr; + switch (u.i[0] >> 26) { + case 0x8: /* LDIL */ + u.i[0] &= ~0x1fffff; + u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11); + assert((u.i[1] >> 26) == 0xd); /* LDO */ + u.i[1] &= ~0xffff; + u.i[1] |= re_assemble_16(label & 0x7ff); + break; + case 0x20: case 0x22: /* CMPB */ + case 0x21: case 0x23: /* CMPIB */ + case 0x28: case 0x2a: /* ADDB */ + case 0x29: case 0x2b: /* ADDIB */ + case 0x31: /* BBI */ + w = ((label - instr) >> 2) - 2; + assert(w >= -2048 && w <= 2047); + u.i[0] &= ~0x1ffd; + u.i[0] |= re_assemble_12(w); + break; + case 0x3a: /* B */ + w = ((label - instr) >> 2) - 2; + assert(w >= -32768 && w <= 32767); + u.i[0] &= ~0x1f1ffd; + u.i[0] |= re_assemble_17(w); + break; + default: + abort(); + } +} +#endif diff --git a/lib/jit_hppa-fpu.c b/lib/jit_hppa-fpu.c new file mode 100644 index 000000000..ab81891bf --- /dev/null +++ b/lib/jit_hppa-fpu.c @@ -0,0 +1,924 @@ +/* + * 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 f39(o,b,x,t) _f39(_jit,o,b,x,t) +static void _f39(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f40(o,b,x,r) _f40(_jit,o,b,x,r) +static void _f40(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f41(o,b,x,t) _f41(_jit,o,b,x,t) +static void _f41(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f42(o,b,i,r) _f42(_jit,o,b,i,r) +static void _f42(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f43(o,b,t,i) f1(o,b,t,i) +#define f45(o,r,a,b,fmt,c,d,e,t) _f45(_jit,o,r,a,b,fmt,c,d,e,t) +static void _f45(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f46(o,r,a,s,df,sf,b,c,d,t) _f46(_jit,o,r,a,s,df,sf,b,c,d,t) +static void _f46(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f47(o,r1,r2,a,fmt,b,c,d,t) f47_48(o,r1,r2,a,fmt,b,c,d,t) +#define f48(o,r1,r2,a,fmt,b,c,d,t) f47_48(o,r1,r2,a,fmt,b,c,d,t) +#define f47_48(o,r1,r2,y,fmt,b,c,d,t) _f47_48(_jit,o,r1,r2,y,fmt,b,c,d,t) +static void _f47_48(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f49(o,r,a,b,c,f,d,e,g,h,i,t) f49_52(o,r,a,b,c,f,d,e,g,h,i,t) +#define f51(o,r1,r2,y,a,f,b,d,e,g,h,c) f49_52(o,r1,r2,y,a,f,b,d,e,g,h,c) +#define f52(o,r1,r2,a,b,f,c,d,e,g,h,t) f49_52(o,r1,r2,a,b,f,c,d,e,g,h,t) +#define f49_52(o,r1,r2,y,v,f,a,b,u,c,d,t) _f49_52(_jit,o,r1,r2,y,v,f,a,b,u,c,d,t) +static void _f49_52(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define f53(o,r1,r2,ta,ra,f,tm) _f53(_jit,o,r1,r2,ta,ra,f,tm) +static void _f53(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define f54(o,r1,r2,a,b,f,c,d,e,g,t) _f54(_jit,o,r1,r2,a,b,f,c,d,e,g,t) +static void _f54(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; +#define FABS_(f,r,t) f49(0xe,r,0,3,0,f,0,0,0,0,0,t) +#define FABS_S(r,t) FABS_(0,r,t) +#define FABS_D(r,t) FABS_(1,r,t) +#define FABS_Q(r,t) f45(0xc,r,0,3,3,0,0,0,t) +#define FADD_(f,r1,r2,t) f52(0xe,r1,r2,0,0,f,3,0,0,0,0,t) +#define FADD_S(r1,r2,t) FADD_(0,r1,r2,t) +#define FADD_D(r1,r2,t) FADD_(1,r1,r2,t) +#define FADD_Q(r1,r2,t) f48(0xc,r1,r2,0,3,3,0,0,t) +#define FPSR_GT 1 +#define FPSR_LT 2 +#define FPSR_EQ 4 +#define FPSR_UN 8 +/* + Actually these are reversed, but easier for the FTEST after the FCMP + fcmp,dbl,false? fr4,fr12 0 + fcmp,dbl,false fr4,fr12 1 + fcmp,dbl,? fr4,fr12 2 + fcmp,dbl,!<=> fr4,fr12 3 ORD + fcmp,dbl,= fr4,fr12 4 NE + fcmp,dbl,=t fr4,fr12 5 + fcmp,dbl,?= fr4,fr12 6 + fcmp,dbl,!<> fr4,fr12 7 LTGT + fcmp,dbl,!?>= fr4,fr12 8 + fcmp,dbl,< fr4,fr12 9 UNGE + fcmp,dbl,?< fr4,fr12 10 + fcmp,dbl,!>= fr4,fr12 11 GE + fcmp,dbl,!?> fr4,fr12 12 + fcmp,dbl,<= fr4,fr12 13 UNGT + fcmp,dbl,?<= fr4,fr12 14 + fcmp,dbl,!> fr4,fr12 15 GT + fcmp,dbl,!?<= fr4,fr12 16 + fcmp,dbl,> fr4,fr12 17 UNLE + fcmp,dbl,?> fr4,fr12 18 + fcmp,dbl,!<= fr4,fr12 19 LE + fcmp,dbl,!?< fr4,fr12 20 + fcmp,dbl,>= fr4,fr12 21 UNLT + fcmp,dbl,?>= fr4,fr12 22 + fcmp,dbl,!< fr4,fr12 23 LT + fcmp,dbl,!?= fr4,fr12 24 + fcmp,dbl,<> fr4,fr12 25 UNEQ + fcmp,dbl,!= fr4,fr12 26 EQ + fcmp,dbl,!=t fr4,fr12 27 + fcmp,dbl,!? fr4,fr12 28 + fcmp,dbl,<=> fr4,fr12 29 UNORD + fcmp,dbl,true? fr4,fr12 30 + fcmp,dbl,true fr4,fr12 31 + */ +#define FCMP_LT 23 +#define FCMP_LE 19 +#define FCMP_EQ 26 +#define FCMP_GE 11 +#define FCMP_GT 15 +#define FCMP_NE 4 +#define FCMP_UNLT 21 +#define FCMP_UNLE 17 +#define FCMP_UNEQ 25 +#define FCMP_UNGE 9 +#define FCMP_UNGT 13 +#define FCMP_LTGT 7 +#define FCMP_ORD 3 +#define FCMP_UNORD 29 +#define FCMP_(f,r1,r2,c) f51(0xe,r1,r2,0,0,f,2,0,0,0,0,c) +#define FCMP_S_(r1,r2,c) FCMP_(0,r1,r2,c) +#define FCMP_D_(r1,r2,c) FCMP_(1,r1,r2,c) +#define FCMP_Q_(r1,r2,c) f47(0xc,r1,r2,0,3,2,0,0,c) +#define FCMP_S_LT(r1,r2) FCMP_S_(r1,r2,FCMP_LT) +#define FCMP_D_LT(r1,r2) FCMP_D_(r1,r2,FCMP_LT) +#define FCMP_Q_LT(r1,r2) FCMP_Q_(r1,r2,FCMP_LT) +#define FCMP_S_LE(r1,r2) FCMP_S_(r1,r2,FCMP_LE) +#define FCMP_D_LE(r1,r2) FCMP_D_(r1,r2,FCMP_LE) +#define FCMP_Q_LE(r1,r2) FCMP_Q_(r1,r2,FCMP_LE) +#define FCMP_S_EQ(r1,r2) FCMP_S_(r1,r2,FCMP_EQ) +#define FCMP_D_EQ(r1,r2) FCMP_D_(r1,r2,FCMP_EQ) +#define FCMP_Q_EQ(r1,r2) FCMP_Q_(r1,r2,FCMP_EQ) +#define FCMP_S_GE(r1,r2) FCMP_S_(r1,r2,FCMP_GE) +#define FCMP_D_GE(r1,r2) FCMP_D_(r1,r2,FCMP_GE) +#define FCMP_Q_GE(r1,r2) FCMP_Q_(r1,r2,FCMP_GE) +#define FCMP_S_GT(r1,r2) FCMP_S_(r1,r2,FCMP_GT) +#define FCMP_D_GT(r1,r2) FCMP_D_(r1,r2,FCMP_GT) +#define FCMP_Q_GT(r1,r2) FCMP_Q_(r1,r2,FCMP_GT) +#define FCMP_S_NE(r1,r2) FCMP_S_(r1,r2,FCMP_NE) +#define FCMP_D_NE(r1,r2) FCMP_D_(r1,r2,FCMP_NE) +#define FCMP_Q_NE(r1,r2) FCMP_Q_(r1,r2,FCMP_NE) +#define FCMP_S_UNLT(r1,r2) FCMP_S_(r1,r2,FCMP_UNLT) +#define FCMP_D_UNLT(r1,r2) FCMP_D_(r1,r2,FCMP_UNLT) +#define FCMP_Q_UNLT(r1,r2) FCMP_Q_(r1,r2,FCMP_UNLT) +#define FCMP_S_UNLE(r1,r2) FCMP_S_(r1,r2,FCMP_UNLE) +#define FCMP_D_UNLE(r1,r2) FCMP_D_(r1,r2,FCMP_UNLE) +#define FCMP_Q_UNLE(r1,r2) FCMP_Q_(r1,r2,FCMP_UNLE) +#define FCMP_S_UNEQ(r1,r2) FCMP_S_(r1,r2,FCMP_UNEQ) +#define FCMP_D_UNEQ(r1,r2) FCMP_D_(r1,r2,FCMP_UNEQ) +#define FCMP_Q_UNEQ(r1,r2) FCMP_Q_(r1,r2,FCMP_UNEQ) +#define FCMP_S_UNGE(r1,r2) FCMP_S_(r1,r2,FCMP_UNGE) +#define FCMP_D_UNGE(r1,r2) FCMP_D_(r1,r2,FCMP_UNGE) +#define FCMP_Q_UNGE(r1,r2) FCMP_Q_(r1,r2,FCMP_UNGE) +#define FCMP_S_UNGT(r1,r2) FCMP_S_(r1,r2,FCMP_UNGT) +#define FCMP_D_UNGT(r1,r2) FCMP_D_(r1,r2,FCMP_UNGT) +#define FCMP_Q_UNGT(r1,r2) FCMP_Q_(r1,r2,FCMP_UNGT) +#define FCMP_S_LTGT(r1,r2) FCMP_S_(r1,r2,FCMP_LTGT) +#define FCMP_D_LTGT(r1,r2) FCMP_D_(r1,r2,FCMP_LTGT) +#define FCMP_Q_LTGT(r1,r2) FCMP_Q_(r1,r2,FCMP_LTGT) +#define FCMP_S_ORD(r1,r2) FCMP_S_(r1,r2,FCMP_ORD) +#define FCMP_D_ORD(r1,r2) FCMP_D_(r1,r2,FCMP_ORD) +#define FCMP_Q_ORD(r1,r2) FCMP_Q_(r1,r2,FCMP_ORD) +#define FCMP_S_UNORD(r1,r2) FCMP_S_(r1,r2,FCMP_UNORD) +#define FCMP_D_UNORD(r1,r2) FCMP_D_(r1,r2,FCMP_UNORD) +#define FCMP_Q_UNORD(r1,r2) FCMP_Q_(r1,r2,FCMP_UNORD) +#define XFNVFF(s,d,r,t) f46(0xc,r,0,0,d,s,1,0,0,t) +#define FCNVFF_Q_S(r,t) XFNVFF(3,0,r,t) +#define FCNVFF_Q_D(r,t) XFNVFF(3,1,r,t) +#define FCNVFF_S_Q(r,t) XFNVFF(0,3,r,t) +#define FCNVFF_D_Q(r,t) XFNVFF(1,3,r,t) +#define FCNVFF_(s,d,r,t) f46(0xc,r,0,0,d,s,1,0,0,t) +#define FCNVFF_S_D(r,t) FCNVFF_(0,1,r,t) +#define FCNVFF_D_S(r,t) FCNVFF_(1,0,r,t) +#define FCNVXF_(s,d,r,t) f46(0xc,r,0,1,d,s,1,0,0,t) +#define FCNVXF_S_S(r,t) FCNVXF_(0,0,r,t) +#define FCNVXF_S_D(r,t) FCNVXF_(0,1,r,t) +#define FCNVXT_(s,d,r,t) f46(0xc,r,0,3,d,s,1,0,0,t) +#define FCNVXT_S_S(r,t) FCNVXT_(0,0,r,t) +#define FCNVXT_D_S(r,t) FCNVXT_(1,0,r,t) +#define FCPY_(f,r,t) f49(0xe,r,0,2,0,f,0,0,0,0,0,t) +#define FCPY_S(r,t) FCPY_(0,r,t) +#define FCPY_D(r,t) FCPY_(1,r,t) +#define FCPY_Q(r,t) f45(0xc,r,0,2,2,0,0,0,t) +#define FDIV_(f,r1,r2,t) f52(0xe,r1,r2,3,0,f,3,0,0,0,0,t) +#define FDIV_S(r1,r2,t) FDIV_(0,r1,r2,t) +#define FDIV_D(r1,r2,t) FDIV_(1,r1,r2,t) +#define FDIV_Q(r1,r2,t) f48(0xc,r1,r2,3,3,3,0,0,t) +#define FID() f45(0xc,0,0,0,2,0,0,0,0) +#define FLDDL(i,b,t) f3(0x14,b,t,i,1) +#define FLDD(x,b,t) f39(0xb,b,x,t) +#define FLDDI(i,b,t) f41(0xb,b,i,t) +#define FLDWL(i,b,t) f43(0x17,b,t,i) +#define FLDW(x,b,t) f39(0x9,b,x,t) +#define FLDWI(i,b,t) f41(0x9,b,i,t) +#define FMPY_(f,r1,r2,t) f52(0xe,r1,r2,2,0,f,3,0,0,0,0,t) +#define FMPY_S(r1,r2,t) FMPY_(0,r1,r2,t) +#define FMPY_D(r1,r2,t) FMPY_(1,r1,r2,t) +#define FMPY_Q(r1,r2,t) f48(0xc,r1,r2,2,3,3,0,0,t) +/* FIXME not disassembled */ +#define FMPYADD_(f,r1,r2,ta,ra,tm) f53(0x6,r1,r2,ta,ra,f,tm) +#define FMPYADD_S(r1,r2,ta,ra,tm) FMPYADD_(0,r1,r2,ta,ra,tm) +#define FMPYADD_D(r1,r2,ta,ra,tm) FMPYADD_(1,r1,r2,ta,ra,tm) +#define FMPYFADD_(f,r1,r2,ra,t) f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,0,t) +#define FMPYFADD_S(r1,r2,ra,t) FMPYFADD_(0,r1,r2,ra,t) +#define FMPYFADD_D(r1,r2,ra,t) FMPYFADD_(1,r1,r2,ra,t) +#define FMPYNFADD_(f,r1,r2,ra,t) f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,1,t) +#define FMPYNFADD_S(r1,r2,ra,t) FMPYNFADD_(0,r1,r2,ra,t) +#define FMPYNFADD_D(r1,r2,ra,t) FMPYNFADD_(1,r1,r2,ra,t) +#define FMPYSUB_(f,r1,r2,ta,ra,tm) f53(0x26,r1,r2,ta,ra,f,tm) +#define FMPYSUB_S(r1,r2,ta,ra,tm) FMPYSUB_(0,r1,r2,ta,ra,tm) +#define FMPYSUB_D(r1,r2,ta,ra,tm) FMPYSUB_(1,r1,r2,ta,ra,tm) +#define FNEG_(f,r,t) f49(0xe,r,0,6,0,f,0,0,0,0,0,t) +#define FNEG_S(r,t) FNEG_(0,r,t) +#define FNEG_D(r,t) FNEG_(1,r,t) +/* FIXME not disassembled */ +#define FNEG_Q(r,t) f45(0xc,r,0,6,3,0,0,0,t) +#define FNEGABS_(f,r,t) f49(0xe,r,0,7,0,f,0,0,0,0,0,t) +#define FNEGABS_S(r,t) FNEGABS_(0,r,t) +#define FNEGABS_D(r,t) FNEGABS_(1,r,t) +#define FNEGABS_Q(r,t) f45(0xc,r,0,7,3,0,0,0,t) +#define FRND_(f,r,t) f49(0xe,r,0,5,0,f,0,0,0,0,0,t) +#define FRND_S(r,t) FRND_(0,r,t) +#define FRND_D(r,t) FRND_(1,r,t) +#define FRND_Q(r,t) f45(0xc,r,0,5,3,0,0,0,t) +#define FSQRT_(f,r,t) f49(0xe,r,0,4,0,f,0,0,0,0,0,t) +#define FSQRT_S(r,t) FSQRT_(0,r,t) +#define FSQRT_D(r,t) FSQRT_(1,r,t) +#define FSQRT_Q(r,t) f45(0xc,r,0,4,3,0,0,0,t) +#define FSTDL(r,i,b) f3(0x1c,b,r,i,1) +#define FSTD(r,x,b) f40(0xb,b,x,r) +#define FSTDI(r,i,b) f42(0xb,b,i,r) +#define FSTWL(r,i,b) f43(0x1f,b,r,i) +#define FSTW(r,x,b) f40(0x9,b,x,r) +#define FSTWI(r,i,b) f42(0x9,b,i,r) +#define FSUB_(f,r1,r2,t) f52(0xe,r1,r2,1,0,f,3,0,0,0,0,t) +#define FSUB_S(r1,r2,t) FSUB_(0,r1,r2,t) +#define FSUB_D(r1,r2,t) FSUB_(1,r1,r2,t) +#define FSUB_Q(r1,r2,t) f48(0xc,r1,r2,1,3,3,0,0,t) +#define FTEST_(c) f47(0xc,0,0,0,0,2,0,1,c) +#define FTEST() f47(0xc,0,0,1,0,2,0,1,0) +#define FTEST_LT() FTEST_(FCMP_LT) +#define FTEST_LE() FTEST_(FCMP_LE) +#define FTEST_EQ() FTEST_(FCMP_EQ) +#define FTEST_GE() FTEST_(FCMP_GE) +#define FTEST_GT() FTEST_(FCMP_GT) +#define FTEST_NE() FTEST_(FCMP_NE) +#define FTEST_UNLT() FTEST_(FCMP_UNLT) +#define FTEST_UNLE() FTEST_(FCMP_UNLE) +#define FTEST_UNEQ() FTEST_(FCMP_UNEQ) +#define FTEST_UNGE() FTEST_(FCMP_UNGE) +#define FTEST_UNGT() FTEST_(FCMP_UNGT) +#define FTEST_LTGT() FTEST_(FCMP_LTGT) +#define FTEST_ORD() FTEST_(FCMP_ORD) +#define FTEST_UNORD() FTEST_(FCMP_UNORD) +#define XMPYU(r1,r2,t) f52(0xe,r1,r2,2,0,0,3,1,0,0,0,t) +#define XMPYU_L_R(r1,r2,t) f52(0xe,r1,r2,2,1,0,3,1,0,0,0,t) +#define XMPYU_R_L(r1,r2,t) f52(0xe,r1,r2,2,0,0,3,1,1,0,0,t) +#define XMPYU_R_R(r1,r2,t) f52(0xe,r1,r2,2,1,0,3,1,1,0,0,t) +#define negr_f(r0,r1) FNEG_S(r1,r0) +#define negr_d(r0,r1) FNEG_D(r1,r0) +#define sqrtr_f(r0,r1) FSQRT_S(r1,r0) +#define sqrtr_d(r0,r1) FSQRT_D(r1,r0) +#define extr_f(r0,r1) _extr_f(_jit,r0,r1) +static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t); +#define extr_d(r0,r1) _extr_d(_jit,r0,r1) +static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t); +#define extr_f_d(r0,r1) FCNVFF_S_D(r1,r0) +#define extr_d_f(r0,r1) FCNVFF_D_S(r1,r0) +#define truncr_f(r0,r1) truncr_f_i(r0,r1) +#define truncr_f_i(r0,r1) _truncr_f_i(_jit,r0,r1) +static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t); +#define truncr_d(r0,r1) truncr_d_i(r0,r1) +#define truncr_d_i(r0,r1) _truncr_d_i(_jit,r0,r1) +static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t); +#define movr_f(r0,r1) FCPY_S(r1,r0) +#define movi_f(r0,i0) _movi_f(_jit,r0,i0) +static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); +#define movr_d(r0,r1) FCPY_D(r1,r0) +#define movi_d(r0,i0) _movi_d(_jit,r0,i0) +static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); +#define absr_f(r0,r1) FABS_S(r1,r0) +#define absr_d(r0,r1) FABS_D(r1,r0) +#define addr_f(r0,r1,r2) FADD_S(r1,r2,r0) +#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(r1,r2,r0) +#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(r1,r2,r0) +#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(r1,r2,r0) +#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(r1,r2,r0) +#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(r1,r2,r0) +#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) FDIV_S(r1,r2,r0) +#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) FDIV_D(r1,r2,r0) +#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 cmpr_f(c,r0,r1,r2) _cmpr_f(_jit,c,r0,r1,r2) +static void _cmpr_f(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define cmpi_f(c,r0,r1,i0) _cmpi_f(_jit,c,r0,r1,i0) +static void _cmpi_f(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_float32_t*); +#define cmpr_d(c,r0,r1,r2) _cmpr_d(_jit,c,r0,r1,r2) +static void _cmpr_d(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_int32_t); +#define cmpi_d(c,r0,r1,i0) _cmpi_d(_jit,c,r0,r1,i0) +static void _cmpi_d(jit_state_t*,jit_word_t, + jit_int32_t,jit_int32_t,jit_float64_t*); +#define ltr_f(r0,r1,r2) cmpr_f(FCMP_LT,r0,r1,r2) +#define lti_f(r0,r1,i0) cmpi_f(FCMP_LT,r0,r1,i0) +#define ltr_d(r0,r1,r2) cmpr_d(FCMP_LT,r0,r1,r2) +#define lti_d(r0,r1,i0) cmpi_d(FCMP_LT,r0,r1,i0) +#define ler_f(r0,r1,r2) cmpr_f(FCMP_LE,r0,r1,r2) +#define lei_f(r0,r1,i0) cmpi_f(FCMP_LE,r0,r1,i0) +#define ler_d(r0,r1,r2) cmpr_d(FCMP_LE,r0,r1,r2) +#define lei_d(r0,r1,i0) cmpi_d(FCMP_LE,r0,r1,i0) +#define eqr_f(r0,r1,r2) cmpr_f(FCMP_EQ,r0,r1,r2) +#define eqi_f(r0,r1,i0) cmpi_f(FCMP_EQ,r0,r1,i0) +#define eqr_d(r0,r1,r2) cmpr_d(FCMP_EQ,r0,r1,r2) +#define eqi_d(r0,r1,i0) cmpi_d(FCMP_EQ,r0,r1,i0) +#define ger_f(r0,r1,r2) cmpr_f(FCMP_GE,r0,r1,r2) +#define gei_f(r0,r1,i0) cmpi_f(FCMP_GE,r0,r1,i0) +#define ger_d(r0,r1,r2) cmpr_d(FCMP_GE,r0,r1,r2) +#define gei_d(r0,r1,i0) cmpi_d(FCMP_GE,r0,r1,i0) +#define gtr_f(r0,r1,r2) cmpr_f(FCMP_GT,r0,r1,r2) +#define gti_f(r0,r1,i0) cmpi_f(FCMP_GT,r0,r1,i0) +#define gtr_d(r0,r1,r2) cmpr_d(FCMP_GT,r0,r1,r2) +#define gti_d(r0,r1,i0) cmpi_d(FCMP_GT,r0,r1,i0) +#define ner_f(r0,r1,r2) cmpr_f(FCMP_NE,r0,r1,r2) +#define nei_f(r0,r1,i0) cmpi_f(FCMP_NE,r0,r1,i0) +#define ner_d(r0,r1,r2) cmpr_d(FCMP_NE,r0,r1,r2) +#define nei_d(r0,r1,i0) cmpi_d(FCMP_NE,r0,r1,i0) +#define unltr_f(r0,r1,r2) cmpr_f(FCMP_UNLT,r0,r1,r2) +#define unlti_f(r0,r1,i0) cmpi_f(FCMP_UNLT,r0,r1,i0) +#define unltr_d(r0,r1,r2) cmpr_d(FCMP_UNLT,r0,r1,r2) +#define unlti_d(r0,r1,i0) cmpi_d(FCMP_UNLT,r0,r1,i0) +#define unler_f(r0,r1,r2) cmpr_f(FCMP_UNLE,r0,r1,r2) +#define unlei_f(r0,r1,i0) cmpi_f(FCMP_UNLE,r0,r1,i0) +#define unler_d(r0,r1,r2) cmpr_d(FCMP_UNLE,r0,r1,r2) +#define unlei_d(r0,r1,i0) cmpi_d(FCMP_UNLE,r0,r1,i0) +#define uneqr_f(r0,r1,r2) cmpr_f(FCMP_UNEQ,r0,r1,r2) +#define uneqi_f(r0,r1,i0) cmpi_f(FCMP_UNEQ,r0,r1,i0) +#define uneqr_d(r0,r1,r2) cmpr_d(FCMP_UNEQ,r0,r1,r2) +#define uneqi_d(r0,r1,i0) cmpi_d(FCMP_UNEQ,r0,r1,i0) +#define unger_f(r0,r1,r2) cmpr_f(FCMP_UNGE,r0,r1,r2) +#define ungei_f(r0,r1,i0) cmpi_f(FCMP_UNGE,r0,r1,i0) +#define unger_d(r0,r1,r2) cmpr_d(FCMP_UNGE,r0,r1,r2) +#define ungei_d(r0,r1,i0) cmpi_d(FCMP_UNGE,r0,r1,i0) +#define ungtr_f(r0,r1,r2) cmpr_f(FCMP_UNGT,r0,r1,r2) +#define ungti_f(r0,r1,i0) cmpi_f(FCMP_UNGT,r0,r1,i0) +#define ungtr_d(r0,r1,r2) cmpr_d(FCMP_UNGT,r0,r1,r2) +#define ungti_d(r0,r1,i0) cmpi_d(FCMP_UNGT,r0,r1,i0) +#define ltgtr_f(r0,r1,r2) cmpr_f(FCMP_LTGT,r0,r1,r2) +#define ltgti_f(r0,r1,i0) cmpi_f(FCMP_LTGT,r0,r1,i0) +#define ltgtr_d(r0,r1,r2) cmpr_d(FCMP_LTGT,r0,r1,r2) +#define ltgti_d(r0,r1,i0) cmpi_d(FCMP_LTGT,r0,r1,i0) +#define ordr_f(r0,r1,r2) cmpr_f(FCMP_ORD,r0,r1,r2) +#define ordi_f(r0,r1,i0) cmpi_f(FCMP_ORD,r0,r1,i0) +#define ordr_d(r0,r1,r2) cmpr_d(FCMP_ORD,r0,r1,r2) +#define ordi_d(r0,r1,i0) cmpi_d(FCMP_ORD,r0,r1,i0) +#define unordr_f(r0,r1,r2) cmpr_f(FCMP_UNORD,r0,r1,r2) +#define unordi_f(r0,r1,i0) cmpi_f(FCMP_UNORD,r0,r1,i0) +#define unordr_d(r0,r1,r2) cmpr_d(FCMP_UNORD,r0,r1,r2) +#define unordi_d(r0,r1,i0) cmpi_d(FCMP_UNORD,r0,r1,i0) +#define ldr_f(r0,r1) FLDWI(0,r1,r0) +#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) FLDW(r2,r1,r0) +#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) FLDDI(0,r1,r0) +#define ldi_d(r0,i0) _ldi_d(_jit,r0,i0) +static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t); +#define ldxr_d(r0,r1,r2) FLDD(r2,r1,r0) +#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 str_f(r0,r1) FSTWI(r1,0,r0) +#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) FSTW(r2,r1,r0) +#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) FSTDI(r1,0,r0) +#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) FSTD(r2,r1,r0) +#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 bcmpr_f(c,i0,r0,r1) _bcmpr_f(_jit,c,i0,r0,r1) +static jit_word_t _bcmpr_f(jit_state_t*,jit_word_t, + jit_word_t,jit_int32_t,jit_int32_t); +#define bcmpi_f(c,i0,r0,i1) _bcmpi_f(_jit,c,i0,r0,i1) +static jit_word_t _bcmpi_f(jit_state_t*,jit_word_t, + jit_word_t,jit_int32_t,jit_float32_t*); +#define bcmpr_d(c,i0,r0,r1) _bcmpr_d(_jit,c,i0,r0,r1) +static jit_word_t _bcmpr_d(jit_state_t*,jit_word_t, + jit_word_t,jit_int32_t,jit_int32_t); +#define bcmpi_d(c,i0,r0,i1) _bcmpi_d(_jit,c,i0,r0,i1) +static jit_word_t _bcmpi_d(jit_state_t*,jit_word_t, + jit_word_t,jit_int32_t,jit_float64_t*); +#define bltr_f(i0,r0,r1) bcmpr_f(FCMP_LT,i0,r0,r1) +#define blti_f(i0,r0,i1) bcmpi_f(FCMP_LT,i0,r0,i1) +#define bltr_d(i0,r0,r1) bcmpr_d(FCMP_LT,i0,r0,r1) +#define blti_d(i0,r0,i1) bcmpi_d(FCMP_LT,i0,r0,i1) +#define bler_f(i0,r0,r1) bcmpr_f(FCMP_LE,i0,r0,r1) +#define blei_f(i0,r0,i1) bcmpi_f(FCMP_LE,i0,r0,i1) +#define bler_d(i0,r0,r1) bcmpr_d(FCMP_LE,i0,r0,r1) +#define blei_d(i0,r0,i1) bcmpi_d(FCMP_LE,i0,r0,i1) +#define beqr_f(i0,r0,r1) bcmpr_f(FCMP_EQ,i0,r0,r1) +#define beqi_f(i0,r0,i1) bcmpi_f(FCMP_EQ,i0,r0,i1) +#define beqr_d(i0,r0,r1) bcmpr_d(FCMP_EQ,i0,r0,r1) +#define beqi_d(i0,r0,i1) bcmpi_d(FCMP_EQ,i0,r0,i1) +#define bger_f(i0,r0,r1) bcmpr_f(FCMP_GE,i0,r0,r1) +#define bgei_f(i0,r0,i1) bcmpi_f(FCMP_GE,i0,r0,i1) +#define bger_d(i0,r0,r1) bcmpr_d(FCMP_GE,i0,r0,r1) +#define bgei_d(i0,r0,i1) bcmpi_d(FCMP_GE,i0,r0,i1) +#define bgtr_f(i0,r0,r1) bcmpr_f(FCMP_GT,i0,r0,r1) +#define bgti_f(i0,r0,i1) bcmpi_f(FCMP_GT,i0,r0,i1) +#define bgtr_d(i0,r0,r1) bcmpr_d(FCMP_GT,i0,r0,r1) +#define bgti_d(i0,r0,i1) bcmpi_d(FCMP_GT,i0,r0,i1) +#define bner_f(i0,r0,r1) bcmpr_f(FCMP_NE,i0,r0,r1) +#define bnei_f(i0,r0,i1) bcmpi_f(FCMP_NE,i0,r0,i1) +#define bner_d(i0,r0,r1) bcmpr_d(FCMP_NE,i0,r0,r1) +#define bnei_d(i0,r0,i1) bcmpi_d(FCMP_NE,i0,r0,i1) +#define bunltr_f(i0,r0,r1) bcmpr_f(FCMP_UNLT,i0,r0,r1) +#define bunlti_f(i0,r0,i1) bcmpi_f(FCMP_UNLT,i0,r0,i1) +#define bunltr_d(i0,r0,r1) bcmpr_d(FCMP_UNLT,i0,r0,r1) +#define bunlti_d(i0,r0,i1) bcmpi_d(FCMP_UNLT,i0,r0,i1) +#define bunler_f(i0,r0,r1) bcmpr_f(FCMP_UNLE,i0,r0,r1) +#define bunlei_f(i0,r0,i1) bcmpi_f(FCMP_UNLE,i0,r0,i1) +#define bunler_d(i0,r0,r1) bcmpr_d(FCMP_UNLE,i0,r0,r1) +#define bunlei_d(i0,r0,i1) bcmpi_d(FCMP_UNLE,i0,r0,i1) +#define buneqr_f(i0,r0,r1) bcmpr_f(FCMP_UNEQ,i0,r0,r1) +#define buneqi_f(i0,r0,i1) bcmpi_f(FCMP_UNEQ,i0,r0,i1) +#define buneqr_d(i0,r0,r1) bcmpr_d(FCMP_UNEQ,i0,r0,r1) +#define buneqi_d(i0,r0,i1) bcmpi_d(FCMP_UNEQ,i0,r0,i1) +#define bunger_f(i0,r0,r1) bcmpr_f(FCMP_UNGE,i0,r0,r1) +#define bungei_f(i0,r0,i1) bcmpi_f(FCMP_UNGE,i0,r0,i1) +#define bunger_d(i0,r0,r1) bcmpr_d(FCMP_UNGE,i0,r0,r1) +#define bungei_d(i0,r0,i1) bcmpi_d(FCMP_UNGE,i0,r0,i1) +#define bungtr_f(i0,r0,r1) bcmpr_f(FCMP_UNGT,i0,r0,r1) +#define bungti_f(i0,r0,i1) bcmpi_f(FCMP_UNGT,i0,r0,i1) +#define bungtr_d(i0,r0,r1) bcmpr_d(FCMP_UNGT,i0,r0,r1) +#define bungti_d(i0,r0,i1) bcmpi_d(FCMP_UNGT,i0,r0,i1) +#define bltgtr_f(i0,r0,r1) bcmpr_f(FCMP_LTGT,i0,r0,r1) +#define bltgti_f(i0,r0,i1) bcmpi_f(FCMP_LTGT,i0,r0,i1) +#define bltgtr_d(i0,r0,r1) bcmpr_d(FCMP_LTGT,i0,r0,r1) +#define bltgti_d(i0,r0,i1) bcmpi_d(FCMP_LTGT,i0,r0,i1) +#define bordr_f(i0,r0,r1) bcmpr_f(FCMP_ORD,i0,r0,r1) +#define bordi_f(i0,r0,i1) bcmpi_f(FCMP_ORD,i0,r0,i1) +#define bordr_d(i0,r0,r1) bcmpr_d(FCMP_ORD,i0,r0,r1) +#define bordi_d(i0,r0,i1) bcmpi_d(FCMP_ORD,i0,r0,i1) +#define bunordr_f(i0,r0,r1) bcmpr_f(FCMP_UNORD,i0,r0,r1) +#define bunordi_f(i0,r0,i1) bcmpi_f(FCMP_UNORD,i0,r0,i1) +#define bunordr_d(i0,r0,r1) bcmpr_d(FCMP_UNORD,i0,r0,r1) +#define bunordi_d(i0,r0,i1) bcmpi_d(FCMP_UNORD,i0,r0,i1) +#endif + +#if CODE +static void +_f39(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t x, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(t & ~0x1f)); + ii((o<<26)|(b<<21)|(x<<16)|t); +} + +static void +_f40(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t x, jit_int32_t r) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(!(x & ~0x1f)); + assert(!(r & ~0x1f)); + ii((o<<26)|(b<<21)|(x<<16)|(1<<9)|r); +} + +static void +_f41(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t x, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(x >= -16 && x < 15); + assert(!(t & ~0x1f)); + ii((o<<26)|(b<<21)|(low_sign_unext(x,5)<<16)|(1<<12)|t); +} + +static void +_f42(jit_state_t *_jit, jit_int32_t o, + jit_int32_t b, jit_int32_t i, jit_int32_t r) +{ + assert(!(o & ~0x3f)); + assert(!(b & ~0x1f)); + assert(i >= -16 && i < 15); + assert(!(r & ~0x1f)); + ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(1<<12)|(1<<9)|r); +} + +static void +_f45(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r, jit_int32_t a, jit_int32_t b, jit_int32_t fmt, + jit_int32_t c, jit_int32_t d, jit_int32_t e, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(a & ~0x1f)); + assert(!(b & ~0x7)); + assert(!(fmt & ~0x3)); + assert(!(c & ~0x3)); + assert(!(d & ~0x7)); + assert(!(e & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r<<21)|(a<<16)|(fmt<<13)|(b<<11)|(c<<9)|(d<<6)|(e<<5)|t); +} + +static void +_f46(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, + jit_int32_t a, jit_int32_t s, jit_int32_t df, jit_int32_t sf, + jit_int32_t b, jit_int32_t c, jit_int32_t d, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r & ~0x1f)); + assert(!(a & ~0x7)); + assert(!(s & ~0x7)); + assert(!(df & ~0x3)); + assert(!(sf & ~0x3)); + assert(!(b & ~0x3)); + assert(!(c & ~0x7)); + assert(!(d & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r<<21)|(a<<18)|(s<<15)| + (df<<13)|(sf<<11)|(b<<9)|(c<<6)|(d<<5)|t); +} + +static void +_f47_48(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r2, jit_int32_t r1, jit_int32_t y, jit_int32_t fmt, + jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r2 & ~0x1f)); + assert(!(r1 & ~0x1f)); + assert(!(y & ~0x7)); + assert(!(fmt & ~0x3)); + assert(!(a & ~0x3)); + assert(!(b & ~0x7)); + assert(!(c & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r2<<21)|(r1<<16)|(y<<13)|(fmt<<11)|(a<<9)|(b<<6)|(c<<5)|t); +} + +static void +_f49_52(jit_state_t *_jit, jit_int32_t o, + jit_int32_t r1, jit_int32_t r2, jit_int32_t y, + jit_int32_t v, jit_int32_t f, jit_int32_t a, jit_int32_t b, + jit_int32_t u, jit_int32_t c, jit_int32_t d, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r1 & ~0x1f)); + assert(!(r2 & ~0x3f)); + assert(!(y & ~0x7)); + assert(!(v & ~0x1)); + assert(!(f & ~0x1)); + assert(!(a & ~0x3)); + assert(!(b & ~0x1)); + assert(!(u & ~0x1)); + assert(!(c & ~0x1)); + assert(!(d & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r1<<21)|(r2<<16)|(y<<13)|(v<<12)| + (f<<11)|(a<<9)|(b<<8)|(u<<7)|(c<<6)|(d<<5)|t); +} + +static void +_f53(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2, + jit_int32_t ta, jit_int32_t ra, jit_int32_t f, jit_int32_t tm) +{ + assert(!(o & ~0x3f)); + assert(!(r1 & ~0x1f)); + assert(!(r2 & ~0x1f)); + assert(!(ta & ~0x1f)); + assert(!(ra & ~0x1f)); + assert(!(f & ~0x1)); + assert(!(tm & ~0x1f)); + assert(ra != tm || + (ta == r1 || ta == r2 || ta == tm) || + (f && ra == 1) || (!f && !ra)); + ii((o<<26)|(r1<<21)|(r2<<16)|(ta<<11)|(ra<<6)|(f<<5)|tm); +} + +static void +_f54(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2, + jit_int32_t a, jit_int32_t b, jit_int32_t f, jit_int32_t c, + jit_int32_t d, jit_int32_t e, jit_int32_t g, jit_int32_t t) +{ + assert(!(o & ~0x3f)); + assert(!(r1 & ~0x1f)); + assert(!(r2 & ~0x1f)); + assert(!(a & ~0x7)); + assert(!(b & ~0x1)); + assert(!(f & ~0x1)); + assert(!(c & ~0x7)); + assert(!(e & ~0x1)); + assert(!(e & ~0x1)); + assert(!(g & ~0x1)); + assert(!(t & ~0x1f)); + ii((o<<26)|(r1<<21)|(r2<<16)|(a<<13)| + (b<<12)|(f<11)|(c<<8)|(d<<7)|(e<<6)|(g<<5)|t); +} + +static void +_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + stxi(alloca_offset - 8, _FP_REGNO, r1); + ldxi_f(r0, _FP_REGNO, alloca_offset - 8); + FCNVXF_S_S(r0, r0); +} + +static void +_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + stxi(alloca_offset - 8, _FP_REGNO, r1); + ldxi_f(r0, _FP_REGNO, alloca_offset - 8); + FCNVXF_S_D(r0, r0); +} + +static void +_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + FCNVXT_S_S(r1, rn(reg)); + stxi_f(alloca_offset - 8, _FP_REGNO, rn(reg)); + ldxi(r0, _FP_REGNO, alloca_offset - 8); + jit_unget_reg(reg); +} + +static void +_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + FCNVXT_D_S(r1, rn(reg)); + stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg)); + ldxi(r0, _FP_REGNO, alloca_offset - 8); + jit_unget_reg(reg); +} + +static void +_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) +{ + ldi_f(r0, (jit_word_t)i0); +} + +static void +_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) +{ + ldi_d(r0, (jit_word_t)i0); +} + +#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 fopi(name) fpr_opi(name, f, 32) +#define dopi(name) fpr_opi(name, d, 64) + +fopi(add) +dopi(add) +fopi(sub) +dopi(sub) +fopi(mul) +dopi(mul) +fopi(div) +dopi(div) + +static void +_cmpr_f(jit_state_t *_jit, jit_word_t c, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + LDI(0, r0); + FCMP_S_(r1, r2, c); + FTEST(); + LDI(1, r0); +} + +static void +_cmpi_f(jit_state_t *_jit, jit_word_t c, + jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0) +{ + jit_int32_t reg = jit_get_reg(jit_class_fpr); + movi_f(rn(reg), i0); + cmpr_f(c, r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_cmpr_d(jit_state_t *_jit, jit_word_t c, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + LDI(0, r0); + FCMP_D_(r1, r2, c); + FTEST(); + LDI(1, r0); +} + +static void +_cmpi_d(jit_state_t *_jit, jit_word_t c, + jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0) +{ + jit_int32_t reg = jit_get_reg(jit_class_fpr); + movi_d(rn(reg), i0); + cmpr_d(c, r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + assert(!(i0 & 3)); + if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) + FLDWL(i0, _R0_REGNO, r0); + else { + 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; + if (i0 >= -16 && i0 <= 15) + FLDWI(i0, r1, r0); + /* |im11a|0|t|i| */ + else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) + FLDWL(i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_f(r0, r1, 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; + assert(!(i0 & 7)); + if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) + FLDDL(i0, _R0_REGNO, r0); + else { + 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; + if (i0 >= -16 && i0 <= 15) + FLDDI(i0, r1, r0); + /* |im10a|m|a|1|i| */ + else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) + FLDDL(i0, r1, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + ldxr_d(r0, r1, 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; + assert(!(i0 & 3)); + if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) + FSTWL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_f(rn(reg), r0); + 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; + if (i0 >= -16 && i0 <= 15) + FSTWI(r1, i0, r0); + /* |im11a|0|t|i| */ + else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) + FSTWL(r1, i0, r0); + else { + 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; + assert(!(i0 & 7)); + if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) + FSTDL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + str_d(rn(reg), r0); + 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; + if (i0 >= -16 && i0 <= 15) + FSTDI(r1, i0, r0); + /* |im10a|m|a|1|i| */ + else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) + FSTDL(r1, i0, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxr_d(rn(reg), r0, r1); + jit_unget_reg(reg); + } +} + +static jit_word_t +_bcmpr_f(jit_state_t *_jit, jit_word_t c, + jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + FCMP_S_(r0, r1, c); + FTEST(); + w = _jit->pc.w; + B_N(((i0 - w) >> 2) - 2, _R0_REGNO); + NOP(); + return (w); +} + +static jit_word_t +_bcmpi_f(jit_state_t *_jit, jit_word_t c, + jit_word_t i0, jit_int32_t r0, jit_float32_t *i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + movi_f(rn(reg), i1); + FCMP_S_(r0, rn(reg), c); + FTEST(); + w = _jit->pc.w; + B_N(((i0 - w) >> 2) - 2, _R0_REGNO); + NOP(); + jit_unget_reg(reg); + return (w); +} + +static jit_word_t +_bcmpr_d(jit_state_t *_jit, jit_word_t c, + jit_word_t i0, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t w; + FCMP_D_(r0, r1, c); + FTEST(); + w = _jit->pc.w; + B_N(((i0 - w) >> 2) - 2, _R0_REGNO); + NOP(); + return (w); +} + +static jit_word_t +_bcmpi_d(jit_state_t *_jit, jit_word_t c, + jit_word_t i0, jit_int32_t r0, jit_float64_t *i1) +{ + jit_word_t w; + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + movi_d(rn(reg), i1); + FCMP_D_(r0, rn(reg), c); + FTEST(); + w = _jit->pc.w; + B_N(((i0 - w) >> 2) - 2, _R0_REGNO); + NOP(); + jit_unget_reg(reg); + return (w); +} +#endif diff --git a/lib/jit_hppa.c b/lib/jit_hppa.c new file mode 100644 index 000000000..d733231e6 --- /dev/null +++ b/lib/jit_hppa.c @@ -0,0 +1,1186 @@ +/* + * 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 PROTO 1 +# include "jit_hppa-cpu.c" +# include "jit_hppa-fpu.c" +#undef PROTO + +/* + * Prototypes + */ +#define patch(instr, node) _patch(_jit, instr, node) +static void _patch(jit_state_t*,jit_word_t,jit_node_t*); + +/* + * Initialization + */ +jit_register_t _rvs[] = { + { 0, "r0" }, /* Zero */ + /* Not register starved, so, avoid allocating r1 and rp + * due to being implicit target of ADDIL and B,L */ + { 1, "r1" }, /* Scratch */ + { 2, "rp" }, /* Return Pointer and scratch */ + { rc(sav) | 3, "r3" }, + { 19, "r19" }, /* Linkage Table */ + { rc(gpr) | 20, "r20" }, + { rc(gpr) | 21, "r21" }, + { rc(gpr) | 22, "r22" }, + { rc(gpr) | 29, "ret1" }, + { rc(gpr) | 28, "ret0" }, + /* JIT_Rx in callee save registers due to need to call + * functions to implement some instructions */ + /* JIT_R0- JIT_R2 */ + { rc(gpr) | rc(sav) | 4, "r4" }, + { rc(gpr) | rc(sav) | 5, "r5" }, + { rc(gpr) | rc(sav) | 6, "r6" }, + /* JIT_V0- JIT_V2 */ + { rc(gpr) | rc(sav) | 7, "r7" }, + { rc(sav) | rc(sav) | 8, "r8" }, + { rc(gpr) | rc(sav) | 9, "r9" }, + /* JIT_R3 */ + { rc(gpr) | rc(sav) | 10, "r10" }, + /* JIT_V3+ */ + { rc(gpr) | rc(sav) | 11, "r11" }, + { rc(gpr) | rc(sav) | 12, "r12" }, + { rc(gpr) | rc(sav) | 13, "r13" }, + { rc(gpr) | rc(sav) | 14, "r14" }, + { rc(gpr) | rc(sav) | 15, "r15" }, + { rc(gpr) | rc(sav) | 16, "r16" }, + { rc(gpr) | rc(sav) | 17, "r17" }, + { rc(gpr) | rc(sav) | 18, "r18" }, + /* Arguments */ + { rc(gpr) | rc(arg) | 23, "r23" }, + { rc(gpr) | rc(arg) | 24, "r24" }, + { rc(gpr) | rc(arg) | 25, "r25" }, + { rc(gpr) | rc(arg) | 26, "r26" }, + { 27, "dp" }, /* Data Pointer */ + { 30, "sp" }, + { 31, "r31" }, /* Link Register */ + { rc(fpr) | 31, "fr31" }, + { rc(fpr) | 30, "fr30" }, + { rc(fpr) | 29, "fr29" }, + { rc(fpr) | 28, "fr28" }, + { rc(fpr) | 27, "fr27" }, + { rc(fpr) | 26, "fr26" }, + { rc(fpr) | 25, "fr25" }, + { rc(fpr) | 24, "fr24" }, + { rc(fpr) | 23, "fr23" }, + { rc(fpr) | 22, "fr22" }, + { rc(fpr) | 11, "fr11" }, + { rc(fpr) | 10, "fr10" }, + { rc(fpr) | 9, "fr9" }, + { rc(fpr) | 8, "fr8" }, + /* Arguments */ + { rc(fpr) | rc(arg) | 7, "fr7" }, + { rc(fpr) | rc(arg) | 6, "fr6" }, + { rc(fpr) | rc(arg) | 5, "fr5" }, + { rc(fpr) | rc(arg) | 4, "fr4" }, + /* Callee Saves */ + { rc(fpr) | rc(sav) | 21, "fr21" }, + { rc(fpr) | rc(sav) | 20, "fr20" }, + { rc(fpr) | rc(sav) | 19, "fr19" }, + { rc(fpr) | rc(sav) | 18, "fr18" }, + { rc(fpr) | rc(sav) | 17, "fr17" }, + { rc(fpr) | rc(sav) | 16, "fr16" }, + { rc(fpr) | rc(sav) | 15, "fr15" }, + { rc(fpr) | rc(sav) | 14, "fr14" }, + { rc(fpr) | rc(sav) | 13, "fr13" }, + { rc(fpr) | rc(sav) | 12, "fr12" }, + { 0, "fpsr" }, + { 1, "fpe2" }, + { 2, "fpe4" }, + { 3, "fpe6" }, + { _NOREG, "" }, +}; + +/* + * Implementation + */ +void +jit_get_cpu(void) +{ + /* FIXME Expecting PARISC 2.0, for PARISC 1.0 should not use fr16-fr31 */ +} + +void +_jit_init(jit_state_t *_jit) +{ + _jitc->reglen = jit_size(_rvs) - 1; +} + +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 = params_offset; + _jitc->function->self.argi = _jitc->function->self.alen = 0; + /* float conversion */ + _jitc->function->self.aoff = alloca_offset - 8; + _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) +{ + jit_int32_t offset; + assert(_jitc->function); + switch (length) { + case 0: case 1: + break; + case 2: + _jitc->function->self.aoff = (_jitc->function->self.aoff + 1) & -2; + break; + case 3: case 4: + _jitc->function->self.aoff = (_jitc->function->self.aoff + 3) & -4; + break; + default: + _jitc->function->self.aoff = (_jitc->function->self.aoff + 7) & -8; + break; + } + offset = _jitc->function->self.aoff; + _jitc->function->self.aoff += length; + return (offset); +} + +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); + _jitc->function->self.size -= sizeof(jit_word_t); + if (_jitc->function->self.argi < 4) + offset = _jitc->function->self.argi++; + else + offset = _jitc->function->self.size; + return (jit_new_node_w(jit_code_arg, offset)); +} + +jit_node_t * +_jit_arg_f(jit_state_t *_jit) +{ + jit_int32_t offset; + assert(_jitc->function); + _jitc->function->self.size -= sizeof(jit_word_t); + if (_jitc->function->self.argi < 4) + offset = _jitc->function->self.argi++; + else + offset = _jitc->function->self.size; + 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 & 1) { + ++_jitc->function->self.argi; + _jitc->function->self.size -= sizeof(jit_word_t); + } + _jitc->function->self.size -= sizeof(jit_float64_t); + if (_jitc->function->self.argi < 4) { + offset = _jitc->function->self.argi + 1; + _jitc->function->self.argi += 2; + } + else { + /* "Standard" initial value (-52) is unaligned */ + if (_jitc->function->self.size & 7) + _jitc->function->self.size -= sizeof(jit_word_t); + offset = _jitc->function->self.size; + } + return (jit_new_node_w(jit_code_arg_d, offset)); +} + +jit_bool_t +_jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset) +{ + return (jit_arg_f_reg_p(offset)); +} + +void +_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w >= 0) + jit_extr_c(u, _R26 - v->u.w); + else + jit_ldxi_c(u, JIT_FP, v->u.w + 3); +} + +void +_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w >= 0) + jit_extr_uc(u, _R26 - v->u.w); + else + jit_ldxi_uc(u, JIT_FP, v->u.w + 3); +} + +void +_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w >= 0) + jit_extr_s(u, _R26 - v->u.w); + else + jit_ldxi_s(u, JIT_FP, v->u.w + 2); +} + +void +_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w >= 0) + jit_extr_us(u, _R26 - v->u.w); + else + jit_ldxi_us(u, JIT_FP, v->u.w + 2); +} + +void +_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) +{ + if (v->u.w >= 0) + jit_movr(u, _R26 - v->u.w); + else + jit_ldxi_i(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 >= 0) + jit_movr_f(u, _F4 - 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 >= 0) + jit_movr_d(u, _F4 - 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); + _jitc->function->call.size -= sizeof(jit_word_t); + if (_jitc->function->call.argi < 4) { + jit_movr(_R26 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; + } + else + jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, u); +} + +void +_jit_pushargi(jit_state_t *_jit, jit_word_t u) +{ + jit_int32_t regno; + assert(_jitc->function); + _jitc->function->call.size -= sizeof(jit_word_t); + if (_jitc->function->call.argi < 4) { + jit_movi(_R26 - _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 + params_offset, JIT_SP, regno); + jit_unget_reg(regno); + } +} + +void +_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) +{ + assert(_jitc->function); + _jitc->function->call.size -= sizeof(jit_word_t); + if (_jitc->function->call.argi < 4) { + jit_movr_f(_F4 - _jitc->function->call.argi, u); + if (_jitc->function->call.call & jit_call_varargs) { + jit_stxi_f(alloca_offset - 8, JIT_FP, u); + jit_ldxi(_R26 - _jitc->function->call.argi, JIT_FP, + alloca_offset - 8); + } + ++_jitc->function->call.argi; + } + else + jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, u); +} + +void +_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) +{ + jit_int32_t regno; + assert(_jitc->function); + _jitc->function->call.size -= sizeof(jit_word_t); + if (_jitc->function->call.argi < 4) { + jit_movi_f(_F4 - _jitc->function->call.argi, u); + if (_jitc->function->call.call & jit_call_varargs) { + jit_stxi_f(alloca_offset - 8, JIT_FP, + _F4 - _jitc->function->call.argi); + jit_ldxi(_R26 - _jitc->function->call.argi, + JIT_FP, alloca_offset - 8); + } + ++_jitc->function->call.argi; + } + else { + regno = jit_get_reg(jit_class_fpr); + jit_movi_f(regno, u); + jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, regno); + jit_unget_reg(regno); + } +} + +void +_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) +{ + assert(_jitc->function); + _jitc->function->call.size -= sizeof(jit_float64_t); + if (_jitc->function->call.argi & 1) { + ++_jitc->function->call.argi; + _jitc->function->call.size -= sizeof(jit_word_t); + } + if (_jitc->function->call.argi < 4) { + jit_movr_d(_F4 - (_jitc->function->call.argi + 1), u); + if (_jitc->function->call.call & jit_call_varargs) { + jit_stxi_d(alloca_offset - 8, JIT_FP, u); + jit_ldxi(_R26 - _jitc->function->call.argi, + JIT_FP, alloca_offset - 4); + jit_ldxi(_R25 - _jitc->function->call.argi, + JIT_FP, alloca_offset - 8); + } + _jitc->function->call.argi += 2; + } + else { + /* "Standard" initial value (-52) is unaligned */ + if ((_jitc->function->call.size + params_offset) & 7) + _jitc->function->call.size -= sizeof(jit_word_t); + jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, u); + } +} + +void +_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) +{ + jit_int32_t regno; + assert(_jitc->function); + _jitc->function->call.size -= sizeof(jit_float64_t); + if (_jitc->function->call.argi & 1) { + ++_jitc->function->call.argi; + _jitc->function->call.size -= sizeof(jit_word_t); + } + if (_jitc->function->call.argi < 4) { + jit_movi_d(_F4 - (_jitc->function->call.argi + 1), u); + if (_jitc->function->call.call & jit_call_varargs) { + jit_stxi_d(alloca_offset - 8, JIT_FP, + _F4 - (_jitc->function->call.argi + 1)); + jit_ldxi(_R26 - _jitc->function->call.argi, + JIT_FP, alloca_offset - 4); + jit_ldxi(_R25 - _jitc->function->call.argi, + JIT_FP, alloca_offset - 8); + } + _jitc->function->call.argi += 2; + } + else { + regno = jit_get_reg(jit_class_fpr); + jit_movi_d(regno, u); + if ((_jitc->function->call.size + params_offset) & 7) + _jitc->function->call.size -= sizeof(jit_word_t); + jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, regno); + jit_unget_reg(regno); + } +} + +jit_bool_t +_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno) +{ + jit_int32_t spec; + spec = jit_class(_rvs[regno].spec); + if (spec & jit_class_arg) { + if (spec & jit_class_gpr) { + regno = _R26 - regno; + if (regno >= 0 && regno < node->v.w) + return (1); + } + else if (spec & jit_class_fpr) { + regno = _F4 - regno; + if (regno >= 0 && regno < node->w.w) + return (1); + } + } + 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 = call->w.w = _jitc->function->call.argi; + _jitc->function->call.argi = _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; + assert(_jitc->function); + if (_jitc->function->self.alen > _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; + node = jit_calli(i0); + node->v.w = node->w.w = _jitc->function->call.argi; + _jitc->function->call.argi = _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_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; + } undo; + + _jitc->function = NULL; + + jit_reglive_setup(); + + undo.word = 0; + undo.node = NULL; + undo.patch_offset = 0; + +#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: + node->u.w = _jit->pc.w; + break; + case jit_code_label: + /* 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(subc,); + case_rrw(subc,); + case_rrr(subx,); + case_rrw(subx,); + 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(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(neg,); + case_rr(com,); + case_rr(ext, _c); + case_rr(ext, _uc); + case_rr(ext, _s); + case_rr(ext, _us); + case_rr(hton,); + 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_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_rr(st, _c); + case_wr(st, _c); + case_rr(st, _s); + case_wr(st, _s); + case_rr(st, _i); + case_wr(st, _i); + 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_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_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(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(trunc, _f_i); + case_rr(trunc, _d_i); + case_rr(ext, _f); + case_rr(ext, _d); + case_rr(ext, _d_f); + case_rr(ext, _f_d); + case_rr(abs, _f); + case_rr(abs, _d); + case_rr(neg, _f); + case_rr(neg, _d); + case_rr(sqrt, _f); + case_rr(sqrt, _d); + case_rrr(add, _f); + case_rrf(add, _f, 32); + case_rrr(add, _d); + case_rrf(add, _d, 64); + case_rrr(sub, _f); + case_rrf(sub, _f, 32); + case_rrr(sub, _d); + case_rrf(sub, _d, 64); + case_rrr(mul, _f); + case_rrf(mul, _f, 32); + case_rrr(mul, _d); + case_rrf(mul, _d, 64); + case_rrr(div, _f); + case_rrf(div, _f, 32); + case_rrr(div, _d); + case_rrf(div, _d, 64); + case_rrr(lt, _f); + case_rrf(lt, _f, 32); + case_rrr(lt, _d); + case_rrf(lt, _d, 64); + case_rrr(le, _f); + case_rrf(le, _f, 32); + case_rrr(le, _d); + case_rrf(le, _d, 64); + case_rrr(eq, _f); + case_rrf(eq, _f, 32); + case_rrr(eq, _d); + case_rrf(eq, _d, 64); + case_rrr(ge, _f); + case_rrf(ge, _f, 32); + case_rrr(ge, _d); + case_rrf(ge, _d, 64); + case_rrr(gt, _f); + case_rrf(gt, _f, 32); + case_rrr(gt, _d); + case_rrf(gt, _d, 64); + case_rrr(ne, _f); + case_rrf(ne, _f, 32); + case_rrr(ne, _d); + case_rrf(ne, _d, 64); + case_rrr(unlt, _f); + case_rrf(unlt, _f, 32); + case_rrr(unlt, _d); + case_rrf(unlt, _d, 64); + case_rrr(unle, _f); + case_rrf(unle, _f, 32); + case_rrr(unle, _d); + case_rrf(unle, _d, 64); + case_rrr(uneq, _f); + case_rrf(uneq, _f, 32); + case_rrr(uneq, _d); + case_rrf(uneq, _d, 64); + case_rrr(unge, _f); + case_rrf(unge, _f, 32); + case_rrr(unge, _d); + case_rrf(unge, _d, 64); + case_rrr(ungt, _f); + case_rrf(ungt, _f, 32); + case_rrr(ungt, _d); + case_rrf(ungt, _d, 64); + case_rrr(ltgt, _f); + case_rrf(ltgt, _f, 32); + case_rrr(ltgt, _d); + case_rrf(ltgt, _d, 64); + case_rrr(ord, _f); + case_rrf(ord, _f, 32); + case_rrr(ord, _d); + case_rrf(ord, _d, 64); + case_rrr(unord, _f); + case_rrf(unord, _f, 32); + case_rrr(unord, _d); + case_rrf(unord, _d, 64); + case_rr(ld, _f); + case_rw(ld, _f); + case_rr(ld, _d); + case_rw(ld, _d); + case_rrr(ldx, _f); + case_rrw(ldx, _f); + case_rrr(ldx, _d); + case_rrw(ldx, _d); + case_rr(st, _f); + case_wr(st, _f); + case_rr(st, _d); + case_wr(st, _d); + case_rrr(stx, _f); + case_wrr(stx, _f); + case_rrr(stx, _d); + case_wrr(stx, _d); + case_brr(blt, _f); + case_brf(blt, _f, 32); + case_brr(blt, _d); + case_brf(blt, _d, 64); + case_brr(ble, _f); + case_brf(ble, _f, 32); + case_brr(ble, _d); + case_brf(ble, _d, 64); + case_brr(beq, _f); + case_brf(beq, _f, 32); + case_brr(beq, _d); + case_brf(beq, _d, 64); + case_brr(bge, _f); + case_brf(bge, _f, 32); + case_brr(bge, _d); + case_brf(bge, _d, 64); + case_brr(bgt, _f); + case_brf(bgt, _f, 32); + case_brr(bgt, _d); + case_brf(bgt, _d, 64); + case_brr(bne, _f); + case_brf(bne, _f, 32); + case_brr(bne, _d); + case_brf(bne, _d, 64); + case_brr(bunlt, _f); + case_brf(bunlt, _f, 32); + case_brr(bunlt, _d); + case_brf(bunlt, _d, 64); + case_brr(bunle, _f); + case_brf(bunle, _f, 32); + case_brr(bunle, _d); + case_brf(bunle, _d, 64); + case_brr(buneq, _f); + case_brf(buneq, _f, 32); + case_brr(buneq, _d); + case_brf(buneq, _d, 64); + case_brr(bunge, _f); + case_brf(bunge, _f, 32); + case_brr(bunge, _d); + case_brf(bunge, _d, 64); + case_brr(bungt, _f); + case_brf(bungt, _f, 32); + case_brr(bungt, _d); + case_brf(bungt, _d, 64); + case_brr(bltgt, _f); + case_brf(bltgt, _f, 32); + case_brr(bltgt, _d); + case_brf(bltgt, _d, 64); + case_brr(bord, _f); + case_brf(bord, _f, 32); + case_brr(bord, _d); + case_brf(bord, _d, 64); + case_brr(bunord, _f); + case_brf(bunord, _f, 32); + case_brr(bunord, _d); + case_brf(bunord, _d, 64); + case jit_code_jmpr: + jmpr(rn(node->u.w)); + break; + case jit_code_jmpi: + temp = node->u.n; + assert(temp->code == jit_code_label || + temp->code == jit_code_epilog); + /* no support for jump outside jit */ + 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); + if (!(temp->flag & jit_flag_patch)) { + word = calli_p(temp->u.w); + patch(word, node); + } + else + calli(temp->u.w); + } + else + calli(node->u.w); + break; + case jit_code_prolog: + _jitc->function = _jitc->functions.ptr + node->w.w; + undo.node = node; + undo.word = _jit->pc.w; + undo.patch_offset = _jitc->patches.offset; + restart_function: + _jitc->again = 0; + 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; + goto restart_function; + } + /* remember label is defined */ + node->flag |= jit_flag_patch; + node->u.w = _jit->pc.w; + epilog(node); + _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(); + } + jit_regarg_clr(node, value); + /* update register live state */ + jit_reglive(node); + } +#undef case_brf +#undef case_brw +#undef case_brr +#undef case_wrr +#undef case_rrf +#undef case_rrrw +#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(_jitc->patches.ptr[offset].inst, word); + } + + return (_jit->code.ptr); +} + +#define CODE 1 +# include "jit_hppa-cpu.c" +# include "jit_hppa-fpu.c" +#undef CODE + +void +_emit_ldxi(jit_state_t *_jit, jit_gpr_t r0, jit_gpr_t r1, jit_word_t i0) +{ + ldxi(rn(r0), rn(r1), i0); +} + +void +_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_gpr_t r1) +{ + stxi(i0, rn(r0), rn(r1)); +} + +void +_emit_ldxi_d(jit_state_t *_jit, jit_fpr_t r0, jit_gpr_t r1, jit_word_t i0) +{ + ldxi_d(rn(r0), rn(r1), i0); +} + +void +_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_fpr_t r1) +{ + stxi_d(i0, rn(r0), 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/lightning.c b/lib/lightning.c index 30f268dc5..7242e9d12 100644 --- a/lib/lightning.c +++ b/lib/lightning.c @@ -1460,9 +1460,17 @@ _jit_optimize(jit_state_t *_jit) #endif if (_jitc->function) { if ((mask & (jit_cc_a0_reg|jit_cc_a0_chg)) == - (jit_cc_a0_reg|jit_cc_a0_chg)) - jit_regset_setbit(&_jitc->function->regset, - jit_regno(node->u.w)); + (jit_cc_a0_reg|jit_cc_a0_chg)) { + if (mask & jit_cc_a0_rlh) { + jit_regset_setbit(&_jitc->function->regset, + jit_regno(node->u.q.l)); + jit_regset_setbit(&_jitc->function->regset, + jit_regno(node->u.q.h)); + } + else + jit_regset_setbit(&_jitc->function->regset, + jit_regno(node->u.w)); + } if ((mask & (jit_cc_a1_reg|jit_cc_a1_chg)) == (jit_cc_a1_reg|jit_cc_a1_chg)) jit_regset_setbit(&_jitc->function->regset, @@ -2869,4 +2877,6 @@ _patch_register(jit_state_t *_jit, jit_node_t *node, jit_node_t *link, # include "jit_sparc.c" #elif defined(__ia64__) # include "jit_ia64.c" +#elif defined(__hppa__) +# include "jit_hppa.c" #endif