From ced3c42deeb853d508b2ebc3cd915d494aca50d0 Mon Sep 17 00:00:00 2001 From: Andy Wingo Date: Wed, 8 May 2019 21:40:42 +0200 Subject: [PATCH] Remove hppa support This is a dead architecture without an official Debian port. --- lightening.h | 2 - lightening/endian.h | 8 - lightening/hppa-cpu.c | 2793 --------------------------------------- lightening/hppa-fpu.c | 1039 --------------- lightening/hppa.c | 1586 ---------------------- lightening/hppa.h | 134 -- lightening/lightening.c | 2 - 7 files changed, 5564 deletions(-) delete mode 100644 lightening/hppa-cpu.c delete mode 100644 lightening/hppa-fpu.c delete mode 100644 lightening/hppa.c delete mode 100644 lightening/hppa.h diff --git a/lightening.h b/lightening.h index a60df3a95..ae3273715 100644 --- a/lightening.h +++ b/lightening.h @@ -97,8 +97,6 @@ typedef struct jit_reloc # include "lightening/ppc.h" #elif defined(__sparc__) # include "lightening/sparc.h" -#elif defined(__hppa__) -# include "lightening/hppa.h" #elif defined(__aarch64__) # include "lightening/aarch64.h" #elif defined(__s390__) || defined(__s390x__) diff --git a/lightening/endian.h b/lightening/endian.h index 9f5b40ef8..3b34a1518 100644 --- a/lightening/endian.h +++ b/lightening/endian.h @@ -27,17 +27,11 @@ #include #include -#if defined(__hpux) && defined(__hppa__) -# include -#endif - #ifndef __WORDSIZE # if defined(WORDSIZE) /* ppc darwin */ # define __WORDSIZE WORDSIZE # elif defined(__SIZEOF_POINTER__) /* ppc aix */ # define __WORDSIZE (__SIZEOF_POINTER__ << 3) -# elif defined(_ILP32) /* hppa hp-ux */ -# define __WORDSIZE 32 # elif defined(_MIPS_SZPTR) /* mips irix */ # if _MIPS_SZPTR == 32 # define __WORDSIZE 32 @@ -76,8 +70,6 @@ # define __BYTE_ORDER BYTE_ORDER # elif defined(__BYTE_ORDER__) /* ppc aix */ # define __BYTE_ORDER __BYTE_ORDER__ -# elif defined(_BIG_ENDIAN) /* hppa hp-ux */ -# define __BYTE_ORDER __BIG_ENDIAN # elif defined(__i386__) /* 32 bit x86 solaris */ # define __BYTE_ORDER __LITTLE_ENDIAN # elif defined(__x86_64__) /* 64 bit x86 solaris */ diff --git a/lightening/hppa-cpu.c b/lightening/hppa-cpu.c deleted file mode 100644 index 68281e4a5..000000000 --- a/lightening/hppa-cpu.c +++ /dev/null @@ -1,2793 +0,0 @@ -/* - * Copyright (C) 2013-2017 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser 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*,int32_t, - int32_t,int32_t,int32_t); -#define f2(o,b,r,i,j) _f2(_jit,o,b,r,i,j) -static void _f2(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t) maybe_unused; -#define f3(o,b,t,i,j) _f3(_jit,o,b,t,i,j) -static void _f3(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t); -#define f7(o,r,i) _f7(_jit,o,r,i) -static void _f7(jit_state_t*,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t); -#define f9(o,r,t,cf,e1,im) _f9(_jit,o,r,t,cf,e1,im) -static void _f9(jit_state_t*, - int32_t,int32_t,int32_t, - int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t); -#define f17(o,r2,r1,c,i,n) _f17(_jit,o,r2,r1,c,i,n) -static void _f17(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t); -#define f17x(o,r2,r1,c,i,n) _f17x(_jit,o,r2,r1,c,i,n) -static void _f17x(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t); -#define f18(o,p,r,c,i,n) _f18(_jit,o,p,r,c,i,n) -static void _f18(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t); -#define f19(o,b,s,i,n) _f19(_jit,o,b,s,i,n) -static void _f19(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t) maybe_unused; -#define f20(o,t,i,g,n) _f20(_jit,o,t,i,g,n) -static void _f20(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t); -#define f21(o,t,x,y,n) _f21(_jit,o,t,x,y,n) -static void _f21(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t); -#define f22(o,b,x,r,n,p) _f22(_jit,o,b,x,r,n,p) -static void _f22(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t) maybe_unused; -#define f27(o,i,j) _f27(_jit,o,i,j) -static void _f27(jit_state_t*,int32_t,int32_t,int32_t) maybe_unused; -#define f28(o,i) _f28(_jit,o,i) -static void _f28(jit_state_t*,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t); -#define f33(o,x,r,y,z,u) _f33(_jit,o,x,r,y,z,u) -static void _f33(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t) maybe_unused; -#define f38(o,s,u,n) _f38(_jit,o,s,u,n) -static void _f38(jit_state_t*,int32_t, - int32_t,int32_t,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 BE_L_N(i,s,b) f19(0x39,b,s,i,1) -#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_N(b) f22(0x3a,b,6,0,1,0) -#define BVE_L(b) f22(0x3a,b,7,0,0,0) -#define BVE_L_N(b) f22(0x3a,b,7,0,0,1) -#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 nop(c) _nop(_jit,c) -static void _nop(jit_state_t*,int32_t); -#define movr(r0,r1) _movr(_jit,r0,r1) -static void _movr(jit_state_t*,int32_t,int32_t); -#define movi(r0,i0) _movi(_jit,r0,i0) -static void _movi(jit_state_t*,int32_t,jit_word_t); -#define movi_p(r0,i0) _movi_p(_jit,r0,i0) -static jit_word_t _movi_p(jit_state_t*,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 bswapr_us(r0,r1) extr_us(r0,r1) -# define bswapr_ui(r0,r1) movr(r0,r1) -#else -# error need bswapr 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*,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,int32_t,jit_word_t); -#define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0) -static void _rsbi(jit_state_t*,int32_t,int32_t,jit_word_t); -#define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2) -static void _mulr(jit_state_t*,int32_t,int32_t,int32_t); -#define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) -static void _muli(jit_state_t*,int32_t,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*, - int32_t,int32_t,int32_t,int32_t); -#define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0) -static void _qmuli(jit_state_t*, - int32_t,int32_t,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*, - int32_t,int32_t,int32_t,int32_t); -#define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0) -static void _qmuli_u(jit_state_t*, - int32_t,int32_t,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*,int32_t,int32_t,int32_t); -#define divi(r0,r1,i0) _divi(_jit,r0,r1,i0) -static void _divi(jit_state_t*,int32_t,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*,int32_t,int32_t,int32_t); -#define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0) -static void _divi_u(jit_state_t*,int32_t,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*,int32_t,int32_t,int32_t); -#define remi(r0,r1,i0) _remi(_jit,r0,r1,i0) -static void _remi(jit_state_t*,int32_t,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*,int32_t,int32_t,int32_t); -#define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0) -static void _remi_u(jit_state_t*,int32_t,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*, - int32_t,int32_t,int32_t,int32_t); -#define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0) -static void _qdivi(jit_state_t*, - int32_t,int32_t,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*, - int32_t,int32_t,int32_t,int32_t); -#define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0) -static void _qdivi_u(jit_state_t*, - int32_t,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,int32_t,jit_word_t); -#define lshr(r0,r1,r2) _lshr(_jit,r0,r1,r2) -static void _lshr(jit_state_t*,int32_t,int32_t,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*,int32_t,int32_t,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*,int32_t,int32_t,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,int32_t,int32_t,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, - int32_t,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*,int32_t,int32_t); -#define ldi_c(r0,i0) _ldi_c(_jit,r0,i0) -static void _ldi_c(jit_state_t*,int32_t,jit_word_t); -#define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2) -static void _ldxr_c(jit_state_t*,int32_t,int32_t,int32_t); -#define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0) -static void _ldxi_c(jit_state_t*,int32_t,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*,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*,int32_t,int32_t,jit_word_t); -#define ldr_s(r0,r1) _ldr_s(_jit,r0,r1) -static void _ldr_s(jit_state_t*,int32_t,int32_t); -#define ldi_s(r0,i0) _ldi_s(_jit,r0,i0) -static void _ldi_s(jit_state_t*,int32_t,jit_word_t); -#define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2) -static void _ldxr_s(jit_state_t*,int32_t,int32_t,int32_t); -#define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0) -static void _ldxi_s(jit_state_t*,int32_t,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*,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*,int32_t,int32_t,jit_word_t); -#define ldr(r0,r1) ldr_ui(r0,r1) -#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*,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*,int32_t,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,int32_t); -#define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2) -static void _stxr_c(jit_state_t*,int32_t,int32_t,int32_t); -#define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1) -static void _stxi_c(jit_state_t*,jit_word_t,int32_t,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,int32_t); -#define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2) -static void _stxr_s(jit_state_t*,int32_t,int32_t,int32_t); -#define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1) -static void _stxi_s(jit_state_t*,jit_word_t,int32_t,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,int32_t); -#define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2) -static void _stxr_i(jit_state_t*,int32_t,int32_t,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,int32_t,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,int32_t,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,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,int32_t,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,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,int32_t,int32_t); -#define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1) -static jit_word_t _boaddi(jit_state_t*,jit_word_t,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,int32_t,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,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,int32_t,int32_t); -#define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1) -static jit_word_t _bxaddi(jit_state_t*,jit_word_t,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,int32_t,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,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,int32_t,int32_t); -#define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1) -static jit_word_t _bosubi(jit_state_t*,jit_word_t,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,int32_t,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,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,int32_t,int32_t); -#define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1) -static jit_word_t _bxsubi(jit_state_t*,jit_word_t,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,int32_t,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,int32_t,jit_word_t); -#define jmpr(r0) _jmpr(_jit,r0) -static void _jmpr(jit_state_t*,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*,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 vastart(r0) _vastart(_jit, r0) -static void _vastart(jit_state_t*, int32_t); -#define vaarg(r0, r1) _vaarg(_jit, r0, r1) -static void _vaarg(jit_state_t*, int32_t, int32_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, int32_t o, - int32_t b, int32_t t, 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, int32_t o, - int32_t b, int32_t t, int32_t i, 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, int32_t o, - int32_t b, int32_t t, int32_t i, 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, int32_t o, int32_t b, - int32_t x, int32_t s, int32_t u, int32_t y, - int32_t c, int32_t z, int32_t m, 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, int32_t o, int32_t b, - int32_t i, int32_t s, int32_t a, int32_t y, - int32_t c, int32_t z, int32_t m, 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, int32_t o, int32_t b, - int32_t r, int32_t s, int32_t a, int32_t x, - int32_t c, int32_t y, int32_t m, 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, int32_t o, int32_t r, 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, int32_t o, - int32_t r2, int32_t r1, int32_t cf, - int32_t e1, int32_t x, int32_t e2, - int32_t e3, int32_t d, 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, - int32_t o, int32_t r, int32_t t, - int32_t cf, int32_t e1, 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, int32_t o, int32_t r2, - int32_t r1, int32_t u, int32_t v, int32_t w, - int32_t x, int32_t sa, int32_t y, 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, int32_t o, - int32_t r2, int32_t r1, int32_t c, int32_t x, - int32_t y, int32_t z, int32_t u, 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, int32_t o, int32_t r, - int32_t t, int32_t c, int32_t x, int32_t se, - int32_t y, int32_t c1, int32_t z, 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, int32_t o, int32_t t, - int32_t r, int32_t c, int32_t x, - int32_t nz, int32_t c1, 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, int32_t o, int32_t t, - int32_t i, int32_t c, int32_t x, - int32_t nz, int32_t c1, 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, int32_t o, - int32_t r2, int32_t r1, int32_t c, int32_t x, - int32_t cp, int32_t y, int32_t cpos, 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, int32_t o, - int32_t r, int32_t t, int32_t c, int32_t c1, - int32_t p, int32_t se, int32_t pos, 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, int32_t o, - int32_t t, int32_t r, int32_t c, int32_t c1, - int32_t cp, int32_t nz, int32_t cpos, 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, int32_t o, - int32_t t, int32_t i, int32_t c, int32_t c1, - int32_t cp, int32_t nz, int32_t cpos, 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, int32_t o, int32_t r2, - int32_t r1, int32_t c, int32_t i, 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, int32_t o, int32_t r, - int32_t i, int32_t c, int32_t t, 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, int32_t o, int32_t p, - int32_t r, int32_t c, int32_t i, 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, int32_t o, int32_t b, - int32_t s, int32_t i, 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, int32_t o, int32_t t, - int32_t i, int32_t g, 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, int32_t o, int32_t t, - int32_t x, int32_t y, 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, int32_t o, int32_t b, - int32_t x, int32_t r, int32_t n, 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, int32_t o, - int32_t a, int32_t b, int32_t c, int32_t d, - int32_t e, int32_t f, int32_t g, 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, int32_t o, - int32_t b, int32_t x, int32_t s, - int32_t y, int32_t m,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, int32_t o, - int32_t b, int32_t i, int32_t s, - int32_t y, int32_t m, 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, int32_t o, - int32_t b, int32_t x, int32_t s, - int32_t y, int32_t m,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, int32_t o, int32_t i, 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, int32_t o, int32_t i) -{ - assert(!(o & ~0x3f)); - assert(!(i & ~0x1ffffff)); - ii((o<<26)|i); -} - -static void -_f29(jit_state_t *_jit, int32_t o, int32_t r, - int32_t x, int32_t s, int32_t y, 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, int32_t o, int32_t b, int32_t r, - int32_t s, int32_t x, int32_t y, 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, int32_t o, int32_t t, - int32_t r, int32_t v, int32_t x, 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, int32_t o, int32_t x, - int32_t r, int32_t y, int32_t z, 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, int32_t o, int32_t o1, - int32_t x, int32_t sf, int32_t n, 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, int32_t o, int32_t op, - int32_t x, int32_t sf, int32_t n, 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, int32_t o, int32_t r, int32_t o1, - int32_t x, int32_t sf, int32_t n, 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, int32_t o, int32_t r2, - int32_t r1, int32_t o1, int32_t x, - int32_t sf, int32_t n, 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, int32_t o, - int32_t s, int32_t u, 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 -_nop(jit_state_t *_jit, int32_t i0) -{ - for (; i0 > 0; i0 -= 4) - NOP(); - assert(i0 == 0); -} - -static void -_movr(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - if (r0 != r1) - COPY(r1, r0); -} - -static void -_movi(jit_state_t *_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, 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (i0 >= -1024 && i0 <= 1023) - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (i0 >= -1023 && i0 <= 1024) - addi(r0, r1, -i0); - else { - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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 -_rsbi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (i0 >= -1024 && i0 <= 1023) - SUBI(i0, r1, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - subr(r0, rn(reg), r1); - jit_unget_reg(reg); - } -} - -static void -_mulr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, - int32_t r0, int32_t r1, int32_t r2, 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, - int32_t r0, int32_t r1, 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, - int32_t r0, int32_t r1, int32_t r2, int32_t r3) -{ - 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, - int32_t r0, int32_t r1, int32_t r2, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, 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, int32_t r0, 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, int32_t r0, int32_t r1, 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, int32_t r0, 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, int32_t r0, int32_t r1, 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, int32_t r0, 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, int32_t r0, int32_t r1, 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, int32_t r0, 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, - int32_t r0, int32_t r1, int32_t r2, 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, - int32_t r0, int32_t r1, 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, - int32_t r0, int32_t r1, int32_t r2, 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, - int32_t r0, int32_t r1, 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1 ,int32_t r2) -{ - SUBI(0x1f, r2, _R1_REGNO); - MTSAR(_R1_REGNO); - DEPW_Z(r1, 32, r0); -} - -static void -_rshr(jit_state_t *_jit, int32_t r0, int32_t r1 ,int32_t r2) -{ - SUBI(0x1f, r2, _R1_REGNO); - MTSAR(_R1_REGNO); - EXTRW(r1, 32, r0); -} - -static void -_rshr_u(jit_state_t *_jit, int32_t r0, int32_t r1 ,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, - int32_t r0, int32_t r1, 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, - int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1) -{ - ldr_uc(r0, r1); - extr_c(r0, r0); -} - -static void -_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - ldi_uc(r0, i0); - extr_c(r0, r0); -} - -static void -_ldxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - ldxr_uc(r0, r1, r2); - extr_c(r0, r0); -} - -static void -_ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - ldxi_uc(r0, r1, i0); - extr_c(r0, r0); -} - -static void -_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1) -{ - ldr_us(r0, r1); - extr_s(r0, r0); -} - -static void -_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - ldi_us(r0, i0); - extr_s(r0, r0); -} - -static void -_ldxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - ldxr_us(r0, r1, r2); - extr_s(r0, r0); -} - -static void -_ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - ldxi_us(r0, r1, i0); - extr_s(r0, r0); -} - -static void -_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0) -{ - 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, int32_t r0, int32_t r1, int32_t r2) -{ - 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, int32_t r0, int32_t r1) -{ - 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, int32_t r0) -{ - 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, int32_t r0, int32_t r1 ,int32_t r2) -{ - 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, int32_t r0, int32_t r1) -{ - 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, int32_t r0) -{ - 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, int32_t r0, int32_t r1 ,int32_t r2) -{ - 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, int32_t r0, int32_t r1) -{ - 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, int32_t r0, 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, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - 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|jit_class_nospill); - 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, int32_t r0, int32_t r1) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - 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, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - 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, int32_t r0, 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, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - 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|jit_class_nospill); - 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, int32_t r0, 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, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - 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|jit_class_nospill); - 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, int32_t r0, 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, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - 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|jit_class_nospill); - 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, int32_t r0, 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, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - 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|jit_class_nospill); - 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, int32_t r0, 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, 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, int32_t r0, 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, 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, int32_t r0, 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, 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, int32_t r0, 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, 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, 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, int32_t r0) -{ - jit_word_t dyn; - jit_word_t imm; - if (r0 != _R1_REGNO) - COPY(r0, _R1_REGNO); - /* inline $$dyncall */ - imm = _jit->pc.w; - BBI_N_GE(_R1_REGNO, 30, 0); /* 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); - dyn = _jit->pc.w; - jmpi(_jit->pc.w); - patch_at(imm, _jit->pc.w); - BVE_L_N(_R1_REGNO); - NOP(); - patch_at(dyn, _jit->pc.w); -} - -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, i0); - BVE_L_N(_R1_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 int32_t gr[] = { - _R4, _R5, _R6, _R7, _R8, - _R9, _R10, _R11, _R12, _R13, - _R14, _R15, _R16, _R17, _R18 -}; - -static int32_t fr[] = { - _F12, _F13, _F14, _F15, _F16, - _F17, _F18, _F19, _F20, _F21 -}; - -static void -_prolog(jit_state_t *_jit, jit_node_t *node) -{ - int32_t regno; - jit_word_t offset; - - if (_jitc->function->define_frame || _jitc->function->assume_frame) { - /* hppa stack grows up */ - assert(_jitc->function->self.aoff <= _jitc->function->frame); - if (_jitc->function->assume_frame) - return; - _jitc->function->self.aoff = _jitc->function->frame; - } - if (_jitc->function->allocar) { - _jitc->function->self.aoff += 63; - _jitc->function->self.aoff &= -64; - } - _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])); - } - - if (_jitc->function->allocar) { - regno = jit_get_reg(jit_class_gpr); - movi(rn(regno), _jitc->function->self.aoff); - stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno)); - jit_unget_reg(regno); - } - - if (_jitc->function->self.call & jit_call_varargs) { - for (regno = 3; regno >= _jitc->function->vagp; --regno) - stxi(params_offset - regno * 4 - 4, _FP_REGNO, rn(_R26 - regno)); - } -} - -static void -_epilog(jit_state_t *_jit, jit_node_t *node) -{ - int32_t regno; - jit_word_t offset; - - if (_jitc->function->assume_frame) - return; - /* 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); -#if defined(__hpux) - BVE_N(_RP_REGNO); -#else - BV_N(_R0_REGNO, _RP_REGNO); -#endif -} - -static void -_vastart(jit_state_t *_jit, int32_t r0) -{ - /* Initialize stack pointer to the first stack argument. */ - addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4); -} - -static void -_vaarg(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - assert(_jitc->function->self.call & jit_call_varargs); - - /* Update vararg stack pointer. */ - subi(r1, r1, 4); - - /* Load argument. */ - ldr(r0, r1); -} - -static void -_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label) -{ - jit_word_t w; - union { - 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/lightening/hppa-fpu.c b/lightening/hppa-fpu.c deleted file mode 100644 index 98c39ce5c..000000000 --- a/lightening/hppa-fpu.c +++ /dev/null @@ -1,1039 +0,0 @@ -/* - * Copyright (C) 2013-2017 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * Authors: - * Paulo Cesar Pereira de Andrade - */ - -#if PROTO - -/* FIXME should actually be hw model/version/etc or other constraint - * that causes a SIGSEGV if using these instructions */ -#if defined(__hpux) -# define FSTXR 0 -#else -# define FSTXR 1 -#endif - -#define f39(o,b,x,t) _f39(_jit,o,b,x,t) -static void _f39(jit_state_t*,int32_t,int32_t,int32_t,int32_t); -#define f40(o,b,x,r) _f40(_jit,o,b,x,r) -static void _f40(jit_state_t*,int32_t,int32_t,int32_t,int32_t) - maybe_unused; -#define f41(o,b,x,t) _f41(_jit,o,b,x,t) -static void _f41(jit_state_t*,int32_t,int32_t,int32_t,int32_t); -#define f42(o,b,i,r) _f42(_jit,o,b,i,r) -static void _f42(jit_state_t*,int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t, - int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t,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*,int32_t,int32_t); -#define extr_d(r0,r1) _extr_d(_jit,r0,r1) -static void _extr_d(jit_state_t*,int32_t,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*,int32_t,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*,int32_t,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*,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*,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*,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,int32_t,jit_float64_t*); -#define rsbr_f(r0,r1,r2) subr_f(r0,r2,r1) -#define rsbi_f(r0,r1,i0) _rsbi_f(_jit,r0,r1,i0) -static void _rsbi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*); -#define rsbr_d(r0,r1,r2) subr_d(r0,r2,r1) -#define rsbi_d(r0,r1,i0) _rsbi_d(_jit,r0,r1,i0) -static void _rsbi_d(jit_state_t*,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,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*,int32_t,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, - int32_t,int32_t,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, - int32_t,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, - int32_t,int32_t,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, - int32_t,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*,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*,int32_t,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*,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*,int32_t,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,int32_t); -#if FSTXR -# define stxr_f(r0,r1,r2) FSTW(r2,r1,r0) -# define stxr_d(r0,r1,r2) FSTD(r2,r1,r0) -#else -# define stxr_f(r0,r1,r2) _stxr_f(_jit,r0,r1,r2) -static void _stxr_f(jit_state_t*,int32_t,int32_t,int32_t); -# define stxr_d(r0,r1,r2) _stxr_d(_jit,r0,r1,r2) -static void _stxr_d(jit_state_t*,int32_t,int32_t,int32_t); -#endif -#define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1) -static void _stxi_f(jit_state_t*,jit_word_t,int32_t,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,int32_t); -#define stxi_d(i0,r0,r1) _stxi_d(_jit,i0,r0,r1) -static void _stxi_d(jit_state_t*,jit_word_t,int32_t,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,int32_t,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,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,int32_t,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,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) -#define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1) -static void _vaarg_d(jit_state_t*, int32_t, int32_t); -#endif - -#if CODE -static void -_f39(jit_state_t *_jit, int32_t o, - int32_t b, int32_t x, 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, int32_t o, - int32_t b, int32_t x, 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, int32_t o, - int32_t b, int32_t x, 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, int32_t o, - int32_t b, int32_t i, 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, int32_t o, - int32_t r, int32_t a, int32_t b, int32_t fmt, - int32_t c, int32_t d, int32_t e, 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, int32_t o, int32_t r, - int32_t a, int32_t s, int32_t df, int32_t sf, - int32_t b, int32_t c, int32_t d, 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, int32_t o, - int32_t r2, int32_t r1, int32_t y, int32_t fmt, - int32_t a, int32_t b, int32_t c, 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, int32_t o, - int32_t r1, int32_t r2, int32_t y, - int32_t v, int32_t f, int32_t a, int32_t b, - int32_t u, int32_t c, int32_t d, 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, int32_t o, int32_t r1, int32_t r2, - int32_t ta, int32_t ra, int32_t f, 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, int32_t o, int32_t r1, int32_t r2, - int32_t a, int32_t b, int32_t f, int32_t c, - int32_t d, int32_t e, int32_t g, 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, int32_t r0, 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, int32_t r0, 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, int32_t r0, int32_t r1) -{ - 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, int32_t r0, int32_t r1) -{ - 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, int32_t r0, jit_float32_t *i0) -{ - union { - int32_t i; - jit_float32_t f; - } data; - int32_t reg; - - if (_jitc->no_data) { - data.f = *i0; - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), data.i); - stxi_i(alloca_offset - 8, _FP_REGNO, rn(reg)); - jit_unget_reg(reg); - ldxi_f(r0, _FP_REGNO, alloca_offset - 8); - } - else - ldi_f(r0, (jit_word_t)i0); -} - -static void -_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0) -{ - union { - int32_t ii[2]; - jit_word_t w; - jit_float64_t d; - } data; - int32_t reg; - - data.d = *i0; - if (_jitc->no_data) { - data.d = *i0; - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), data.ii[0]); - stxi_i(alloca_offset - 8, _FP_REGNO, rn(reg)); - movi(rn(reg), data.ii[1]); - stxi_i(alloca_offset - 4, _FP_REGNO, rn(reg)); - jit_unget_reg(reg); - ldxi_d(r0, _FP_REGNO, alloca_offset - 8); - } - else - ldi_d(r0, (jit_word_t)i0); -} - -#define fpr_opi(name, type, size) \ -static void \ -_##name##i_##type(jit_state_t *_jit, \ - int32_t r0, int32_t r1, \ - jit_float##size##_t *i0) \ -{ \ - 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(rsb) -dopi(rsb) -fopi(mul) -dopi(mul) -fopi(div) -dopi(div) - -static void -_cmpr_f(jit_state_t *_jit, jit_word_t c, - int32_t r0, int32_t r1, 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, - int32_t r0, int32_t r1, jit_float32_t *i0) -{ - 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, - int32_t r0, int32_t r1, 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, - int32_t r0, int32_t r1, jit_float64_t *i0) -{ - 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, int32_t r0, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0, jit_word_t i0) -{ - 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, int32_t r0, int32_t r1, jit_word_t i0) -{ - 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, int32_t r0) -{ - 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); - } -} - -#if !FSTXR -static void -_stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - reg = jit_get_reg(jit_class_gpr); - addr(rn(reg), r0, r1); - str_f(rn(reg), r2); - jit_unget_reg(reg); -} - -static void -_stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - reg = jit_get_reg(jit_class_gpr); - addr(rn(reg), r0, r1); - str_d(rn(reg), r2); - jit_unget_reg(reg); -} -#endif - -static void -_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1) -{ - 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); -#if FSTXR - movi(rn(reg), i0); - stxr_f(rn(reg), r0, r1); -#else - addi(rn(reg), r0, i0); - str_f(rn(reg), r1); -#endif - jit_unget_reg(reg); - } -} - -static void -_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - 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, int32_t r0, int32_t r1) -{ - 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); -#if FSTXR - movi(rn(reg), i0); - stxr_d(rn(reg), r0, r1); -#else - addi(rn(reg), r0, i0); - str_d(rn(reg), r1); -#endif - jit_unget_reg(reg); - } -} - -static jit_word_t -_bcmpr_f(jit_state_t *_jit, jit_word_t c, - jit_word_t i0, int32_t r0, 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, int32_t r0, jit_float32_t *i1) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(jit_class_fpr|jit_class_nospill); - 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, int32_t r0, 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, int32_t r0, jit_float64_t *i1) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(jit_class_fpr|jit_class_nospill); - 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); -} - -static void -_vaarg_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - - assert(_jitc->function->self.call & jit_call_varargs); - - /* Align pointer if required. */ - reg = jit_get_reg(jit_class_gpr); - andi(rn(reg), r1, 7); - subr(r1, r1, rn(reg)); - jit_unget_reg(reg); - - /* Adjust vararg stack pointer. */ - subi(r1, r1, 8); - - /* Load argument. */ - ldr_d(r0, r1); -} -#endif diff --git a/lightening/hppa.c b/lightening/hppa.c deleted file mode 100644 index d6c56cb44..000000000 --- a/lightening/hppa.c +++ /dev/null @@ -1,1586 +0,0 @@ -/* - * Copyright (C) 2013-2019 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser General Public - * License for more details. - * - * Authors: - * Paulo Cesar Pereira de Andrade - */ - -# define JIT_SP _R30 -# define JIT_RET _R28 -# define JIT_FRET _F4 - -#define jit_arg_reg_p(i) (i >= 0 && i < 4) - -#define PROTO 1 -# include "hppa-cpu.c" -# include "hppa-fpu.c" -#undef PROTO - -/* - * Types - */ -typedef jit_pointer_t jit_va_list; - -/* - * Prototypes - */ -#define patch(instr, node) _patch(_jit, instr, node) -static void _patch(jit_state_t*,jit_word_t,jit_node_t*); - -/* libgcc */ -extern void __clear_cache(void *, void *); - -/* - * Initialization - */ -static const 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) -{ - 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; - _jitc->function->self.call = jit_call_default; - jit_alloc((jit_pointer_t *)&_jitc->function->regoff, - _jitc->reglen * sizeof(int32_t)); - - /* _no_link here does not mean the jit_link() call can be removed - * by rewriting as: - * _jitc->function->prolog = jit_new_node(jit_code_prolog); - */ - _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); -} - -int32_t -_jit_allocai(jit_state_t *_jit, int32_t length) -{ - 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; - } - if (!_jitc->realize) { - jit_inc_synth_ww(allocai, _jitc->function->self.aoff, length); - jit_dec_synth(); - } - offset = _jitc->function->self.aoff; - _jitc->function->self.aoff += length; - return (offset); -} - -void -_jit_allocar(jit_state_t *_jit, int32_t u, int32_t v) -{ - int32_t reg; - assert(_jitc->function); - jit_inc_synth_ww(allocar, u, v); - if (!_jitc->function->allocar) { - _jitc->function->aoffoff = jit_allocai(sizeof(int32_t)); - _jitc->function->allocar = 1; - } - reg = jit_get_reg(jit_class_gpr); - jit_addi(reg, v, 63); - jit_andi(reg, reg, -64); - jit_ldxi_i(u, JIT_FP, _jitc->function->aoffoff); - jit_addr(JIT_SP, JIT_SP, reg); - jit_stxi_i(_jitc->function->aoffoff, JIT_FP, u); - jit_unget_reg(reg); - jit_dec_synth(); -} - -void -_jit_ret(jit_state_t *_jit) -{ - jit_node_t *instr; - assert(_jitc->function); - jit_inc_synth(ret); - /* jump to epilog */ - instr = jit_jmpi(); - jit_patch_at(instr, _jitc->function->epilog); - jit_dec_synth(); -} - -void -_jit_retr(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(retr, u); - jit_movr(JIT_RET, u); - jit_ret(); - jit_dec_synth(); -} - -void -_jit_reti(jit_state_t *_jit, jit_word_t u) -{ - jit_inc_synth_w(reti, u); - jit_movi(JIT_RET, u); - jit_ret(); - jit_dec_synth(); -} - -void -_jit_retr_f(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(retr_f, u); - jit_movr_f(JIT_FRET, u); - jit_ret(); - jit_dec_synth(); -} - -void -_jit_reti_f(jit_state_t *_jit, jit_float32_t u) -{ - jit_inc_synth_f(reti_f, u); - jit_movi_f(JIT_FRET, u); - jit_ret(); - jit_dec_synth(); -} - -void -_jit_retr_d(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(retr_d, u); - jit_movr_d(JIT_FRET, u); - jit_ret(); - jit_dec_synth(); -} - -void -_jit_reti_d(jit_state_t *_jit, jit_float64_t u) -{ - jit_inc_synth_d(reti_d, u); - jit_movi_d(JIT_FRET, u); - jit_ret(); - jit_dec_synth(); -} - -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_bool_t -_jit_arg_register_p(jit_state_t *_jit, jit_node_t *u) -{ - assert(u->code == jit_code_arg || - u->code == jit_code_arg_f || u->code == jit_code_arg_d); - return (jit_arg_reg_p(u->u.w)); -} - -void -_jit_ellipsis(jit_state_t *_jit) -{ - jit_inc_synth(ellipsis); - if (_jitc->prepare) { - jit_link_prepare(); - assert(!(_jitc->function->call.call & jit_call_varargs)); - _jitc->function->call.call |= jit_call_varargs; - } - else { - jit_link_prolog(); - assert(!(_jitc->function->self.call & jit_call_varargs)); - _jitc->function->self.call |= jit_call_varargs; - - _jitc->function->vagp = _jitc->function->self.argi; - } - jit_dec_synth(); -} - -void -_jit_va_push(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(va_push, u); - jit_pushargr(u); - jit_dec_synth(); -} - -jit_node_t * -_jit_arg(jit_state_t *_jit) -{ - jit_node_t *node; - int32_t offset; - assert(_jitc->function); - _jitc->function->self.size -= sizeof(jit_word_t); - if (jit_arg_reg_p(_jitc->function->self.argi)) - offset = _jitc->function->self.argi++; - else - offset = _jitc->function->self.size; - node = jit_new_node_ww(jit_code_arg, offset, - ++_jitc->function->self.argn); - jit_link_prolog(); - return (node); -} - -jit_node_t * -_jit_arg_f(jit_state_t *_jit) -{ - jit_node_t *node; - int32_t offset; - assert(_jitc->function); - _jitc->function->self.size -= sizeof(jit_word_t); - if (jit_arg_reg_p(_jitc->function->self.argi)) - offset = _jitc->function->self.argi++; - else - offset = _jitc->function->self.size; - node = jit_new_node_ww(jit_code_arg_f, offset, - ++_jitc->function->self.argn); - jit_link_prolog(); - return (node); -} - -jit_node_t * -_jit_arg_d(jit_state_t *_jit) -{ - jit_node_t *node; - 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 (jit_arg_reg_p(_jitc->function->self.argi)) { - 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; - } - node = jit_new_node_ww(jit_code_arg_d, offset, - ++_jitc->function->self.argn); - jit_link_prolog(); - return (node); -} - -void -_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg); - jit_inc_synth_wp(getarg_c, u, 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); - jit_dec_synth(); -} - -void -_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg); - jit_inc_synth_wp(getarg_uc, u, 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); - jit_dec_synth(); -} - -void -_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg); - jit_inc_synth_wp(getarg_s, u, 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); - jit_dec_synth(); -} - -void -_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg); - jit_inc_synth_wp(getarg_us, u, 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); - jit_dec_synth(); -} - -void -_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg); - jit_inc_synth_wp(getarg_i, u, v); - if (v->u.w >= 0) - jit_movr(u, _R26 - v->u.w); - else - jit_ldxi_i(u, JIT_FP, v->u.w); - jit_dec_synth(); -} - -void -_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg); - jit_inc_synth_wp(putargr, u, v); - if (v->u.w >= 0) - jit_movr(_R26 - v->u.w, u); - else - jit_stxi(v->u.w, JIT_FP, u); - jit_dec_synth(); -} - -void -_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v) -{ - int32_t regno; - assert(v->code == jit_code_arg); - jit_inc_synth_wp(putargi, u, v); - if (v->u.w >= 0) - jit_movi(_R26 - v->u.w, u); - else { - regno = jit_get_reg(jit_class_gpr); - jit_movi(regno, u); - jit_stxi(v->u.w, JIT_FP, regno); - jit_unget_reg(regno); - } - jit_dec_synth(); -} - -void -_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg_f); - jit_inc_synth_wp(getarg_f, u, v); - if (v->u.w >= 0) - jit_movr_f(u, _F4 - v->u.w); - else - jit_ldxi_f(u, JIT_FP, v->u.w); - jit_dec_synth(); -} - -void -_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg_f); - jit_inc_synth_wp(putargr_f, u, v); - if (v->u.w >= 0) - jit_movr_f(_F4 - v->u.w, u); - else - jit_stxi_f(v->u.w, JIT_FP, u); - jit_dec_synth(); -} - -void -_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v) -{ - int32_t regno; - assert(v->code == jit_code_arg_f); - jit_inc_synth_fp(putargi_f, u, v); - if (v->u.w >= 0) - jit_movi_f(_R26 - v->u.w, u); - else { - regno = jit_get_reg(jit_class_fpr); - jit_movi_f(regno, u); - jit_stxi_f(v->u.w, JIT_FP, regno); - jit_unget_reg(regno); - } - jit_dec_synth(); -} - -void -_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg_d); - jit_inc_synth_wp(getarg_d, u, v); - if (v->u.w >= 0) - jit_movr_d(u, _F4 - v->u.w); - else - jit_ldxi_d(u, JIT_FP, v->u.w); - jit_dec_synth(); -} - -void -_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - assert(v->code == jit_code_arg_d); - jit_inc_synth_wp(putargr_d, u, v); - if (v->u.w >= 0) - jit_movr_d(_F4 - v->u.w, u); - else - jit_stxi_d(v->u.w, JIT_FP, u); - jit_dec_synth(); -} - -void -_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v) -{ - int32_t regno; - assert(v->code == jit_code_arg_d); - jit_inc_synth_dp(putargi_d, u, v); - if (v->u.w >= 0) - jit_movi_d(_R26 - v->u.w, u); - else { - regno = jit_get_reg(jit_class_fpr); - jit_movi_d(regno, u); - jit_stxi_d(v->u.w, JIT_FP, regno); - jit_unget_reg(regno); - } - jit_dec_synth(); -} - -void -_jit_pushargr(jit_state_t *_jit, int32_t u) -{ - assert(_jitc->function); - jit_inc_synth_w(pushargr, u); - jit_link_prepare(); - _jitc->function->call.size -= sizeof(jit_word_t); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movr(_R26 - _jitc->function->call.argi, u); - ++_jitc->function->call.argi; - } - else - jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, u); - jit_dec_synth(); -} - -void -_jit_pushargi(jit_state_t *_jit, jit_word_t u) -{ - int32_t regno; - assert(_jitc->function); - jit_inc_synth_w(pushargi, u); - jit_link_prepare(); - _jitc->function->call.size -= sizeof(jit_word_t); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - 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); - } - jit_dec_synth(); -} - -void -_jit_pushargr_f(jit_state_t *_jit, int32_t u) -{ - assert(_jitc->function); - jit_inc_synth_w(pushargr_f, u); - jit_link_prepare(); - _jitc->function->call.size -= sizeof(jit_word_t); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movr_f(_F4 - _jitc->function->call.argi, u); -#if !defined(__hpux) - /* HP-UX appears to always pass float arguments in gpr registers */ - if (_jitc->function->call.call & jit_call_varargs) -#endif - { - 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); - jit_dec_synth(); -} - -void -_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) -{ - int32_t regno; - assert(_jitc->function); - jit_inc_synth_f(pushargi_f, u); - jit_link_prepare(); - _jitc->function->call.size -= sizeof(jit_word_t); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movi_f(_F4 - _jitc->function->call.argi, u); -#if !defined(__hpux) - /* HP-UX appears to always pass float arguments in gpr registers */ - if (_jitc->function->call.call & jit_call_varargs) -#endif - { - 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); - } - jit_dec_synth(); -} - -void -_jit_pushargr_d(jit_state_t *_jit, int32_t u) -{ - assert(_jitc->function); - jit_inc_synth_w(pushargr_d, u); - jit_link_prepare(); - _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 (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movr_d(_F4 - (_jitc->function->call.argi + 1), u); -#if !defined(__hpux) - /* HP-UX appears to always pass float arguments in gpr registers */ - if (_jitc->function->call.call & jit_call_varargs) -#endif - { - 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); - } - jit_dec_synth(); -} - -void -_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) -{ - int32_t regno; - assert(_jitc->function); - jit_inc_synth_d(pushargi_d, u); - jit_link_prepare(); - _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 (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movi_d(_F4 - (_jitc->function->call.argi + 1), u); -#if !defined(__hpux) - /* HP-UX appears to always pass float arguments in gpr registers */ - if (_jitc->function->call.call & jit_call_varargs) -#endif - { - 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_dec_synth(); -} - -jit_bool_t -_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno) -{ - int32_t spec; - spec = jit_class(_rvs[regno].spec); - if (spec & jit_class_arg) { - if (spec & jit_class_gpr) { - regno -= _R23; - 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, int32_t r0) -{ - jit_node_t *call; - assert(_jitc->function); - jit_inc_synth_w(finishr, r0); - 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_dec_synth(); -} - -jit_node_t * -_jit_finishi(jit_state_t *_jit, jit_pointer_t i0) -{ - jit_node_t *node; - assert(_jitc->function); - jit_inc_synth_w(finishi, (jit_word_t)i0); - 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; - jit_dec_synth(); - return (node); -} - -void -_jit_retval_c(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_c, r0); - jit_extr_c(r0, JIT_RET); - jit_dec_synth(); -} - -void -_jit_retval_uc(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_uc, r0); - jit_extr_uc(r0, JIT_RET); - jit_dec_synth(); -} - -void -_jit_retval_s(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_s, r0); - jit_extr_s(r0, JIT_RET); - jit_dec_synth(); -} - -void -_jit_retval_us(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_us, r0); - jit_extr_us(r0, JIT_RET); - jit_dec_synth(); -} - -void -_jit_retval_i(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_i, r0); - jit_movr(r0, JIT_RET); - jit_dec_synth(); -} - -void -_jit_retval_f(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_f, r0); - jit_movr_f(r0, JIT_FRET); - jit_dec_synth(); -} - -void -_jit_retval_d(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_d, r0); - jit_movr_d(r0, JIT_FRET); - jit_dec_synth(); -} - -jit_pointer_t -_emit_code(jit_state_t *_jit) -{ - jit_node_t *node; - jit_node_t *temp; - jit_word_t word; - int32_t value; - int32_t offset; - struct { - jit_node_t *node; - jit_word_t word; -#if DEVEL_DISASSEMBLER - jit_word_t prevw; -#endif - int32_t patch_offset; - } undo; -#if DEVEL_DISASSEMBLER - jit_word_t prevw; -#endif - - _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 -#if DEVEL_DISASSEMBLER - prevw = _jit->pc.w; -#endif - for (node = _jitc->head; node; node = node->next) { - if (_jit->pc.uc >= _jitc->code.end) - return (NULL); - -#if DEVEL_DISASSEMBLER - node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw; - prevw = _jit->pc.w; -#endif - value = jit_classify(node->code); - jit_regarg_set(node, value); - switch (node->code) { - case jit_code_align: - assert(!(node->u.w & (node->u.w - 1)) && - node->u.w <= sizeof(jit_word_t)); - if (node->u.w == sizeof(jit_word_t) && - (word = _jit->pc.w & (sizeof(jit_word_t) - 1))) - nop(sizeof(jit_word_t) - word); - break; - 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_rrw(rsb,); - 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, _us); - case_rr(hton, _ui); - 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_rrf(rsb, _f, 32); - case_rrr(sub, _d); - case_rrf(sub, _d, 64); - case_rrf(rsb, _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: - 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) - jmpi(temp->u.w); - else { - word = jmpi_p(_jit->pc.w); - patch(word, node); - } - } - else - jmpi(node->u.w); - 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; -#if DEVEL_DISASSEMBLER - undo.prevw = prevw; -#endif - 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; -#if DEVEL_DISASSEMBLER - prevw = undo.prevw; -#endif - _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_va_start: - vastart(rn(node->u.w)); - break; - case jit_code_va_arg: - vaarg(rn(node->u.w), rn(node->v.w)); - break; - case jit_code_va_arg_d: - vaarg_d(rn(node->u.w), rn(node->v.w)); - break; - case jit_code_live: - case jit_code_arg: case jit_code_ellipsis: - case jit_code_va_push: - case jit_code_allocai: case jit_code_allocar: - case jit_code_arg_f: case jit_code_arg_d: - case jit_code_va_end: - case jit_code_ret: - case jit_code_retr: case jit_code_reti: - case jit_code_retr_f: case jit_code_reti_f: - case jit_code_retr_d: case jit_code_reti_d: - case jit_code_getarg_c: case jit_code_getarg_uc: - case jit_code_getarg_s: case jit_code_getarg_us: - case jit_code_getarg_i: - case jit_code_getarg_f: case jit_code_getarg_d: - case jit_code_putargr: case jit_code_putargi: - case jit_code_putargr_f: case jit_code_putargi_f: - case jit_code_putargr_d: case jit_code_putargi_d: - case jit_code_pushargr: case jit_code_pushargi: - case jit_code_pushargr_f: case jit_code_pushargi_f: - case jit_code_pushargr_d: case jit_code_pushargi_d: - case jit_code_retval_c: case jit_code_retval_uc: - case jit_code_retval_s: case jit_code_retval_us: - case jit_code_retval_i: - case jit_code_retval_f: case jit_code_retval_d: - case jit_code_prepare: - case jit_code_finishr: case jit_code_finishi: - break; - default: - abort(); - } - jit_regarg_clr(node, value); - assert(_jitc->regarg == 0 && _jitc->synth == 0); - /* 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); - } - - jit_flush(_jit->code.ptr, _jit->pc.uc); - - return (_jit->code.ptr); -} - -#define CODE 1 -# include "hppa-cpu.c" -# include "hppa-fpu.c" -#undef CODE - -void -jit_flush(void *fptr, void *tptr) -{ - jit_word_t f, t, s; - s = sysconf(_SC_PAGE_SIZE); - f = (jit_word_t)fptr & -s; - t = (((jit_word_t)tptr) + s - 1) & -s; -#if defined(__hppa) -/* --- parisc2.0.pdf --- - Programming Note - -The minimum spacing that is guaranteed to work for "self-modifying code" is -shown in the code segment below. Since instruction prefetching is permitted, -any data cache flushes must be separated from any instruction cache flushes -by a SYNC. This will ensure that the "new" instruction will be written to -memory prior to any attempts at prefetching it as an instruction. - - LDIL l%newinstr,rnew - LDW r%newinstr(0,rnew),temp - LDIL l%instr,rinstr - STW temp,r%instr(0,rinstr) - FDC r%instr(0,rinstr) - SYNC - FIC r%instr(rinstr) - SYNC - instr ... - (at least seven instructions) - -This sequence assumes a uniprocessor system. In a multiprocessor system, -software must ensure no processor is executing code which is in the process -of being modified. -*/ - -/* - Adapted from ffcall/trampoline/cache-hppa.c:__TR_clear_cache to -loop over addresses as it is unlikely from and to addresses would fit in -at most two cachelines. - FIXME A cache line can be 16, 32, or 64 bytes. - */ - /* - * Copyright 1995-1997 Bruno Haible, - * - * This is free software distributed under the GNU General Public Licence - * described in the file COPYING. Contact the author if you don't have this - * or can't live with it. There is ABSOLUTELY NO WARRANTY, explicit or implied, - * on this software. - */ - { - jit_word_t n = f + 32; - register int u, v; - for (; f <= t; n = f + 32, f += 64) { - asm volatile ("fdc 0(0,%0)" - "\n\t" "fdc 0(0,%1)" - "\n\t" "sync" - : - : "r" (f), "r" (n) - ); - asm volatile ("mfsp %%sr0,%1" - "\n\t" "ldsid (0,%4),%0" - "\n\t" "mtsp %0,%%sr0" - "\n\t" "fic 0(%%sr0,%2)" - "\n\t" "fic 0(%%sr0,%3)" - "\n\t" "sync" - "\n\t" "mtsp %1,%%sr0" - "\n\t" "nop" - "\n\t" "nop" - "\n\t" "nop" - "\n\t" "nop" - "\n\t" "nop" - "\n\t" "nop" - : "=r" (u), "=r" (v) - : "r" (f), "r" (n), "r" (f) - ); - } - } -#else - /* This is supposed to work but appears to fail on multiprocessor systems */ - __clear_cache((void *)f, (void *)t); -#endif -} - -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) -{ - 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/lightening/hppa.h b/lightening/hppa.h deleted file mode 100644 index b26e4bd68..000000000 --- a/lightening/hppa.h +++ /dev/null @@ -1,134 +0,0 @@ -/* - * Copyright (C) 2013-2017 Free Software Foundation, Inc. - * - * This file is part of GNU lightning. - * - * GNU lightning is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU lightning 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 Lesser 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 { - _R0, /* Always zero */ - _R1, /* ADDIL implicit target */ - _R2, /* B,L implicit target */ -#define jit_r_num() 4 -#define jit_r(n) ((n) < 3 ? _R4 + (n) : _R10 + (n) - 3) -#define jit_v_num() 11 -#define jit_v(n) ((n) < 3 ? _R7 + (n) : _R11 + (n) - 3) -#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_R3 _R10 -#define JIT_V0 _R7 -#define JIT_V1 _R8 -#define JIT_V2 _R9 -#define JIT_V3 _R11 -#define JIT_V4 _R12 -#define JIT_V5 _R13 -#define JIT_V6 _R14 -#define JIT_V7 _R15 -#define JIT_V8 _R16 -#define JIT_V9 _R17 -#define JIT_V10 _R18 - _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 -#define JIT_F6 _F18 -#define JIT_F7 _F19 -#define JIT_F8 _F20 -#define JIT_F9 _F21 - /* 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; - -#endif /* _jit_hppa */ diff --git a/lightening/lightening.c b/lightening/lightening.c index 694ea3ac9..8c9197e0e 100644 --- a/lightening/lightening.c +++ b/lightening/lightening.c @@ -324,8 +324,6 @@ jit_patch_there(jit_state_t* _jit, jit_reloc_t reloc, jit_pointer_t addr) # include "ppc.c" #elif defined(__sparc__) # include "sparc.c" -#elif defined(__hppa__) -# include "hppa.c" #elif defined(__aarch64__) # include "aarch64.c" #elif defined(__s390__) || defined(__s390x__)