[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 03/05: Remove hppa support
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 03/05: Remove hppa support |
|
Date: |
Wed, 8 May 2019 15:49:44 -0400 (EDT) |
wingo pushed a commit to branch master
in repository guile.
commit ced3c42deeb853d508b2ebc3cd915d494aca50d0
Author: Andy Wingo <address@hidden>
Date: Wed May 8 21:40:42 2019 +0200
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(-)
diff --git a/lightening.h b/lightening.h
index a60df3a..ae32737 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 9f5b40e..3b34a15 100644
--- a/lightening/endian.h
+++ b/lightening/endian.h
@@ -27,17 +27,11 @@
#include <string.h>
#include <stddef.h>
-#if defined(__hpux) && defined(__hppa__)
-# include <machine/param.h>
-#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 68281e4..0000000
--- 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 98c39ce..0000000
--- 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 d6c56cb..0000000
--- 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, "<none>" },
-};
-
-/*
- * 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, <address@hidden>
- *
- * 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 b26e4bd..0000000
--- 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 694ea3a..8c9197e 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__)