From 570f361c6c8308ddc574d6308b50263175cae59e Mon Sep 17 00:00:00 2001 From: Andy Wingo Date: Wed, 8 May 2019 21:41:46 +0200 Subject: [PATCH] Remove Sparc support Sadly, this is a dead architecture, without an official Debian port. Rest in peace! --- lightening.h | 2 - lightening/lightening.c | 2 - lightening/sparc-cpu.c | 2568 --------------------------------------- lightening/sparc-fpu.c | 1499 ----------------------- lightening/sparc.c | 1948 ----------------------------- lightening/sparc.h | 102 -- 6 files changed, 6121 deletions(-) delete mode 100644 lightening/sparc-cpu.c delete mode 100644 lightening/sparc-fpu.c delete mode 100644 lightening/sparc.c delete mode 100644 lightening/sparc.h diff --git a/lightening.h b/lightening.h index ae3273715..c3163486e 100644 --- a/lightening.h +++ b/lightening.h @@ -95,8 +95,6 @@ typedef struct jit_reloc # include "lightening/arm.h" #elif defined(__ppc__) || defined(__powerpc__) # include "lightening/ppc.h" -#elif defined(__sparc__) -# include "lightening/sparc.h" #elif defined(__aarch64__) # include "lightening/aarch64.h" #elif defined(__s390__) || defined(__s390x__) diff --git a/lightening/lightening.c b/lightening/lightening.c index 8c9197e0e..0973d8a69 100644 --- a/lightening/lightening.c +++ b/lightening/lightening.c @@ -322,8 +322,6 @@ jit_patch_there(jit_state_t* _jit, jit_reloc_t reloc, jit_pointer_t addr) # include "arm.c" #elif defined(__ppc__) || defined(__powerpc__) # include "ppc.c" -#elif defined(__sparc__) -# include "sparc.c" #elif defined(__aarch64__) # include "aarch64.c" #elif defined(__s390__) || defined(__s390x__) diff --git a/lightening/sparc-cpu.c b/lightening/sparc-cpu.c deleted file mode 100644 index 81f92ce23..000000000 --- a/lightening/sparc-cpu.c +++ /dev/null @@ -1,2568 +0,0 @@ -/* - * Copyright (C) 2013-2017, 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 - */ - -#if PROTO -# define _G2_REGNO 0x02 -# define _G3_REGNO 0x03 -# define _G4_REGNO 0x04 -# define _O0_REGNO 0x08 -# define _O1_REGNO 0x09 -# define _SP_REGNO 0x0e -# define _FP_REGNO 0x1e -# define _O7_REGNO 0x0f -# define _L0_REGNO 0x10 -# define _L1_REGNO 0x11 -# define _L2_REGNO 0x12 -# define _L3_REGNO 0x13 -# define _L4_REGNO 0x14 -# define _L5_REGNO 0x15 -# define _L6_REGNO 0x16 -# define _L7_REGNO 0x17 -# define _I7_REGNO 0x1f -/* - * - previous stack frame - * fp ---- - * fp- local variables (in lightning, 8 bytes space for float conversion) - * fp- alloca - * sp+ stack arguments - * sp+ 6 words to save register arguments - * sp+ 1 word for hidden address of aggregate return value (32 bits only) - * sp+ 16 words for in and local registers - * sp ---- - * decreasing memory address - next stack frame (not yet allocated) - */ -# define stack_framesize ((16 + (__WORDSIZE == 32) + 6) * sizeof(jit_word_t)) -typedef union { - struct { uint32_t b: 2; } op; - struct { uint32_t _: 2; uint32_t b: 1; } a; - struct { uint32_t _: 2; uint32_t b: 5; } rd; - struct { uint32_t _: 2; uint32_t b: 30; } disp30; - struct { uint32_t _: 3; uint32_t b: 4; } cond; - struct { uint32_t _: 7; uint32_t b: 3; } op2; - struct { uint32_t _: 7; uint32_t b: 6; } op3; - struct { uint32_t _: 10; uint32_t b: 1; } cc1; - struct { uint32_t _: 10; uint32_t b: 22; } imm22; - struct { uint32_t _: 10; uint32_t b: 22; } disp22; - struct { uint32_t _: 11; uint32_t b: 1; } cc0; - struct { uint32_t _: 12; uint32_t b: 1; } p; - struct { uint32_t _: 13; uint32_t b: 19; } disp19; - struct { uint32_t _: 13; uint32_t b: 5; } rs1; - struct { uint32_t _: 18; uint32_t b: 1; } i; - struct { uint32_t _: 18; uint32_t b: 9; } opf; - struct { uint32_t _: 19; uint32_t b: 1; } x; - struct { uint32_t _: 19; uint32_t b: 8; } asi; - struct { uint32_t _: 19; uint32_t b: 6; } res; - struct { uint32_t _: 19; uint32_t b: 13; } simm13; - struct { uint32_t _: 20; uint32_t b: 7; } asix; - struct { uint32_t _: 20; uint32_t b: 6; } asis; - struct { uint32_t _: 26; uint32_t b: 6; } shim; - struct { uint32_t _: 25; uint32_t b: 7; } imm7; - struct { uint32_t _: 27; uint32_t b: 5; } rs2; - int32_t v; -} jit_instr_t; -# define ii(i) *_jit->pc.ui++ = i -# define s7_p(imm) ((imm) <= 63 && (imm) >= -64) -# define s13_p(imm) ((imm) <= 4095 && (imm) >= -4096) -# define s19_p(imm) ((imm) <= 262143 && (imm) >= -262144) -# define s22_p(imm) ((imm) <= 2097151 && (imm) >= -20971512) -# define s30_p(imm) ((imm) <= 536870911 && (imm) >= -536870912) -# define f1(op, disp30) _f1(_jit, op, disp30) -static void _f1(jit_state_t*,int32_t,int32_t); -# define f2r(op, rd, op2, imm22) _f2r(_jit, op, rd, op2, imm22) -static void _f2r(jit_state_t*,int32_t,int32_t,int32_t,int32_t); -# define f2b(op, a, cond, op2, disp22) _f2b(_jit, op, a, cond, op2, disp22) -static void -_f2b(jit_state_t*,int32_t,int32_t,int32_t,int32_t,int32_t); -# if __WORDSIZE == 64 -# define f2bp(op,a,cond,op2,cc1,cc0,p,disp19) \ - _f2bp(_jit,op,a,cond,op2,cc1,cc0,p,disp19) -static void -_f2bp(jit_state_t*,int32_t,int32_t,int32_t,int32_t,int32_t, - int32_t,int32_t,int32_t); -# endif -# define f3r(op, rd, op3, rs1, rs2) _f3r(_jit, op, rd, op3, rs1, rs2) -static void _f3r(jit_state_t*, - int32_t,int32_t,int32_t,int32_t,int32_t); -# if __WORDSIZE == 64 -# define f3rx(op, rd, op3, rs1, rs2) _f3rx(_jit, op, rd, op3, rs1, rs2) -static void _f3rx(jit_state_t*, - int32_t,int32_t,int32_t,int32_t,int32_t); -# endif -# define f3i(op, rd, op3, rs1, simm13) _f3i(_jit, op, rd, op3, rs1, simm13) -static void _f3i(jit_state_t*, - int32_t,int32_t,int32_t,int32_t,int32_t); -# define f3s(op, rd, op3, rs1, simm13) _f3s(_jit, op, rd, op3, rs1, simm13) -static void _f3s(jit_state_t*, - int32_t,int32_t,int32_t,int32_t,int32_t); -# define f3t(cond, rs1, i, ri) _f3t(_jit, cond, rs1, i, ri) -static void _f3t(jit_state_t*,int32_t,int32_t,int32_t,int32_t) - maybe_unused; -# define f3a(op, rd, op3, rs1, rs2) _f3a(_jit, op, rd, op3, rs1, asi, rs2) -static void _f3a(jit_state_t*,int32_t, - int32_t,int32_t,int32_t,int32_t,int32_t) - maybe_unused; -# define LDSB(rs1, rs2, rd) f3r(3, rd, 9, rs1, rs2) -# define LDSBI(rs1, imm, rd) f3i(3, rd, 9, rs1, imm) -# define LDSH(rs1, rs2, rd) f3r(3, rd, 10, rs1, rs2) -# define LDSHI(rs1, imm, rd) f3i(3, rd, 10, rs1, imm) -# define LDUB(rs1, rs2, rd) f3r(3, rd, 1, rs1, rs2) -# define LDUBI(rs1, imm, rd) f3i(3, rd, 1, rs1, imm) -# define LDUH(rs1, rs2, rd) f3r(3, rd, 2, rs1, rs2) -# define LDUHI(rs1, imm, rd) f3i(3, rd, 2, rs1, imm) -# if __WORDSIZE == 32 -# define LD(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2) -# define LDI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm) -# define LDD(rs1, rs2, rd) f3r(3, rd, 3, rs1, rs2) -# define LDDI(rs1, imm, rd) f3i(3, rd, 3, rs1, imm) -# else -# define LDSW(rs1, rs2, rd) f3r(3, rd, 8, rs1, rs2) -# define LDSWI(rs1, imm, rd) f3i(3, rd, 8, rs1, imm) -# define LDUW(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2) -# define LDUWI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm) -# define LDX(rs1, rs2, rd) f3r(3, rd, 11, rs1, rs2) -# define LDXI(rs1, imm, rd) f3i(3, rd, 11, rs1, imm) -# endif -# define LDSBA(rs1, rs2, asi, rd) f3a(3, rd, 25, rs1, asi, rs2) -# define LDSHA(rs1, rs2, asi, rd) f3a(3, rd, 26, rs1, asi, rs2) -# define LDUBA(rs1, rs2, asi, rd) f3a(3, rd, 17, rs1, asi, rs2) -# define LDUHA(rs1, rs2, asi, rd) f3a(3, rd, 18, rs1, asi, rs2) -# if __WORDSIZE == 32 -# define LDA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2) -# define LDDA(rs1, rs2, asi, rd) f3a(3, rd, 19, rs1, asi, rs2) -# else -# define LDSWA(rs1, rs2, asi, rd) f3a(3, rd, 24, rs1, asi, rs2) -# define LDUWA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2) -# define LDXA(rs1, rs2, asi, rd) f3a(3, rd, 27, rs1, asi, rs2) -# endif -# define LDC(rs1, rs2, rd) f3r(3, rd, 48, rs1, rs2) -# define LDCI(rs1, imm, rd) f3i(3, rd, 48, rs1, imm) -# define LDDC(rs1, rs2, rd) f3r(3, rd, 51, rs1, rs2) -# define LDDCI(rs1, imm, rd) f3i(3, rd, 51, rs1, imm) -# define LDCSR(rs1, rs2, rd) f3r(3, rd, 49, rs1, rs2) -# define LDCSRI(rs1, imm, rd) f3i(3, rd, 49, rs1, imm) -# define STB(rd, rs1, rs2) f3r(3, rd, 5, rs1, rs2) -# define STBI(rd, rs1, imm) f3i(3, rd, 5, rs1, imm) -# define STH(rd, rs1, rs2) f3r(3, rd, 6, rs1, rs2) -# define STHI(rd, rs1, imm) f3i(3, rd, 6, rs1, imm) -# if __WORDSIZE == 32 -# define ST(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2) -# define STI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm) -# define STD(rrd, s1, rs2) f3r(3, rd, 7, rs1, rs2) -# define STDI(rd, rs1, imm) f3i(3, rd, 7, rs1, imm) -# else -# define STW(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2) -# define STWI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm) -# define STX(rd, rs1, rs2) f3r(3, rd, 14, rs1, rs2) -# define STXI(rd, rs1, imm) f3i(3, rd, 14, rs1, imm) -# endif -# define STBA(rd, rs1, rs2) f3a(3, rd, 21, rs1, asi, rs2) -# define STHA(rd, rs1, rs2) f3a(3, rd, 22, rs1, asi, rs2) -# if __WORDSIZE == 32 -# define STA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2) -# define STDA(rd, rs1, rs2) f3a(3, rd, 23, rs1, asi, rs2) -# else -# define STWA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2) -# define STXA(rd, rs1, rs2) f3a(3, rd, 30, rs1, asi, rs2) -# endif -# define STC(rd, rs1, rs2) f3r(3, rd, 52, rs1, rs2) -# define STCI(rd, rs1, imm) f3i(3, rd, 52, rs1, imm) -# define STDC(rd, rs1, rs2) f3r(3, rd, 55, rs1, rs2) -# define STDCI(rd, rs1, imm) f3i(3, rd, 55, rs1, imm) -# define STCSR(rd, rs1, rs2) f3r(3, rd, 53, rs1, rs2) -# define STCSRI(rd, rs1, imm) f3i(3, rd, 53, rs1, imm) -# define STDCQ(rd, rs1, rs2) f3r(3, rd, 54, rs1, rs2) -# define STDCQI(rd, rs1, imm) f3i(3, rd, 54, rs1, imm) -# define LDSTUB(rs1, rs2, rd) f3r(3, rd, 13, rs1, rs2) -# define LDSTUBI(rs1, imm, rd) f3r(3, rd, 13, rs1, imm) -# define LDSTUBA(rs1, rs2, asi, rd) f3a(3, rd, 21, rs1, asi, rs2) -# define SWAP(rs1, rs2, rd) f3r(3, rd, 15, rs1, rs2) -# define SWAPI(rs1, imm, rd) f3r(3, rd, 15, rs1, imm) -# define SWAPA(rs1, rs2, asi, rd) f3a(3, rd, 23, rs1, asi, rs2) -# define NOP() SETHI(0, 0) -# define HI(im) ((im) >> 10) -# define LO(im) ((im) & 0x3ff) -# define SETHI(im, rd) f2r(0, rd, 4, im) -# define AND(rs1, rs2, rd) f3r(2, rd, 1, rs1, rs2) -# define ANDI(rs1, imm, rd) f3i(2, rd, 1, rs1, imm) -# define ANDcc(rs1, rs2, rd) f3r(2, rd, 17, rs1, rs2) -# define ANDIcc(rs1, imm, rd) f3i(2, rd, 17, rs1, imm) -# define BTST(rs1, rs2) ANDcc(rs1, rs2, 0) -# define BTSTI(rs1, imm) ANDIcc(rs1, imm, 0) -# define ANDN(rs1, rs2, rd) f3r(2, rd, 5, rs1, rs2) -# define ANDNI(rs1, imm, rd) f3i(2, rd, 5, rs1, imm) -# define ANDNcc(rs1, rs2, rd) f3r(2, rd, 21, rs1, rs2) -# define ANDNIcc(rs1, imm, rd) f3i(2, rd, 21, rs1, imm) -# define OR(rs1, rs2, rd) f3r(2, rd, 2, rs1, rs2) -# define ORI(rs1, imm, rd) f3i(2, rd, 2, rs1, imm) -# define ORcc(rs1, rs2, rd) f3r(2, rd, 18, rs1, rs2) -# define ORIcc(rs1, imm, rd) f3i(2, rd, 18, rs1, imm) -# define ORN(rs1, rs2, rd) f3r(2, rd, 6, rs1, rs2) -# define ORNI(rs1, imm, rd) f3i(2, rd, 6, rs1, imm) -# define ORNcc(rs1, rs2, rd) f3r(2, rd, 22, rs1, rs2) -# define ORNIcc(rs1, imm, rd) f3i(2, rd, 22, rs1, imm) -# define XOR(rs1, rs2, rd) f3r(2, rd, 3, rs1, rs2) -# define XORI(rs1, imm, rd) f3i(2, rd, 3, rs1, imm) -# define XORcc(rs1, rs2, rd) f3r(2, rd, 19, rs1, rs2) -# define XORIcc(rs1, imm, rd) f3i(2, rd, 19, rs1, imm) -# define XNOR(rs1, rs2, rd) f3r(2, rd, 7, rs1, rs2) -# define XNORI(rs1, imm, rd) f3i(2, rd, 7, rs1, imm) -# define XNORcc(rs1, rs2, rd) f3r(2, rd, 23, rs1, rs2) -# define XNORIcc(rs1, imm, rd) f3i(2, rd, 23, rs1, imm) -# define SLL(rs1, rs2, rd) f3r(2, rd, 37, rs1, rs2) -# define SLLI(rs1, imm, rd) f3i(2, rd, 37, rs1, imm) -# define SRL(rs1, rs2, rd) f3r(2, rd, 38, rs1, rs2) -# define SRLI(rs1, imm, rd) f3i(2, rd, 38, rs1, imm) -# define SRA(rs1, rs2, rd) f3r(2, rd, 39, rs1, rs2) -# define SRAI(rs1, imm, rd) f3i(2, rd, 39, rs1, imm) -# if __WORDSIZE == 64 -# define SLLX(rs1, rs2, rd) f3rx(2, rd, 37, rs1, rs2) -# define SLLXI(rs1, imm, rd) f3s(2, rd, 37, rs1, imm) -# define SRLX(rs1, rs2, rd) f3rx(2, rd, 38, rs1, rs2) -# define SRLXI(rs1, imm, rd) f3s(2, rd, 38, rs1, imm) -# define SRAX(rs1, rs2, rd) f3rx(2, rd, 39, rs1, rs2) -# define SRAXI(rs1, imm, rd) f3s(2, rd, 39, rs1, imm) -# endif -# define ADD(rs1, rs2, rd) f3r(2, rd, 0, rs1, rs2) -# define ADDI(rs1, imm, rd) f3i(2, rd, 0, rs1, imm) -# define ADDcc(rs1, rs2, rd) f3r(2, rd, 16, rs1, rs2) -# define ADDIcc(rs1, imm, rd) f3i(2, rd, 16, rs1, imm) -# define ADDX(rs1, rs2, rd) f3r(2, rd, 8, rs1, rs2) -# define ADDXI(rs1, imm, rd) f3i(2, rd, 8, rs1, imm) -# define ADDXcc(rs1, rs2, rd) f3r(2, rd, 24, rs1, rs2) -# define ADDXIcc(rs1, imm, rd) f3i(2, rd, 24, rs1, imm) -# define TADDcc(rs1, rs2, rd) f3r(2, rd, 32, rs1, rs2) -# define TADDIcc(rs1, imm, rd) f3i(2, rd, 32, rs1, imm) -# define TADDccTV(rs1, rs2, rd) f3r(2, rd, 34, rs1, rs2) -# define TADDIccTV(rs1, imm, rd) f3i(2, rd, 34, rs1, imm) -# define SUB(rs1, rs2, rd) f3r(2, rd, 4, rs1, rs2) -# define NEG(rs1, rd) SUB(0, rs1, rd) -# define SUBI(rs1, imm, rd) f3i(2, rd, 4, rs1, imm) -# define SUBcc(rs1, rs2, rd) f3r(2, rd, 20, rs1, rs2) -# define SUBIcc(rs1, imm, rd) f3i(2, rd, 20, rs1, imm) -# define CMP(rs1, rs2) SUBcc(rs1, rs2, 0) -# define CMPI(rs1, imm) SUBIcc(rs1, imm, 0) -# define SUBX(rs1, rs2, rd) f3r(2, rd, 12, rs1, rs2) -# define SUBXI(rs1, imm, rd) f3i(2, rd, 12, rs1, imm) -# define SUBXcc(rs1, rs2, rd) f3r(2, rd, 28, rs1, rs2) -# define SUBXIcc(rs1, imm, rd) f3i(2, rd, 28, rs1, imm) -# define TSUBcc(rs1, rs2, rd) f3r(2, rd, 33, rs1, rs2) -# define TDADDIcc(rs1, imm, rd) f3i(2, rd, 33, rs1, imm) -# define TSUBccTV(rs1, rs2, rd) f3r(2, rd, 35, rs1, rs2) -# define TSUBIccTV(rs1, imm, rd) f3i(2, rd, 35, rs1, imm) -# define MULScc(rs1, rs2, rd) f3r(2, rd, 36, rs1, rs2) -# define MULSIcc(rs1, imm, rd) f3i(2, rd, 36, rs1, imm) -# define UMUL(rs1, rs2, rd) f3r(2, rd, 10, rs1, rs2) -# define UMULI(rs1, imm, rd) f3i(2, rd, 10, rs1, imm) -# define SMUL(rs1, rs2, rd) f3r(2, rd, 11, rs1, rs2) -# define SMULI(rs1, imm, rd) f3i(2, rd, 11, rs1, imm) -# define UMULcc(rs1, rs2, rd) f3r(2, rd, 26, rs1, rs2) -# define UMULIcc(rs1, imm, rd) f3i(2, rd, 26, rs1, imm) -# define SMULcc(rs1, rs2, rd) f3r(2, rd, 27, rs1, rs2) -# define SMULIcc(rs1, imm, rd) f3i(2, rd, 27, rs1, imm) -# define UDIV(rs1, rs2, rd) f3r(2, rd, 14, rs1, rs2) -# define UDIVI(rs1, imm, rd) f3i(2, rd, 14, rs1, imm) -# define SDIV(rs1, rs2, rd) f3r(2, rd, 15, rs1, rs2) -# define SDIVI(rs1, imm, rd) f3i(2, rd, 15, rs1, imm) -# define UDIVcc(rs1, rs2, rd) f3r(2, rd, 30, rs1, rs2) -# define UDIVIcc(rs1, imm, rd) f3i(2, rd, 30, rs1, imm) -# define SDIVcc(rs1, rs2, rd) f3r(2, rd, 31, rs1, rs2) -# define SDIVIcc(rs1, imm, rd) f3i(2, rd, 31, rs1, imm) -# if __WORDSIZE == 64 -# define MULX(rs1, rs2, rd) f3r(2, rd, 9, rs1, rs2) -# define MULXI(rs1, imm, rd) f3i(2, rd, 9, rs1, imm) -# define SDIVX(rs1, rs2, rd) f3r(2, rd, 45, rs1, rs2) -# define SDIVXI(rs1, imm, rd) f3i(2, rd, 45, rs1, imm) -# define UDIVX(rs1, rs2, rd) f3r(2, rd, 13, rs1, rs2) -# define UDIVXI(rs1, imm, rd) f3i(2, rd, 13, rs1, imm) -# endif -# define SAVE(rs1, rs2, rd) f3r(2, rd, 60, rs1, rs2) -# define SAVEI(rs1, imm, rd) f3i(2, rd, 60, rs1, imm) -# define RESTORE(rs1, rs2, rd) f3r(2, rd, 61, rs1, rs2) -# define RESTOREI(rs1, imm, rd) f3i(2, rd, 61, rs1, imm) -# define SPARC_BA 8 /* always */ -# define SPARC_BN 0 /* never */ -# define SPARC_BNE 9 /* not equal - not Z */ -# define SPARC_BNZ SPARC_BNE -# define SPARC_BE 1 /* equal - Z */ -# define SPARC_BZ SPARC_BE -# define SPARC_BG 10 /* greater - not (Z or (N xor V)) */ -# define SPARC_BLE 2 /* less or equal - Z or (N xor V) */ -# define SPARC_BGE 11 /* greater or equal - not (N xor V) */ -# define SPARC_BL 3 /* less - N xor V */ -# define SPARC_BGU 12 /* greater unsigned - not (C or Z) */ -# define SPARC_BLEU 4 /* less or equal unsigned - C or Z */ -# define SPARC_BCC 13 /* carry clear - not C */ -# define SPARC_BGEU SPARC_BCC -# define SPARC_BCS 5 /* carry set - C */ -# define SPARC_BLU SPARC_BCS -# define SPARC_BPOS 14 /* positive - not N */ -# define SPARC_BNEG 6 /* negative - N */ -# define SPARC_BVC 15 /* overflow clear - not V */ -# define SPARC_BVS 7 /* overflow set - V */ -/* Preferred BPcc integer branch opcodes */ -# if __WORDSIZE == 64 -# define SPARC_BPA 8 /* always - 1 */ -# define SPARC_BPN 0 /* never - 0 */ -# define SPARC_BPNE 9 /* not equal - not Z */ -# define SPARC_BPE 1 /* equal - Z */ -# define SPARC_BPG 10 /* greater - not (Z or (N xor V)) */ -# define SPARC_BPLE 2 /* less or equal - Z or (N xor V) */ -# define SPARC_BPGE 11 /* greater or equal - not (N xor V) */ -# define SPARC_BPL 3 /* less - N xor V */ -# define SPARC_BPGU 12 /* greater unsigned - not (C or V) */ -# define SPARC_BPLEU 4 /* less or equal unsigned - C or Z */ -# define SPARC_BPCC 13 /* carry clear (greater than or equal, unsigned) - not C */ -# define SPARC_BPCS 5 /* carry set (less than, unsigned) - C */ -# define SPARC_BPPOS 14 /* positive - not N */ -# define SPARC_BPNEG 6 /* negative - N */ -# define SPARC_BPVC 15 /* overflow clear - not V */ -# define SPARC_BPVS 7 /* overflow set - V */ -# endif -# define B(cc, imm) f2b(0, 0, cc, 2, imm) -# define Ba(cc, imm) f2b(0, 1, cc, 2, imm) -# define BA(imm) B(SPARC_BA, imm) -# define BAa(imm) Ba(SPARC_BA, imm) -# define BN(imm) B(SPARC_BN, imm) -# define BNa(imm) Ba(SPARC_BN, imm) -# define BNE(imm) B(SPARC_BNE, imm) -# define BNEa(imm) Ba(SPARC_BNE, imm) -# define BNZ(imm) BNE(imm) -# define BNZa(imm) BNEa(imm) -# define BE(imm) B(SPARC_BE, imm) -# define BEa(imm) Ba(SPARC_BE, imm) -# define BZ(imm) BE(imm) -# define BZa(imm) BEa(imm) -# define BG(imm) B(SPARC_BG, imm) -# define BGa(imm) Ba(SPARC_BG, imm) -# define BLE(imm) B(SPARC_BLE, imm) -# define BLEa(imm) Ba(SPARC_BLE, imm) -# define BGE(imm) B(SPARC_BGE, imm) -# define BGEa(imm) Ba(SPARC_BGE, imm) -# define BL(imm) B(SPARC_BL, imm) -# define BLa(imm) Ba(SPARC_BL, imm) -# define BGU(imm) B(SPARC_BGU, imm) -# define BGUa(imm) Ba(SPARC_BGU, imm) -# define BLEU(imm) B(SPARC_BLEU, imm) -# define BLEUa(imm) Ba(SPARC_BLEU, imm) -# define BCC(imm) B(SPARC_BCC, imm) -# define BCCa(imm) Ba(SPARC_BCC, imm) -# define BGEU(imm) BCC(imm) -# define BGEUa(imm) BCCa(imm) -# define BCS(imm) B(SPARC_BCS, imm) -# define BCSa(imm) Ba(SPARC_BCS, imm) -# define BLU(imm) BCS(imm) -# define BLUa(imm) BCSa(imm) -# define BPOS(imm) B(SPARC_BPOS, imm) -# define BPOSa(imm) Ba(SPARC_BPOS, imm) -# define BNEG(imm) B(SPARC_BNEG, imm) -# define BNEGa(imm) Ba(SPARC_BNEG, imm) -# define BVC(imm) B(SPARC_BVC, imm) -# define BVCa(imm) Ba(SPARC_BVC, imm) -# define BVS(imm) B(SPARC_BVS, imm) -# define BVSa(imm) Ba(SPARC_BVS, imm) -# if __WORDSIZE == 64 -# define BPccap(cc,a,cc1, cc2,p,imm) f2bp(0, a, cc, 1, cc1, cc0, p, imm) -# define BPap(cc, imm) f2bp(0, 1, cc, 1, 1, 0, p, imm) -# define BPa(cc, imm) f2bp(0, 1, cc, 1, 1, 0, 1, imm) -# define BP(cc, imm) f2bp(0, 0, cc, 1, 1, 0, 1, imm) -# define BPA(imm) BP(SPARC_BPA, imm) -# define BPN(imm) BP(SPARC_BPN, imm) -# define BNPE(imm) BP(SPARC_BPNE, imm) -# define BPE(imm) BP(SPARC_BPE, imm) -# define BPG(imm) BP(SPARC_BPG, imm) -# define BPLE(imm) BP(SPARC_BPLE, imm) -# define BPGE(imm) BP(SPARC_BPGE, imm) -# define BPL(imm) BP(SPARC_BPL, imm) -# define BPGU(imm) BP(SPARC_BPGU, imm) -# define BPLEU(imm) BP(SPARC_BPLEU, imm) -# define BPCC(imm) BP(SPARC_BPCC, imm) -# define BPCS(imm) BP(SPARC_BPCS, imm) -# define BPPOS(imm) BP(SPARC_BPPOS, imm) -# define BPNEG(imm) BP(SPARC_BPNEG, imm) -# define BPVC(imm) BP(SPARC_BPVC, imm) -# define BPVS(imm) BP(SPARC_BPVS, imm) -# endif -# define SPARC_CBA 8 /* always */ -# define SPARC_CBN 0 /* never */ -# define SPARC_CB3 7 /* 3 */ -# define SPARC_CB2 6 /* 2 */ -# define SPARC_CB23 5 /* 2 or 3 */ -# define SPARC_CB1 4 /* 1 */ -# define SPARC_CB13 3 /* 1 or 3 */ -# define SPARC_CB12 2 /* 1 or 2 */ -# define SPARC_CB123 1 /* 1 or 2 or 3 */ -# define SPARC_CB0 9 /* 0 */ -# define SPARC_CB03 10 /* 0 or 3 */ -# define SPARC_CB02 11 /* 0 or 2 */ -# define SPARC_CB023 12 /* 0 or 2 or 3 */ -# define SPARC_CB01 13 /* 0 or 1 */ -# define SPARC_CB013 14 /* 0 or 1 or 3 */ -# define SPARC_CB012 15 /* 0 or 1 or 2 */ -# define CB(cc, imm) f2b(0, 0, cc, 7, imm) -# define CBa(cc, imm) f2b(0, 1, cc, 7, imm) -# define CBA(imm) CB(SPARC_CBA, imm) -# define CBAa(imm) CBa(SPARC_CBA, imm) -# define CBN(imm) CB(SPARC_CBN, imm) -# define CBNa(imm) CBa(SPARC_CBN, imm) -# define CB3(imm) CB(SPARC_CB3, imm) -# define CB3a(imm) CBa(SPARC_CB3, imm) -# define CB2(imm) CB(SPARC_CB2, imm) -# define CB2a(imm) CBa(SPARC_CB2, imm) -# define CB23(imm) CB(SPARC_CB23, imm) -# define CB23a(imm) CBa(SPARC_CB23, imm) -# define CB1(imm) CB(SPARC_CB1, imm) -# define CB1a(imm) CBa(SPARC_CB1, imm) -# define CB13(imm) CB(SPARC_CB13, imm) -# define CB13a(imm) CBa(SPARC_CB13, imm) -# define CB12(imm) CB(SPARC_CB12, imm) -# define CB12a(imm) CBa(SPARC_CB12, imm) -# define CB123(imm) CB(SPARC_CB123, imm) -# define CB123a(imm) CBa(SPARC_CB123, imm) -# define CB0(imm) CB(SPARC_CB0, imm) -# define CB0a(imm) CBa(SPARC_CB0, imm) -# define CB03(imm) CB(SPARC_CB03, imm) -# define CB03a(imm) CBa(SPARC_CB03, imm) -# define CB02(imm) CB(SPARC_CB02, imm) -# define CB02a(imm) CBa(SPARC_CB02, imm) -# define CB023(imm) CB(SPARC_CB103, imm) -# define CB023a(imm) CBa(SPARC_CB023, imm) -# define CB01(imm) CB(SPARC_CB01, imm) -# define CB01a(imm) CBa(SPARC_CB01, imm) -# define CB013(imm) CB(SPARC_CB013, imm) -# define CB013a(imm) CBa(SPARC_CB013, imm) -# define CB012(imm) CB(SPARC_CB012, imm) -# define CB012a(imm) CBa(SPARC_CB012, imm) -# define CALLI(imm) f1(1, imm) -# define CALL(r0) JMPL(_O7_REGNO, r0, 0) -# define RETL() JMPLI(0, _O7_REGNO, 8) -# define RET() JMPLI(0, _I7_REGNO, 8) -# define JMPL(rd, rs1, rs2) f3r(2, rd, 56, rs1, rs2) -# define JMPLI(rd, rs1, imm) f3i(2, rd, 56, rs1, imm) -# define RETT(rs1, rs2) f3r(2, 0, 57, rs1, rs2) -# define RETTI(rs1, imm) f3i(2, 0, 57, rs1, imm) -# define SPARC_TA 8 /* always */ -# define SPARC_TN 0 /* never */ -# define SPARC_TNE 9 /* not equal - not Z */ -# define SPARC_TNZ SPARC_BNE -# define SPARC_TE 1 /* equal - Z */ -# define SPARC_TZ SPARC_BE -# define SPARC_TG 10 /* greater - not (Z or (N xor V)) */ -# define SPARC_TLE 2 /* less or equal - Z or (N xor V) */ -# define SPARC_TGE 11 /* greater or equal - not (N xor V) */ -# define SPARC_TL 3 /* less - N xor V */ -# define SPARC_TGU 12 /* greater unsigned - not (C or Z) */ -# define SPARC_TLEU 4 /* less or equal unsigned - C or Z */ -# define SPARC_TCC 13 /* carry clear - not C */ -# define SPARC_TGEU SPARC_BCC -# define SPARC_TCS 5 /* carry set - C */ -# define SPARC_TLU SPARC_BCS -# define SPARC_TPOS 14 /* positive - not N */ -# define SPARC_TNEG 6 /* negative - N */ -# define SPARC_TVC 15 /* overflow clear - not V */ -# define SPARC_TVS 7 /* overflow set - V */ -# define T(cc, rs1, rs2) f3t(cc, rs1, 0, rs2) -# define TI(cc, rs1, imm) f3t(cc, rs1, 1, imm) -# define TA(rs1, rs2) T(SPARC_TA, rs1, rs2) -# define TAI(rs1, imm) TI(SPARC_TA, rs1, imm) -# define TN(rs1, rs2) T(SPARC_TN, rs1, rs2) -# define TNI(rs1, imm) TI(SPARC_TN, rs1, imm) -# define TNE(rs1, rs2) T(SPARC_TNE, rs1, rs2) -# define TNEI(rs1, imm) TI(SPARC_TNE, rs1, imm) -# define TNZ(rs1, rs2) TNE(rs1, rs2) -# define TNZI(rs1, imm) TNEI(rs1, imm) -# define TE(rs1, rs2) T(SPARC_TE, rs1, rs2) -# define TEI(rs1, imm) TI(SPARC_TE, rs1, imm) -# define TZ(rs1, rs2) TE(rs1, rs2) -# define TZI(rs1, imm) TEI(rs1, imm) -# define TG(rs1, rs2) T(SPARC_TG, rs1, rs2) -# define TGI(rs1, imm) TI(SPARC_TG, rs1, imm) -# define TLE(rs1, rs2) T(SPARC_TLE, rs1, rs2) -# define TLEI(rs1, imm) TI(SPARC_TLE, rs1, imm) -# define TGE(rs1, rs2) T(SPARC_TGE, rs1, rs2) -# define TGEI(rs1, imm) TI(SPARC_TGE, rs1, imm) -# define TL(rs1, rs2) T(SPARC_TL, rs1, rs2) -# define TLI(rs1, imm) TI(SPARC_TL, rs1, imm) -# define TGU(rs1, rs2) T(SPARC_TGU, rs1, rs2) -# define TGUI(rs1, imm) TI(SPARC_TGU, rs1, imm) -# define TLEU(rs1, rs2) T(SPARC_TLEU, rs1, rs2) -# define TLEUI(rs1, imm) TI(SPARC_TLEU, rs1, imm) -# define TCC(rs1, rs2) T(SPARC_TCC, rs1, rs2) -# define TCCI(rs1, imm) TI(SPARC_TCC, rs1, imm) -# define TGEU(rs1, rs2) TCC(rs1, rs2) -# define TGEUI(rs1, imm) TCCI(rs1, imm) -# define TCS(rs1, rs2) T(SPARC_TCC, rs1, rs2) -# define TCSI(rs1, imm) TI(SPARC_TCC, rs1, imm) -# define TLU(rs1, rs2) TCS(rs1, rs2) -# define TLUI(rs1, imm) TCSI(rs1, imm) -# define TPOS(rs1, rs2) T(SPARC_TPOS, rs1, rs2) -# define TPOSI(rs1, imm) TI(SPARC_TPOS, rs1, imm) -# define TNEG(rs1, rs2) T(SPARC_TNEG, rs1, rs2) -# define TNEGI(rs1, imm) TI(SPARC_TNEG, rs1, imm) -# define TVC(rs1, rs2) T(SPARC_TVC, rs1, rs2) -# define TVCI(rs1, imm) TI(SPARC_TVC, rs1, imm) -# define TVS(rs1, rs2) T(SPARC_TVS, rs1, rs2) -# define TVSI(rs1, imm) TI(SPARC_TVS, rs1, imm) -# define RDY(rd) f3r(2, rd, 40, 0, 0) -# define RDASR(rs1, rd) f3r(2, rd, 40, rs1, 0) -# define RDPSR(rd) f3r(2, rd, 41, 0, 0) -# define RDWIM(rd) f3r(2, rd, 42, 0, 0) -# define RDTBR(rd) f3r(2, rd, 43, 0, 0) -# define WRY(rs1, rs2) f3r(2, 0, 48, rs1, rs2) -# define WRYI(rs1, imm) f3i(2, 0, 48, rs1, imm) -# define WRASR(rs1, rs2, rd) f3r(2, rd, 48, rs1, rs2) -# define WRASRI(rs1, imm, rd) f3i(2, rd, 48, rs1, imm) -# define WRPSR(rs1, rs2, rd) f3r(2, rd, 49, rs1, rs2) -# define WRPSRI(rs1, imm, rd) f3i(2, rd, 49, rs1, imm) -# define WRWIM(rs1, rs2, rd) f3r(2, rd, 50, rs1, rs2) -# define WRWIMI(rs1, imm, rd) f3i(2, rd, 50, rs1, imm) -# define WRTBR(rs1, rs2, rd) f3r(2, rd, 51, rs1, rs2) -# define WRTBRI(rs1, imm, rd) f3i(2, rd, 51, rs1, imm) -# define STBAR() f3i(2, 0, 40, 15, 0) -# define UNIMP(imm) f2r(0, 0, 0, imm) -# define FLUSH(rs1, rs2) f3r(2, 0, 59, rs1, rs2) -# define FLUSHI(rs1, im) f3i(2, 0, 59, rs1, imm) -# define nop(i0) _nop(_jit, i0) -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) XNOR(r1, 0, r0) -# define negr(r0, r1) NEG(r1, r0) -# 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); -# if __WORDSIZE == 32 -# define addcr(r0, r1, r2) ADDcc(r1, r2, r0) -# else -# define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2) -static void _addcr(jit_state_t*, int32_t, int32_t, int32_t); -# endif -# define addci(r0, r1, i0) _addci(_jit, r0, r1, i0) -static void _addci(jit_state_t*, int32_t, int32_t, jit_word_t); -# if __WORDSIZE == 32 -# define addxr(r0, r1, r2) ADDXcc(r1, r2, r0) -# else -# define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2) -static void _addxr(jit_state_t*, int32_t, int32_t, int32_t); -# endif -# 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); -# if __WORDSIZE == 32 -# define subcr(r0, r1, r2) SUBcc(r1, r2, r0) -# else -# define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2) -static void _subcr(jit_state_t*, int32_t, int32_t, int32_t); -# endif -# define subci(r0, r1, i0) _subci(_jit, r0, r1, i0) -static void _subci(jit_state_t*, int32_t, int32_t, jit_word_t); -# if __WORDSIZE == 32 -# define subxr(r0, r1, r2) SUBXcc(r1, r2, r0) -# else -# define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2) -static void _subxr(jit_state_t*, int32_t, int32_t, int32_t); -# endif -# 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); -# if __WORDSIZE == 32 -# define mulr(r0, r1, r2) UMUL(r1, r2, r0) -# else -# define mulr(r0, r1, r2) MULX(r1, r2, r0) -# endif -# define muli(r0, r1, i0) _muli(_jit, r0, r1, i0) -static void _muli(jit_state_t*, int32_t, int32_t, jit_word_t); -# if __WORDSIZE == 32 -# define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1) -# define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0) -# define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc) -static void _iqmulr(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,jit_bool_t); -# define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1) -# define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0) -# define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc) -static void _iqmuli(jit_state_t*,int32_t,int32_t, - int32_t,jit_word_t,jit_bool_t); -# else -# 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); -# endif -# 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); -# 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); -# define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1) -# define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0) -# define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc) -static void _iqdivr(jit_state_t*,int32_t,int32_t, - int32_t,int32_t,jit_bool_t); -# define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1) -# define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0) -# define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc) -static void _iqdivi(jit_state_t*,int32_t,int32_t, - int32_t,jit_word_t,jit_bool_t); -# 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); -# 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); -# 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); -# if __WORDSIZE == 32 -# define lshr(r0, r1, r2) SLL(r1, r2, r0) -# define lshi(r0, r1, i0) SLLI(r1, i0, r0) -# define rshr(r0, r1, r2) SRA(r1, r2, r0) -# define rshi(r0, r1, i0) SRAI(r1, i0, r0) -# define rshr_u(r0, r1, r2) SRL(r1, r2, r0) -# define rshi_u(r0, r1, i0) SRLI(r1, i0, r0) -# else -# define lshr(r0, r1, r2) SLLX(r1, r2, r0) -# define lshi(r0, r1, i0) SLLXI(r1, i0, r0) -# define rshr(r0, r1, r2) SRAX(r1, r2, r0) -# define rshi(r0, r1, i0) SRAXI(r1, i0, r0) -# define rshr_u(r0, r1, r2) SRLX(r1, r2, r0) -# define rshi_u(r0, r1, i0) SRLXI(r1, i0, r0) -# endif -# define bswapr_us(r0,r1) extr_us(r0,r1) -# define extr_c(r0,r1) _extr_c(_jit,r0,r1) -static void _extr_c(jit_state_t*,int32_t,int32_t); -# define extr_uc(r0,r1) andi(r0, r1, 0xff) -# define extr_s(r0,r1) _extr_s(_jit,r0,r1) -static void _extr_s(jit_state_t*,int32_t,int32_t); -# define extr_us(r0,r1) _extr_us(_jit,r0,r1) -static void _extr_us(jit_state_t*,int32_t,int32_t); -# if __WORDSIZE == 32 -# define bswapr_ui(r0,r1) movr(r0,r1) -# else -# define bswapr_ui(r0,r1) extr_ui(r0,r1) -# define bswapr_ul(r0,r1) movr(r0,r1) -# define extr_i(r0,r1) _extr_i(_jit,r0,r1) -static void _extr_i(jit_state_t*,int32_t,int32_t); -# define extr_ui(r0,r1) _extr_ui(_jit,r0,r1) -static void _extr_ui(jit_state_t*,int32_t,int32_t); -# endif -# define cr(cc, r0, r1, r2) _cr(_jit, cc, r0, r1, r2) -static void _cr(jit_state_t*,int32_t,int32_t,int32_t,int32_t); -# define cw(cc, r0, r1, i0) _cw(_jit, cc, r0, r1, i0) -static void _cw(jit_state_t*,int32_t,int32_t,int32_t,jit_word_t); -# if __WORDSIZE == 32 -# define ltr(r0, r1, r2) cr(SPARC_BL, r0, r1, r2) -# define lti(r0, r1, i0) cw(SPARC_BL, r0, r1, i0) -# define ltr_u(r0, r1, r2) cr(SPARC_BLU, r0, r1, r2) -# define lti_u(r0, r1, i0) cw(SPARC_BLU, r0, r1, i0) -# define ler(r0, r1, r2) cr(SPARC_BLE, r0, r1, r2) -# define lei(r0, r1, i0) cw(SPARC_BLE, r0, r1, i0) -# define ler_u(r0, r1, r2) cr(SPARC_BLEU, r0, r1, r2) -# define lei_u(r0, r1, i0) cw(SPARC_BLEU, r0, r1, i0) -# define eqr(r0, r1, r2) cr(SPARC_BE, r0, r1, r2) -# define eqi(r0, r1, i0) cw(SPARC_BE, r0, r1, i0) -# define ger(r0, r1, r2) cr(SPARC_BGE, r0, r1, r2) -# define gei(r0, r1, i0) cw(SPARC_BGE, r0, r1, i0) -# define ger_u(r0, r1, r2) cr(SPARC_BGEU, r0, r1, r2) -# define gei_u(r0, r1, i0) cw(SPARC_BGEU, r0, r1, i0) -# define gtr(r0, r1, r2) cr(SPARC_BG, r0, r1, r2) -# define gti(r0, r1, i0) cw(SPARC_BG, r0, r1, i0) -# define gtr_u(r0, r1, r2) cr(SPARC_BGU, r0, r1, r2) -# define gti_u(r0, r1, i0) cw(SPARC_BGU, r0, r1, i0) -# define ner(r0, r1, r2) cr(SPARC_BNE, r0, r1, r2) -# define nei(r0, r1, i0) cw(SPARC_BNE, r0, r1, i0) -# else -# define ltr(r0, r1, r2) cr(SPARC_BPL, r0, r1, r2) -# define lti(r0, r1, i0) cw(SPARC_BPL, r0, r1, i0) -# define ltr_u(r0, r1, r2) cr(SPARC_BPCS, r0, r1, r2) -# define lti_u(r0, r1, i0) cw(SPARC_BPCS, r0, r1, i0) -# define ler(r0, r1, r2) cr(SPARC_BPLE, r0, r1, r2) -# define lei(r0, r1, i0) cw(SPARC_BPLE, r0, r1, i0) -# define ler_u(r0, r1, r2) cr(SPARC_BPLEU, r0, r1, r2) -# define lei_u(r0, r1, i0) cw(SPARC_BPLEU, r0, r1, i0) -# define eqr(r0, r1, r2) cr(SPARC_BPE, r0, r1, r2) -# define eqi(r0, r1, i0) cw(SPARC_BPE, r0, r1, i0) -# define ger(r0, r1, r2) cr(SPARC_BPGE, r0, r1, r2) -# define gei(r0, r1, i0) cw(SPARC_BPGE, r0, r1, i0) -# define ger_u(r0, r1, r2) cr(SPARC_BPCC, r0, r1, r2) -# define gei_u(r0, r1, i0) cw(SPARC_BPCC, r0, r1, i0) -# define gtr(r0, r1, r2) cr(SPARC_BPG, r0, r1, r2) -# define gti(r0, r1, i0) cw(SPARC_BPG, r0, r1, i0) -# define gtr_u(r0, r1, r2) cr(SPARC_BPGU, r0, r1, r2) -# define gti_u(r0, r1, i0) cw(SPARC_BPGU, r0, r1, i0) -# define ner(r0, r1, r2) cr(SPARC_BPNE, r0, r1, r2) -# define nei(r0, r1, i0) cw(SPARC_BPNE, r0, r1, i0) -# endif -# define ldr_c(r0, r1) LDSB(r1, 0, r0) -# define ldi_c(r0, i0) _ldi_c(_jit, r0, i0) -static void _ldi_c(jit_state_t*,int32_t,jit_word_t); -# define ldr_uc(r0, r1) LDUB(r1, 0, r0) -# define ldi_uc(r0, i0) _ldi_uc(_jit, r0, i0) -static void _ldi_uc(jit_state_t*,int32_t,jit_word_t); -# define ldr_s(r0, r1) LDSH(r1, 0, r0) -# define ldi_s(r0, i0) _ldi_s(_jit, r0, i0) -static void _ldi_s(jit_state_t*,int32_t,jit_word_t); -# define ldr_us(r0, r1) LDUH(r1, 0, r0) -# define ldi_us(r0, i0) _ldi_us(_jit, r0, i0) -static void _ldi_us(jit_state_t*,int32_t,jit_word_t); -# if __WORDSIZE == 32 -# define ldr_i(r0, r1) LD(r1, 0, r0) -# define ldr(u, v) ldr_i(u, v) -# define ldi(u, v) ldi_i(u, v) -# else -# define ldr_i(r0, r1) LDSW(r1, 0, r0) -# define ldr_ui(r0, r1) LDUW(r1, 0, r0) -# define ldr_l(r0, r1) LDX(r1, 0, r0) -# define ldr(u, v) ldr_l(u, v) -# define ldi(u, v) ldi_l(u, v) -# endif -# define ldi_i(r0, i0) _ldi_i(_jit, r0, i0) -static void _ldi_i(jit_state_t*,int32_t,jit_word_t); -# if __WORDSIZE == 64 -# define ldi_ui(r0, i0) _ldi_ui(_jit, r0, i0) -static void _ldi_ui(jit_state_t*,int32_t,jit_word_t); -# define ldi_l(r0, i0) _ldi_l(_jit, r0, i0) -static void _ldi_l(jit_state_t*,int32_t,jit_word_t); -# endif -# define ldxr_c(r0, r1, r2) LDSB(r1, r2, r0) -# 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 ldxr_uc(r0, r1, r2) LDUB(r1, r2, 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 ldxr_s(r0, r1, r2) LDSH(r1, r2, r0) -# 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 ldxr_us(r0, r1, r2) LDUH(r1, r2, 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); -# if __WORDSIZE == 32 -# define ldxr(u, v, w) ldxr_i(u, v, w) -# define ldxr_i(r0, r1, r2) LD(r1, r2, r0) -# define ldxi(u, v, w) ldxi_i(u, v, w) -# else -# define ldxr(u, v, w) ldxr_l(u, v, w) -# define ldxr_i(r0, r1, r2) LDSW(r1, r2, r0) -# define ldxr_ui(r0, r1, r2) LDUW(r1, r2, r0) -# define ldxr_l(r0, r1, r2) LDX(r1, r2, r0) -# define ldxi(u, v, w) ldxi_l(u, v, w) -# endif -# define ldxi_i(r0, r1, i0) _ldxi_i(_jit, r0, r1, i0) -static void _ldxi_i(jit_state_t*,int32_t,int32_t,jit_word_t); -# if __WORDSIZE == 64 -# 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 ldxi_l(r0, r1, i0) _ldxi_l(_jit, r0, r1, i0) -static void _ldxi_l(jit_state_t*,int32_t,int32_t,jit_word_t); -# endif -# define str_c(r0, r1) STB(r1, r0, 0) -# define sti_c(i0, r0) _sti_c(_jit, i0, r0) -static void _sti_c(jit_state_t*,jit_word_t,int32_t); -# define str_s(r0, r1) STH(r1, r0, 0) -# define sti_s(i0, r0) _sti_s(_jit, i0, r0) -static void _sti_s(jit_state_t*,jit_word_t,int32_t); -# if __WORDSIZE == 32 -# define str(u, v) str_i(u, v) -# define str_i(r0, r1) STI(r1, r0, 0) -# define sti(u, v) sti_i(u, v) -# else -# define str(u, v) str_l(u, v) -# define str_i(r0, r1) STW(r1, r0, 0) -# define str_l(r0, r1) STX(r1, r0, 0) -# define sti(u, v) sti_l(u, v) -# endif -# define sti_i(i0, r0) _sti_i(_jit, i0, r0) -static void _sti_i(jit_state_t*,jit_word_t,int32_t); -# if __WORDSIZE == 64 -# define sti_l(i0, r0) _sti_l(_jit, i0, r0) -static void _sti_l(jit_state_t*,jit_word_t,int32_t); -# endif -# define stxr_c(r0, r1, r2) STB(r2, r1, r0) -# 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 stxr_s(r0, r1, r2) STH(r2, r1, r0) -# 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); -# if __WORDSIZE == 32 -# define stxr(u, v, w) stxr_i(u, v, w) -# define stxr_i(r0, r1, r2) ST(r2, r1, r0) -# define stxi(u, v, w) stxi_i(u, v, w) -# else -# define stxr(u, v, w) stxr_l(u, v, w) -# define stxr_i(r0, r1, r2) STW(r2, r1, r0) -# define stxi(u, v, w) stxi_l(u, v, w) -# define stxr_l(r0, r1, r2) STX(r2, r1, r0) -# endif -# 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); -# if __WORDSIZE == 64 -# define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1) -static void _stxi_l(jit_state_t*,jit_word_t,int32_t,int32_t); -# endif -# define br(cc, i0, r0, r1) _br(_jit, cc, i0, r0, r1) -static jit_word_t -_br(jit_state_t*,int32_t,jit_word_t,int32_t,int32_t); -# define bw(cc, i0, r0, i1) _bw(_jit, cc, i0, r0, i1) -static jit_word_t -_bw(jit_state_t*,int32_t,jit_word_t,int32_t,jit_word_t); -# if __WORDSIZE == 32 -# define bltr(i0, r0, r1) br(SPARC_BL, i0, r0, r1) -# define blti(i0, r0, i1) bw(SPARC_BL, i0, r0, i1) -# define bltr_u(i0, r0, r1) br(SPARC_BLU, i0, r0, r1) -# define blti_u(i0, r0, i1) bw(SPARC_BLU, i0, r0, i1) -# define bler(i0, r0, r1) br(SPARC_BLE, i0, r0, r1) -# define blei(i0, r0, i1) bw(SPARC_BLE, i0, r0, i1) -# define bler_u(i0, r0, r1) br(SPARC_BLEU, i0, r0, r1) -# define blei_u(i0, r0, i1) bw(SPARC_BLEU, i0, r0, i1) -# define beqr(i0, r0, r1) br(SPARC_BE, i0, r0, r1) -# define beqi(i0, r0, i1) bw(SPARC_BE, i0, r0, i1) -# define bger(i0, r0, r1) br(SPARC_BGE, i0, r0, r1) -# define bgei(i0, r0, i1) bw(SPARC_BGE, i0, r0, i1) -# define bger_u(i0, r0, r1) br(SPARC_BGEU, i0, r0, r1) -# define bgei_u(i0, r0, i1) bw(SPARC_BGEU, i0, r0, i1) -# define bgtr(i0, r0, r1) br(SPARC_BG, i0, r0, r1) -# define bgti(i0, r0, i1) bw(SPARC_BG, i0, r0, i1) -# define bgtr_u(i0, r0, r1) br(SPARC_BGU, i0, r0, r1) -# define bgti_u(i0, r0, i1) bw(SPARC_BGU, i0, r0, i1) -# define bner(i0, r0, r1) br(SPARC_BNE, i0, r0, r1) -# define bnei(i0, r0, i1) bw(SPARC_BNE, i0, r0, i1) -# else -# define bltr(i0, r0, r1) br(SPARC_BPL, i0, r0, r1) -# define blti(i0, r0, i1) bw(SPARC_BPL, i0, r0, i1) -# define bltr_u(i0, r0, r1) br(SPARC_BPCS, i0, r0, r1) -# define blti_u(i0, r0, i1) bw(SPARC_BPCS, i0, r0, i1) -# define bler(i0, r0, r1) br(SPARC_BPLE, i0, r0, r1) -# define blei(i0, r0, i1) bw(SPARC_BPLE, i0, r0, i1) -# define bler_u(i0, r0, r1) br(SPARC_BPLEU, i0, r0, r1) -# define blei_u(i0, r0, i1) bw(SPARC_BPLEU, i0, r0, i1) -# define beqr(i0, r0, r1) br(SPARC_BPE, i0, r0, r1) -# define beqi(i0, r0, i1) bw(SPARC_BPE, i0, r0, i1) -# define bger(i0, r0, r1) br(SPARC_BPGE, i0, r0, r1) -# define bgei(i0, r0, i1) bw(SPARC_BPGE, i0, r0, i1) -# define bger_u(i0, r0, r1) br(SPARC_BPCC, i0, r0, r1) -# define bgei_u(i0, r0, i1) bw(SPARC_BPCC, i0, r0, i1) -# define bgtr(i0, r0, r1) br(SPARC_BPG, i0, r0, r1) -# define bgti(i0, r0, i1) bw(SPARC_BPG, i0, r0, i1) -# define bgtr_u(i0, r0, r1) br(SPARC_BPGU, i0, r0, r1) -# define bgti_u(i0, r0, i1) bw(SPARC_BPGU, i0, r0, i1) -# define bner(i0, r0, r1) br(SPARC_BPNE, i0, r0, r1) -# define bnei(i0, r0, i1) bw(SPARC_BPNE, i0, r0, i1) -# endif -# define b_asr(jif,add,sgn,i0,r0,r1) _b_asr(_jit,jif,add,sgn,i0,r0,r1) -static jit_word_t -_b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t, - jit_word_t,int32_t,int32_t); -# define b_asw(jif,add,sgn,i0,r0,i1) _b_asw(_jit,jif,add,sgn,i0,r0,i1) -static jit_word_t -_b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t, - jit_word_t,int32_t,jit_word_t); -# define boaddr(i0, r0, r1) b_asr(1, 1, 1, i0, r0, r1) -# define boaddi(i0, r0, i1) b_asw(1, 1, 1, i0, r0, i1) -# define boaddr_u(i0, r0, r1) b_asr(1, 1, 0, i0, r0, r1) -# define boaddi_u(i0, r0, i1) b_asw(1, 1, 0, i0, r0, i1) -# define bxaddr(i0, r0, r1) b_asr(0, 1, 1, i0, r0, r1) -# define bxaddi(i0, r0, i1) b_asw(0, 1, 1, i0, r0, i1) -# define bxaddr_u(i0, r0, r1) b_asr(0, 1, 0, i0, r0, r1) -# define bxaddi_u(i0, r0, i1) b_asw(0, 1, 0, i0, r0, i1) -# define bosubr(i0, r0, r1) b_asr(1, 0, 1, i0, r0, r1) -# define bosubi(i0, r0, i1) b_asw(1, 0, 1, i0, r0, i1) -# define bosubr_u(i0, r0, r1) b_asr(1, 0, 0, i0, r0, r1) -# define bosubi_u(i0, r0, i1) b_asw(1, 0, 0, i0, r0, i1) -# define bxsubr(i0, r0, r1) b_asr(0, 0, 1, i0, r0, r1) -# define bxsubi(i0, r0, i1) b_asw(0, 0, 1, i0, r0, i1) -# define bxsubr_u(i0, r0, r1) b_asr(0, 0, 0, i0, r0, r1) -# define bxsubi_u(i0, r0, i1) b_asw(0, 0, 0, i0, r0, i1) -# define bm_r(set, i0, r0, r1) _bm_r(_jit,set,i0,r0,r1) -static jit_word_t -_bm_r(jit_state_t*,jit_bool_t,jit_word_t,int32_t,int32_t); -# define bm_w(set,i0,r0,i1) _bm_w(_jit,set,i0,r0,i1) -static jit_word_t -_bm_w(jit_state_t*,jit_bool_t,jit_word_t,int32_t,jit_word_t); -# define bmsr(i0, r0, r1) bm_r(1, i0, r0, r1) -# define bmsi(i0, r0, i1) bm_w(1, i0, r0, i1) -# define bmcr(i0, r0, r1) bm_r(0, i0, r0, r1) -# define bmci(i0, r0, i1) bm_w(0, i0, r0, i1) -# 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(jump, label) _patch_at(_jit, jump, label) -static void _patch_at(jit_state_t*,jit_word_t,jit_word_t); -#endif - -#if CODE -static void -_f2r(jit_state_t *_jit, - int32_t op, int32_t rd, int32_t op2, int32_t imm22) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(rd & 0xffffffe0)); - assert(!(op2 & 0xfffffff8)); - assert(s22_p(imm22)); - v.op.b = op; - v.rd.b = rd; - v.op2.b = op2; - v.imm22.b = imm22; - ii(v.v); -} - -static void -_f2b(jit_state_t *_jit, - int32_t op, int32_t a, int32_t cond, int32_t op2, - int32_t disp22) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(a & 0xfffffffe)); - assert(!(cond & 0xfffffff0)); - assert(!(op2 & 0xfffffff8)); - assert(s22_p(disp22)); - v.op.b = op; - v.a.b = a; - v.cond.b = cond; - v.op2.b = op2; - v.disp22.b = disp22; - ii(v.v); -} - -# if __WORDSIZE == 64 -static void -_f2bp(jit_state_t *_jit, - int32_t op, int32_t a, int32_t cond, int32_t op2, - int32_t cc1, int32_t cc0, int32_t p, int32_t disp19) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(a & 0xfffffffe)); - assert(!(cond & 0xfffffff0)); - assert(!(op2 & 0xfffffff8)); - assert(s19_p(disp19)); - v.op.b = op; - v.a.b = a; - v.cond.b = cond; - v.op2.b = op2; - v.cc1.b = cc1; - v.cc0.b = cc0; - v.p.b = p; - v.disp19.b = disp19; - ii(v.v); -} -# endif - -static void -_f3r(jit_state_t *_jit, int32_t op, int32_t rd, - int32_t op3, int32_t rs1, int32_t rs2) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(rd & 0xffffffe0)); - assert(!(op3 & 0xffffffc0)); - assert(!(rs1 & 0xffffffe0)); - assert(!(rs2 & 0xffffffe0)); - v.op.b = op; - v.rd.b = rd; - v.op3.b = op3; - v.rs1.b = rs1; - v.i.b = 0; - v.asi.b = 0; - v.rs2.b = rs2; - ii(v.v); -} - -# if __WORDSIZE == 64 -static void -_f3rx(jit_state_t *_jit, int32_t op, int32_t rd, - int32_t op3, int32_t rs1, int32_t rs2) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(rd & 0xffffffe0)); - assert(!(op3 & 0xffffffc0)); - assert(!(rs1 & 0xffffffe0)); - assert(!(rs2 & 0xffffffe0)); - v.op.b = op; - v.rd.b = rd; - v.op3.b = op3; - v.rs1.b = rs1; - v.i.b = 0; - v.x.b = 1; - v.asix.b = 0; - v.rs2.b = rs2; - ii(v.v); -} - -static void -_f3s(jit_state_t *_jit, int32_t op, int32_t rd, - int32_t op3, int32_t rs1, int32_t shim) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(rd & 0xffffffe0)); - assert(!(op3 & 0xffffffc0)); - assert(!(rs1 & 0xffffffe0)); - assert(!(shim & 0xffffffc0)); - v.op.b = op; - v.rd.b = rd; - v.op3.b = op3; - v.rs1.b = rs1; - v.i.b = 1; - v.x.b = 1; - v.asis.b = 0; - v.shim.b = shim; - ii(v.v); -} -# endif - -static void -_f3i(jit_state_t *_jit, int32_t op, int32_t rd, - int32_t op3, int32_t rs1, int32_t simm13) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(rd & 0xffffffe0)); - assert(!(op3 & 0xffffffc0)); - assert(!(rs1 & 0xffffffe0)); - assert(s13_p(simm13)); - v.op.b = op; - v.rd.b = rd; - v.op3.b = op3; - v.rs1.b = rs1; - v.i.b = 1; - v.simm13.b = simm13; - ii(v.v); -} - -static void -_f3t(jit_state_t *_jit, int32_t cond, - int32_t rs1, int32_t i, int32_t rs2_imm7) -{ - jit_instr_t v; - assert(!(cond & 0xfffffff0)); - assert(!(i & 0xfffffffe)); - assert(!(rs1 & 0xffffffe0)); - v.op.b = 2; - v.rd.b = cond; - v.op3.b = 58; - v.i.b = i; - if (i) { - assert(s7_p(rs2_imm7)); - v.res.b = 0; - v.imm7.b = rs2_imm7; - } - else { - assert(!(rs2_imm7 & 0xffffffe0)); - v.asi.b = 0; - v.rs2.b = rs2_imm7; - } - ii(v.v); -} - -static void -_f3a(jit_state_t *_jit, int32_t op, int32_t rd, - int32_t op3, int32_t rs1, int32_t asi, int32_t rs2) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(!(rd & 0xffffffe0)); - assert(!(op3 & 0xffffffc0)); - assert(!(rs1 & 0xffffffe0)); - assert(!(asi & 0xffffff00)); - assert(!(rs2 & 0xffffffe0)); - v.op.b = op; - v.rd.b = rd; - v.op3.b = op3; - v.rs1.b = rs1; - v.i.b = 0; - v.asi.b = asi; - v.rs2.b = rs2; - ii(v.v); -} - -static void -_f1(jit_state_t *_jit, int32_t op, int32_t disp30) -{ - jit_instr_t v; - assert(!(op & 0xfffffffc)); - assert(s30_p(disp30)); - v.op.b = op; - v.disp30.b = disp30; - ii(v.v); -} - -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) - ORI(r1, 0, r0); -} - -static void -_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - if (s13_p(i0)) - ORI(0, i0, r0); - else { -# if __WORDSIZE == 64 - if (i0 & 0xffffffff00000000) { - int32_t reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), (i0 >> 32) & 0xffffffff); - movi(r0, i0 & 0xffffffff); - lshi(rn(reg), rn(reg), 32); - OR(rn(reg), r0, r0); - jit_unget_reg(reg); - } - else { -# endif - SETHI(HI((int)i0), r0); - if (LO(i0)) - ORI(r0, LO(i0), r0); -# if __WORDSIZE == 64 - } -# endif - } -} - -static jit_word_t -_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - jit_word_t w; -# if __WORDSIZE == 64 - int32_t reg; -# endif - w = _jit->pc.w; -# if __WORDSIZE == 64 - reg = jit_get_reg(jit_class_gpr); - SETHI(HI((int)i0), r0); - ORI(r0, LO(i0), r0); - i0 = (int)(i0 >> 32); - SETHI(HI(i0), rn(reg)); - ORI(rn(reg), LO(i0), rn(reg)); - SLLXI(rn(reg), 32, rn(reg)); - OR(rn(reg), r0, r0); - jit_unget_reg(reg); -# else - SETHI(HI(i0), r0); - ORI(r0, LO(i0), r0); -# endif - return (w); -} - -static void -_addi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - ADDI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - addr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_addcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - if (jit_carry == _NOREG) - jit_carry = jit_get_reg(jit_class_gpr); - if (r0 == r1) { - reg = jit_get_reg(jit_class_gpr); - addr(rn(reg), r1, r2); - ltr_u(rn(jit_carry), rn(reg), r1); - movr(r0, rn(reg)); - jit_unget_reg(reg); - } - else { - addr(r0, r1, r2); - ltr_u(rn(jit_carry), r0, r1); - } -} -# endif - -static void -_addci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ -# if __WORDSIZE == 32 - int32_t reg; - if (s13_p(i0)) - ADDIcc(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - addcr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -# else - int32_t reg; - if (jit_carry == _NOREG) - jit_carry = jit_get_reg(jit_class_gpr); - if (r0 == r1) { - reg = jit_get_reg(jit_class_gpr); - addi(rn(reg), r1, i0); - ltr_u(rn(jit_carry), rn(reg), r1); - movr(r0, rn(reg)); - jit_unget_reg(reg); - } - else { - addi(r0, r1, i0); - ltr_u(rn(jit_carry), r0, r1); - } -# endif -} - -# if __WORDSIZE == 64 -static void -_addxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - assert(jit_carry != _NOREG); - reg = jit_get_reg(jit_class_gpr); - movr(rn(reg), rn(jit_carry)); - addcr(r0, r1, r2); - addcr(r0, r0, rn(reg)); - jit_unget_reg(reg); -} -# endif - -static void -_addxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ -# if __WORDSIZE == 32 - int32_t reg; - if (s13_p(i0)) - ADDXIcc(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - addxr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -# else - int32_t reg; - assert(jit_carry != _NOREG); - reg = jit_get_reg(jit_class_gpr); - movr(rn(reg), rn(jit_carry)); - addci(r0, r1, i0); - addcr(r0, r0, rn(reg)); - jit_unget_reg(reg); -# endif -} - -static void -_subi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - SUBI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - subr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_subcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - if (jit_carry == _NOREG) - jit_carry = jit_get_reg(jit_class_gpr); - if (r0 == r1) { - reg = jit_get_reg(jit_class_gpr); - subr(rn(reg), r1, r2); - ltr_u(rn(jit_carry), r1, rn(reg)); - movr(r0, rn(reg)); - jit_unget_reg(reg); - } - else { - subr(r0, r1, r2); - ltr_u(rn(jit_carry), r1, r0); - } -} -# endif - -static void -_subci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ -# if __WORDSIZE == 32 - int32_t reg; - if (s13_p(i0)) - SUBIcc(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - subcr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -# else - int32_t reg; - if (jit_carry == _NOREG) - jit_carry = jit_get_reg(jit_class_gpr); - if (r0 == r1) { - reg = jit_get_reg(jit_class_gpr); - addi(rn(reg), r1, -i0); - ltr_u(rn(jit_carry), r1, rn(reg)); - movr(r0, rn(reg)); - jit_unget_reg(reg); - } - else { - addi(r0, r1, -i0); - ltr_u(rn(jit_carry), r1, r0); - } -# endif -} - -# if __WORDSIZE == 64 -static void -_subxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - assert(jit_carry != _NOREG); - reg = jit_get_reg(jit_class_gpr); - movr(rn(reg), rn(jit_carry)); - subcr(r0, r1, r2); - subcr(r0, r0, rn(reg)); - jit_unget_reg(reg); -} -#endif - -static void -_subxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ -# if __WORDSIZE == 32 - int32_t reg; - if (s13_p(i0)) - SUBXIcc(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - subxr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -# else - int32_t reg; - assert(jit_carry != _NOREG); - reg = jit_get_reg(jit_class_gpr); - movr(rn(reg), rn(jit_carry)); - subci(r0, r1, i0); - subcr(r0, r0, rn(reg)); - jit_unget_reg(reg); -# endif -} - -static void -_rsbi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - subi(r0, r1, i0); - negr(r0, r0); -} - -static void -_muli(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 32 - UMULI(r1, i0, r0); -# else - MULXI(r1, i0, r0); -# endif - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - mulr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 32 -static void -_iqmulr(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, int32_t r3, jit_bool_t sign) -{ - if (sign) - SMUL(r2, r3, r0); - else - UMUL(r2, r3, r0); - RDY(r1); -} - -static void -_iqmuli(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, jit_word_t i0, jit_bool_t sign) -{ - int32_t reg; - if (s13_p(i0)) { - if (sign) - SMULI(r2, i0, r0); - else - UMULI(r2, i0, r0); - RDY(r1); - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - iqmulr(r0, r1, r2, rn(reg), sign); - jit_unget_reg(reg); - } -} - -# else -static __int128_t __llmul(jit_word_t a, jit_word_t b) -{ - return (__int128_t)a * (__int128_t)b; -} - -# define QMUL_PROLOG() \ - do { \ - (void)jit_get_reg(_O0|jit_class_gpr|jit_class_named); \ - (void)jit_get_reg(_O1|jit_class_gpr|jit_class_named); \ - if (r0 != _G2_REGNO && r1 != _G2_REGNO) \ - stxi(BIAS(-8), _FP_REGNO, _G2_REGNO); \ - if (r0 != _G3_REGNO && r1 != _G3_REGNO) \ - stxi(BIAS(-16), _FP_REGNO, _G3_REGNO); \ - if (r0 != _G4_REGNO && r1 != _G4_REGNO) \ - stxi(BIAS(-24), _FP_REGNO, _G4_REGNO); \ - } while (0) - -# define QMUL_EPILOG() \ - do { \ - if (r0 != _G2_REGNO && r1 != _G2_REGNO) \ - ldxi(_G2_REGNO, _FP_REGNO, BIAS(-8)); \ - if (r0 != _G3_REGNO && r1 != _G3_REGNO) \ - ldxi(_G3_REGNO, _FP_REGNO, BIAS(-16)); \ - if (r0 != _G4_REGNO && r1 != _G4_REGNO) \ - ldxi(_G4_REGNO, _FP_REGNO, BIAS(-24)); \ - (void)jit_unget_reg(_O0); \ - (void)jit_unget_reg(_O1); \ - } while (0) - -static void -_qmulr(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, int32_t r3) -{ - QMUL_PROLOG(); - movr(_O0_REGNO, r3); - movr(_O1_REGNO, r2); - calli((jit_word_t)__llmul); - movr(r0, _O1_REGNO); - movr(r1, _O0_REGNO); - QMUL_EPILOG(); -} - -static void -_qmuli(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, jit_word_t i0) -{ - QMUL_PROLOG(); - movi(_O0_REGNO, i0); - movr(_O1_REGNO, r2); - calli((jit_word_t)__llmul); - movr(r0, _O1_REGNO); - movr(r1, _O0_REGNO); - QMUL_EPILOG(); -} - -static __uint128_t __ullmul(jit_uword_t a, jit_uword_t b) -{ - return (__uint128_t)a * (__uint128_t)b; -} - -static void -_qmulr_u(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, int32_t r3) -{ - QMUL_PROLOG(); - movr(_O0_REGNO, r3); - movr(_O1_REGNO, r2); - calli((jit_word_t)__ullmul); - movr(r0, _O1_REGNO); - movr(r1, _O0_REGNO); - QMUL_EPILOG(); -} - -static void -_qmuli_u(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, jit_word_t i0) -{ - QMUL_PROLOG(); - movi(_O0_REGNO, i0); - movr(_O1_REGNO, r2); - calli((jit_word_t)__ullmul); - movr(r0, _O1_REGNO); - movr(r1, _O0_REGNO); - QMUL_EPILOG(); -} -# endif - -static void -_divr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ -# if __WORDSIZE == 32 - int32_t reg; - reg = jit_get_reg(jit_class_gpr); - rshi(rn(reg), r1, 31); - WRY(rn(reg), 0); - SDIV(r1, r2, r0); - jit_unget_reg(reg); -# else - SDIVX(r1, r2, r0); -# endif -} - -static void -_divi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; -# if __WORDSIZE == 32 - reg = jit_get_reg(jit_class_gpr); -# endif - if (s13_p(i0)) { -# if __WORDSIZE == 32 - rshi(rn(reg), r1, 31); - WRY(rn(reg), 0); - SDIVI(r1, i0, r0); -# else - SDIVXI(r1, i0, r0); -# endif - } - else { -# if __WORDSIZE == 64 - reg = jit_get_reg(jit_class_gpr); -# endif - movi(rn(reg), i0); - divr(r0, r1, rn(reg)); -# if __WORDSIZE == 64 - jit_unget_reg(reg); -# endif - } -# if __WORDSIZE == 32 - jit_unget_reg(reg); -# endif -} - -static void -_divr_u(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ -# if __WORDSIZE == 32 - WRYI(0, 0); - UDIV(r1, r2, r0); -# else - UDIVX(r1, r2, r0); -# endif -} - -static void -_divi_u(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 32 - WRYI(0, 0); - UDIVI(r1, i0, r0); -# else - UDIVXI(r1, i0, r0); -# endif - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - divr_u(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_iqdivr(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, int32_t r3, jit_bool_t sign) -{ - int32_t sv0, rg0; - int32_t sv1, rg1; - - if (r0 == r2 || r0 == r3) { - sv0 = jit_get_reg(jit_class_gpr); - rg0 = rn(sv0); - } - else - rg0 = r0; - if (r1 == r2 || r1 == r3) { - sv1 = jit_get_reg(jit_class_gpr); - rg1 = rn(sv1); - } - else - rg1 = r1; - - if (sign) - divr(rg0, r2, r3); - else - divr_u(rg0, r2, r3); - mulr(rg1, r3, rg0); - subr(rg1, r2, rg1); - if (rg0 != r0) { - movr(r0, rg0); - jit_unget_reg(sv0); - } - if (rg1 != r1) { - movr(r1, rg1); - jit_unget_reg(sv1); - } -} - -static void -_iqdivi(jit_state_t *_jit, int32_t r0, int32_t r1, - int32_t r2, jit_word_t i0, jit_bool_t sign) -{ - int32_t reg; - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - iqdivr(r0, r1, r2, rn(reg), sign); - jit_unget_reg(reg); -} - -static void -_remr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - if (r0 == r1 || r0 == r2) { - reg = jit_get_reg(jit_class_gpr); - divr(rn(reg), r1, r2); - mulr(rn(reg), r2, rn(reg)); - subr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } - else { - divr(r0, r1, r2); - mulr(r0, r2, r0); - subr(r0, r1, r0); - } -} - -static void -_remi(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); - remr(r0, r1, rn(reg)); - jit_unget_reg(reg); -} - -static void -_remr_u(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - if (r0 == r1 || r0 == r2) { - reg = jit_get_reg(jit_class_gpr); - divr_u(rn(reg), r1, r2); - mulr(rn(reg), r2, rn(reg)); - subr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } - else { - divr_u(r0, r1, r2); - mulr(r0, r2, r0); - subr(r0, r1, r0); - } -} - -static void -_remi_u(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); - remr_u(r0, r1, rn(reg)); - jit_unget_reg(reg); -} - -static void -_andi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - ANDI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - andr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - ORI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - orr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_xori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - XORI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - xorr(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_extr_c(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - lshi(r0, r1, __WORDSIZE - 8); - rshi(r0, r0, __WORDSIZE - 8); -} - -static void -_extr_s(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - lshi(r0, r1, __WORDSIZE - 16); - rshi(r0, r0, __WORDSIZE - 16); -} - -static void -_extr_us(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - lshi(r0, r1, __WORDSIZE - 16); - rshi_u(r0, r0, __WORDSIZE - 16); -} - -#if __WORDSIZE == 64 -static void -_extr_i(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - lshi(r0, r1, __WORDSIZE - 32); - rshi(r0, r0, __WORDSIZE - 32); -} - -static void -_extr_ui(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - lshi(r0, r1, __WORDSIZE - 32); - rshi_u(r0, r0, __WORDSIZE - 32); -} -#endif - -static void -_cr(jit_state_t *_jit, int32_t cc, - int32_t r0, int32_t r1, int32_t r2) -{ - CMP(r1, r2); -# if __WORDSIZE == 32 - Ba(cc, 3); -# else - BPa(cc, 3); -# endif - movi(r0, 1); - movi(r0, 0); -} - -static void -_cw(jit_state_t *_jit, int32_t cc, - int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { - CMPI(r1, i0); -# if __WORDSIZE == 32 - Ba(cc, 3); -# else - BPa(cc, 3); -# endif - movi(r0, 1); - movi(r0, 0); - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - cr(cc, r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDSBI(0, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_c(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDUBI(0, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_uc(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDSHI(0, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_s(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDUHI(0, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_us(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 32 - LDI(0, i0, r0); -# else - LDSWI(0, i0, r0); -# endif - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_i(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDUWI(0, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_ui(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -static void -_ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDXI(0, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_l(r0, rn(reg)); - jit_unget_reg(reg); - } -} -# endif - -static void -_ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDSBI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldxr_c(r0, r1, rn(reg)); - 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 (s13_p(i0)) - LDUBI(r1, i0, 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 -_ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDSHI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldxr_s(r0, r1, rn(reg)); - 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 (s13_p(i0)) - LDUHI(r1, i0, 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 -_ldxi_i(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 32 - LDI(r1, i0, r0); -# else - LDSWI(r1, i0, r0); -# endif - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldxr_i(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_ldxi_ui(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDUWI(r1, i0, 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 -_ldxi_l(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDXI(r1, i0, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldxr_l(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} -# endif - -static void -_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - int32_t reg; - if (s13_p(i0)) - STBI(r0, 0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - str_c(rn(reg), r0); - jit_unget_reg(reg); - } -} - -static void -_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - int32_t reg; - if (s13_p(i0)) - STHI(r0, 0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - str_s(rn(reg), r0); - jit_unget_reg(reg); - } -} - -static void -_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 32 - STI(r0, 0, i0); -# else - STWI(r0, 0, i0); -# endif - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - str_i(rn(reg), r0); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - int32_t reg; - if (s13_p(i0)) - STXI(r0, 0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - str_l(rn(reg), r0); - jit_unget_reg(reg); - } -} -# endif - -static void -_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1) -{ - int32_t reg; - if (s13_p(i0)) - STBI(r1, r0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - stxr_c(r0, rn(reg), r1); - 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 (s13_p(i0)) - STHI(r1, r0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - stxr_s(r0, rn(reg), r1); - 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 (s13_p(i0)) { -# if __WORDSIZE == 32 - STI(r1, r0, i0); -# else - STWI(r1, r0, i0); -# endif - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - stxr_i(r0, rn(reg), r1); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1) -{ - int32_t reg; - if (s13_p(i0)) - STXI(r1, r0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - stxr_l(r0, rn(reg), r1); - jit_unget_reg(reg); - } -} -# endif - -static jit_word_t -_br(jit_state_t *_jit, int32_t cc, - jit_word_t i0, int32_t r0, int32_t r1) -{ - jit_word_t w; - CMP(r0, r1); - w = _jit->pc.w; -# if __WORDSIZE == 32 - B(cc, (i0 - w) >> 2); -# else - BP(cc, (i0 - w) >> 2); -# endif - NOP(); - return (w); -} - -static jit_word_t -_bw(jit_state_t *_jit, int32_t cc, - jit_word_t i0, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - int32_t reg; - if (s13_p(i1)) { - CMPI(r0, i1); - w = _jit->pc.w; -# if __WORDSIZE == 32 - B(cc, (i0 - w) >> 2); -# else - B(cc, (i0 - w) >> 2); -# endif - NOP(); - } - else { - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - movi(rn(reg), i1); - w = br(cc, i0, r0, rn(reg)); - jit_unget_reg(reg); - } - return (w); -} - -static jit_word_t -_b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn, - jit_word_t i0, int32_t r0, int32_t r1) -{ - jit_word_t w; - if (add) - ADDcc(r0, r1, r0); - else - SUBcc(r0, r1, r0); - w = _jit->pc.w; -# if __WORDSIZE == 32 - B(sgn ? - (jif ? SPARC_BVS : SPARC_BVC) : - (jif ? SPARC_BCS : SPARC_BCC), - (i0 - w) >> 2); -# else - BP(sgn ? - (jif ? SPARC_BPVS : SPARC_BPVC) : - (jif ? SPARC_BPCS : SPARC_BPCC), - (i0 - w) >> 2); -# endif - NOP(); - return (w); -} - -static jit_word_t -_b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn, - jit_word_t i0, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - int32_t reg; - if (s13_p(i1)) { - if (add) - ADDIcc(r0, i1, r0); - else - SUBIcc(r0, i1, r0); - w = _jit->pc.w; -# if __WORDSIZE == 32 - B(sgn ? - (jif ? SPARC_BVS : SPARC_BVC) : - (jif ? SPARC_BCS : SPARC_BCC), - (i0 - w) >> 2); -# else - BP(sgn ? - (jif ? SPARC_BPVS : SPARC_BPVC) : - (jif ? SPARC_BPCS : SPARC_BPCC), - (i0 - w) >> 2); -# endif - NOP(); - } - else { - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - movi(rn(reg), i1); - w = b_asr(jif, add, sgn, i0, r0, rn(reg)); - jit_unget_reg(reg); - } - return (w); -} - -static jit_word_t -_bm_r(jit_state_t *_jit, jit_bool_t set, - jit_word_t i0, int32_t r0, int32_t r1) -{ - jit_word_t w; - BTST(r0, r1); - w = _jit->pc.w; -# if __WORDSIZE == 32 - B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2); -# else - BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2); -# endif - NOP(); - return (w); -} - -static jit_word_t -_bm_w(jit_state_t *_jit, jit_bool_t set, - jit_word_t i0, int32_t r0, jit_word_t i1) -{ - jit_word_t w; - int32_t reg; - if (s13_p(i1)) { - BTSTI(r0, i1); - w = _jit->pc.w; -# if __WORDSIZE == 32 - B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2); -# else - BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2); -# endif - NOP(); - } - else { - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - movi(rn(reg), i1); - w = bm_r(set, i0, r0, rn(reg)); - jit_unget_reg(reg); - } - return (w); -} - -static void -_jmpr(jit_state_t *_jit, int32_t r0) -{ - JMPL(0, r0, 0); - NOP(); -} - -static void -_jmpi(jit_state_t *_jit, jit_word_t i0) -{ - jit_word_t w; - int32_t reg; - w = (i0 - _jit->pc.w) >> 2; - if (s22_p(w)) { - BA(w); - NOP(); - } - else { - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - movi(rn(reg), i0); - jmpr(rn(reg)); - jit_unget_reg(reg); - } -} - -static jit_word_t -_jmpi_p(jit_state_t *_jit, jit_word_t i0) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(jit_class_gpr|jit_class_nospill); - w = movi_p(rn(reg), i0); - jmpr(rn(reg)); - jit_unget_reg(reg); - return (w); -} - -static void -_callr(jit_state_t *_jit, int32_t r0) -{ - CALL(r0); - NOP(); -} - -static void -_calli(jit_state_t *_jit, jit_word_t i0) -{ - jit_word_t w; - w = (i0 - _jit->pc.w) >> 2; - CALLI(w); - NOP(); -} - -static jit_word_t -_calli_p(jit_state_t *_jit, jit_word_t i0) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(jit_class_gpr); - w = movi_p(rn(reg), i0); - callr(rn(reg)); - jit_unget_reg(reg); - return (w); -} - -#define OFF(n) BIAS(((n) * sizeof(jit_word_t))) -static void -_prolog(jit_state_t *_jit, jit_node_t *node) -{ - int32_t reg; - if (_jitc->function->define_frame || _jitc->function->assume_frame) { - int32_t frame = -_jitc->function->frame; - assert(_jitc->function->self.aoff >= frame); - if (_jitc->function->assume_frame) - return; - _jitc->function->self.aoff = frame; - } - if (_jitc->function->allocar) - _jitc->function->self.aoff &= -16; - /* align at 16 bytes boundary */ - _jitc->function->stack = ((stack_framesize + - _jitc->function->self.alen - - _jitc->function->self.aoff) + 15) & -16; - SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO); - - /* (most) other backends do not save incoming arguments, so, - * only save locals here */ - if (jit_regset_tstbit(&_jitc->function->regset, _L0)) - stxi(OFF(0), _SP_REGNO, _L0_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L1)) - stxi(OFF(1), _SP_REGNO, _L1_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L2)) - stxi(OFF(2), _SP_REGNO, _L2_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L3)) - stxi(OFF(3), _SP_REGNO, _L3_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L4)) - stxi(OFF(4), _SP_REGNO, _L4_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L5)) - stxi(OFF(5), _SP_REGNO, _L5_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L6)) - stxi(OFF(6), _SP_REGNO, _L6_REGNO); - if (jit_regset_tstbit(&_jitc->function->regset, _L7)) - stxi(OFF(7), _SP_REGNO, _L7_REGNO); - - if (_jitc->function->allocar) { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), BIAS(_jitc->function->self.aoff)); - /* Already "biased" by allocai */ - stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg)); - jit_unget_reg(reg); - } - - if (_jitc->function->self.call & jit_call_varargs) { - for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg) - stxi(BIAS((16 + (__WORDSIZE == 32)) * sizeof(jit_word_t) + - reg * sizeof(jit_word_t)), _FP_REGNO, rn(_I0 + reg)); - } -} - -static void -_epilog(jit_state_t *_jit, jit_node_t *node) -{ - if (_jitc->function->assume_frame) - return; - /* (most) other backends do not save incoming arguments, so, - * only save locals here */ - if (jit_regset_tstbit(&_jitc->function->regset, _L0)) - ldxi(_L0_REGNO, _FP_REGNO, _jitc->function->stack + OFF(0)); - if (jit_regset_tstbit(&_jitc->function->regset, _L1)) - ldxi(_L1_REGNO, _FP_REGNO, _jitc->function->stack + OFF(1)); - if (jit_regset_tstbit(&_jitc->function->regset, _L2)) - ldxi(_L2_REGNO, _FP_REGNO, _jitc->function->stack + OFF(2)); - if (jit_regset_tstbit(&_jitc->function->regset, _L3)) - ldxi(_L3_REGNO, _FP_REGNO, _jitc->function->stack + OFF(3)); - if (jit_regset_tstbit(&_jitc->function->regset, _L4)) - ldxi(_L4_REGNO, _FP_REGNO, _jitc->function->stack + OFF(4)); - if (jit_regset_tstbit(&_jitc->function->regset, _L5)) - ldxi(_L5_REGNO, _FP_REGNO, _jitc->function->stack + OFF(5)); - if (jit_regset_tstbit(&_jitc->function->regset, _L6)) - ldxi(_L6_REGNO, _FP_REGNO, _jitc->function->stack + OFF(6)); - if (jit_regset_tstbit(&_jitc->function->regset, _L7)) - ldxi(_L7_REGNO, _FP_REGNO, _jitc->function->stack + OFF(7)); - RESTOREI(0, 0, 0); - RETL(); - NOP(); -} - -static void -_vastart(jit_state_t *_jit, int32_t r0) -{ - /* Initialize stack pointer to the first stack argument. */ - if (jit_arg_reg_p(_jitc->function->vagp)) - addi(r0, _FP_REGNO, BIAS((16 + (__WORDSIZE == 32) + - _jitc->function->vagp) * - sizeof(jit_word_t))); - else - addi(r0, _FP_REGNO, BIAS(_jitc->function->self.size)); -} - -static void -_vaarg(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - assert(_jitc->function->self.call & jit_call_varargs); - - /* Load argument. */ - ldr(r0, r1); - - /* Update vararg stack pointer. */ - addi(r1, r1, sizeof(jit_word_t)); -} - -static void -_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label) -{ - jit_instr_t i; - union { - int32_t *i; - jit_word_t w; - } u; - - u.w = instr; - i.v = u.i[0]; - - if (i.op.b == 0) { /* conditional branch */ - if (i.op2.b == 2 || i.op2.b == 6) { /* int or float condition */ - i.disp22.b = (label - instr) >> 2; - u.i[0] = i.v; - } -# if __WORDSIZE == 64 - else if (i.op2.b == 1) { - i.disp19.b = (label - instr) >> 2; - u.i[0] = i.v; - } -# endif - else if (i.op2.b == 4) { /* movi_p */ - /* SETHI */ - i.imm22.b = HI((int)label); - u.i[0] = i.v; - i.v = u.i[1]; - if (i.op.b == 2 && i.op3.b == 2) { - /* ORI */ - i.simm13.b = LO(label); - u.i[1] = i.v; -# if __WORDSIZE == 64 - i.v = u.i[2]; - assert(i.op2.b == 4); - label = (label >> 32) & 0xffffffff; - i.imm22.b = HI((int)label); - u.i[2] = i.v; - i.v = u.i[3]; - assert(i.op.b == 2 && i.op3.b == 2); - /* ORI */ - i.simm13.b = LO(label); - u.i[3] = i.v; -# endif - } - else - abort(); - } - else - abort(); - } - else - abort(); -} -#endif diff --git a/lightening/sparc-fpu.c b/lightening/sparc-fpu.c deleted file mode 100644 index 3305b4deb..000000000 --- a/lightening/sparc-fpu.c +++ /dev/null @@ -1,1499 +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 -# if __WORDSIZE == 32 -# define FPR(r) (r) -# define CLASS_SNG jit_class_fpr -# define CLASS_DBL jit_class_fpr -# else -# define single_precision_p(r) ((r) >= 0 && (r) <= 31) -# define FPR(r) ((r) > 31 ? (r) - 31 : (r)) -# define CLASS_SNG (jit_class_fpr | jit_class_sng) -# define CLASS_DBL (jit_class_fpr | jit_class_dbl) -# endif -# define LDF(rs1, rs2, rd) f3r(3, FPR(rd), 32, FPR(rs1), FPR(rs2)) -# define LDFI(rs1, imm, rd) f3i(3, FPR(rd), 32, FPR(rs1), imm) -# define LDDF(rs1, rs2, rd) f3r(3, FPR(rd), 35, FPR(rs1), FPR(rs2)) -# define LDDFI(rs1, imm, rd) f3i(3, FPR(rd), 35, FPR(rs1), imm) -# define LDFSR(rs1, rs2, rd) f3r(3, FPR(rd), 33, FPR(rs1), FPR(rs2)) -# define LDFSRI(rs1, imm, rd) f3i(3, FPR(rd), 33, FPR(rs1), imm) -# define STF(rd, rs1, rs2) f3r(3, FPR(rd), 36, FPR(rs1), FPR(rs2)) -# define STFI(rd, rs1, imm) f3i(3, FPR(rd), 36, FPR(rs1), imm) -# define STDF(rd, rs1, rs2) f3r(3, FPR(rd), 39, FPR(rs1), FPR(rs2)) -# define STDFI(rd, rs1, imm) f3i(3, FPR(rd), 39, FPR(rs1), imm) -# define STFSR(rd, rs1, rs2) f3r(3, FPR(rd), 37, FPR(rs1), FPR(rs2)) -# define STFSRI(rd, rs1, imm) f3i(3, FPR(rd), 37, FPR(rs1), imm) -# define STDFQ(rd, rs1, rs2) f3r(3, FPR(rd), 38, FPR(rs1), FPR(rs2)) -# define STFDFQ(rd, rs1, imm) f3i(3, FPR(rd), 38, FPR(rs1), imm) -# define SPARC_FBA 8 /* always - 1 */ -# define SPARC_FBN 0 /* never - 0 */ -# define SPARC_FBU 7 /* unordered - U */ -# define SPARC_FBG 6 /* greater - G */ -# define SPARC_FBUG 5 /* unordered or greater - G or U */ -# define SPARC_FBL 4 /* less - L */ -# define SPARC_FBUL 3 /* unordered or less - L or U */ -# define SPARC_FBLG 2 /* less or greater - L or G */ -# define SPARC_FBNE 1 /* not equal - L or G or U */ -# define SPARC_FBNZ SPARC_FBNE -# define SPARC_FBE 9 /* equal - E */ -# define SPARC_FBZ SPARC_FBE -# define SPARC_FBUE 10 /* unordered or equal - E or U */ -# define SPARC_FBGE 11 /* greater or equal - E or G */ -# define SPARC_FBUGE 12 /* unordered or greater or equal - E or G or U */ -# define SPARC_FBLE 13 /* less or equal - E or L */ -# define SPARC_FBULE 14 /* unordered or less or equal - E or L or U */ -# define SPARC_FBO 15 /* ordered - E or L or G */ -# define FB(cc, imm) f2b(0, 0, cc, 6, imm) -# define FBa(cc, imm) f2b(0, 1, cc, 6, imm) -# define FBA(imm) FB(SPARC_FBA, imm) -# define FBAa(imm) FBa(SPARC_FBA, imm) -# define FBN(imm) FB(SPARC_FBN, imm) -# define FBNa(imm) FBa(SPARC_FBN, imm) -# define FBU(imm) FB(SPARC_FBU, imm) -# define FBUa(imm) FBa(SPARC_FBU, imm) -# define FBG(imm) FB(SPARC_FBG, imm) -# define FBGa(imm) FBa(SPARC_FBG, imm) -# define FBUG(imm) FB(SPARC_FBUG, imm) -# define FBUGa(imm) FBa(SPARC_FBUG, imm) -# define FBL(imm) FB(SPARC_FBL, imm) -# define FBLa(imm) FBa(SPARC_FBL, imm) -# define FBUL(imm) FB(SPARC_FBUL, imm) -# define FBULa(imm) FBa(SPARC_FBUL, imm) -# define FBLG(imm) FB(SPARC_FBLG, imm) -# define FBLGa(imm) FBa(SPARC_FBLG, imm) -# define FBNE(imm) FB(SPARC_FBNE, imm) -# define FBNEa(imm) FBa(SPARC_FBNE, imm) -# define FBE(imm) FB(SPARC_FBE, imm) -# define FBEa(imm) FBa(SPARC_FBE, imm) -# define FBUE(imm) FB(SPARC_FBUE, imm) -# define FBUEa(imm) FBa(SPARC_FBUE, imm) -# define FBLE(imm) FB(SPARC_FBLE, imm) -# define FBLEa(imm) FBa(SPARC_FBLE, imm) -# define FBO(imm) FB(SPARC_FBO, imm) -# define FBOa(imm) FBa(SPARC_FBO, imm) -# define FPop1(rd, rs1, opf, rs2) f3f(rd, 52, rs1, opf, rs2) -# define FPop2(rd, rs1, opf, rs2) f3f(rd, 53, rs1, opf, rs2) -# define f3f(rd, op3, rs1, opf, rs2) _f3f(_jit, rd, op3, rs1, opf, rs2) -static void -_f3f(jit_state_t*,int32_t,int32_t,int32_t, int32_t,int32_t); -# define FITOS(rs2, rd) FPop1(rd, 0, 196, rs2) -# define FITOD(rs2, rd) FPop1(rd, 0, 200, rs2) -# define FITOQ(rs2, rd) FPop1(rd, 0, 204, rs2) -# if __WORDSIZE == 64 -# define FXTOS(rs2, rd) FPop1(rd, 0, 132, rs2) -# define FXTOD(rs2, rd) FPop1(rd, 0, 136, rs2) -# define FxTOQ(rs2, rd) FPop1(rd, 0, 140, rs2) -# endif -# define FSTOI(rs2, rd) FPop1(rd, 0, 209, rs2) -# define FDTOI(rs2, rd) FPop1(rd, 0, 210, rs2) -# define FQTOI(rs2, rd) FPop1(rd, 0, 211, rs2) -# define FSTOX(rs2, rd) FPop1(rd, 0, 129, rs2) -# define FDTOX(rs2, rd) FPop1(rd, 0, 130, rs2) -# define FQTOX(rs2, rd) FPop1(rd, 0, 131, rs2) -# define FSTOD(rs2, rd) FPop1(rd, 0, 201, rs2) -# define FSTOQ(rs2, rd) FPop1(rd, 0, 205, rs2) -# define FDTOS(rs2, rd) FPop1(rd, 0, 198, rs2) -# define FDTOQ(rs2, rd) FPop1(rd, 0, 206, rs2) -# define FQTOS(rs2, rd) FPop1(rd, 0, 199, rs2) -# define FQTOD(rs2, rd) FPop1(rd, 0, 203, rs2) -# define FMOVS(rs2, rd) FPop1(rd, 0, 1, rs2) -# define FMOVD(rs2, rd) FPop1(rd, 0, 2, rs2) -# define FMOVQ(rs2, rd) FPop1(rd, 0, 3, rs2) -# define FNEGS(rs2, rd) FPop1(rd, 0, 5, rs2) -# define FNEGD(rs2, rd) FPop1(rd, 0, 6, rs2) -# define FNEGQ(rs2, rd) FPop1(rd, 0, 7, rs2) -# define FABSS(rs2, rd) FPop1(rd, 0, 9, rs2) -# define FABSD(rs2, rd) FPop1(rd, 0, 10, rs2) -# define FABSQ(rs2, rd) FPop1(rd, 0, 11, rs2) -# define FSQRTS(rs2, rd) FPop1(rd, 0, 41, rs2) -# define FSQRTD(rs2, rd) FPop1(rd, 0, 42, rs2) -# define FSQRTQ(rs2, rd) FPop1(rd, 0, 43, rs2) -# define SPARC_FADDS 65 -# define SPARC_FADDD 66 -# define SPARC_FADDQ 67 -# define SPARC_FSUBS 69 -# define SPARC_FSUBD 70 -# define SPARC_FSUBQ 71 -# define SPARC_FMULS 73 -# define SPARC_FMULD 74 -# define SPARC_FMULQ 75 -# define SPARC_FSMULD 105 -# define SPARC_FDMULQ 110 -# define SPARC_FDIVS 77 -# define SPARC_FDIVD 78 -# define SPARC_FDIVQ 79 -# define FADDS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDS, rs2) -# define FADDD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDD, rs2) -# define FADDQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDQ, rs2) -# define FSUBS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBS, rs2) -# define FSUBD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBD, rs2) -# define FSUBQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBQ, rs2) -# define FMULS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULS, rs2) -# define FMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULD, rs2) -# define FMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULQ, rs2) -# define FSMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSMULD, rs2) -# define FDMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDMULQ, rs2) -# define FDIVS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVS, rs2) -# define FDIVD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVD, rs2) -# define FDIVQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVQ, rs2) -# define SPARC_FCMPS 81 -# define SPARC_FCMPD 82 -# define SPARC_FCMPQ 83 -# define SPARC_FCMPES 85 -# define SPARC_FCMPED 86 -# define SPARC_FCMPEQ 87 -# define FCMPS(rs1, rs2) FPop2(0, rs1, SPARC_FCMPS, rs2) -# define FCMPD(rs1, rs2) FPop2(0, rs1, SPARC_FCMPD, rs2) -# define FCMPQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPQ, rs2) -# define FCMPES(rs1, rs2) FPop2(0, rs1, SPARC_FCMPES, rs2) -# define FCMPED(rs1, rs2) FPop2(0, rs1, SPARC_FCMPED, rs2) -# define FCMPEQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPEQ, rs2) -# define CPop1(rd, rs1, opc, rs2) f3f(rd, 54, rs1, opf, rs2) -# define CPop2(rd, rs1, opc, rs2) f3f(rd, 55, rs1, opf, rs2) -# define extr_f(r0, r1) _extr_f(_jit, r0, r1) -static void _extr_f(jit_state_t*, int32_t, int32_t); -# if __WORDSIZSE == 32 -# define truncr_f(r0, r1) truncr_f_i(r0, r1) -# define truncr_d(r0, r1) truncr_d_i(r0, r1) -# else -# define truncr_f(r0, r1) truncr_f_l(r0, r1) -# define truncr_d(r0, r1) truncr_d_l(r0, r1) -# endif -# define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1) -static void _truncr_f_i(jit_state_t*, int32_t, int32_t); -# if __WORDSIZE == 64 -# define truncr_f_l(r0, r1) _truncr_f_l(_jit, r0, r1) -static void _truncr_f_l(jit_state_t*, int32_t, int32_t); -# endif -# if __WORDSIZE == 32 -# define extr_d_f(r0, r1) FDTOS(r1, r0) -# else -# define extr_d_f(r0, r1) _extr_d_f(_jit, r0, r1) -static void _extr_d_f(jit_state_t*, int32_t, int32_t); -# endif -# define movi_f(r0, i0) _movi_f(_jit, r0, i0) -# if __WORDSIZE == 32 -# define movr_f(r0, r1) FMOVS(r1, r0) -# else -# define movr_f(r0, r1) _movr_f(_jit, r0, r1) -static void _movr_f(jit_state_t*, int32_t, int32_t); -# endif -static void _movi_f(jit_state_t*, int32_t, jit_float32_t*); -# if __WORDSIZE == 32 -# define negr_f(r0, r1) FNEGS(r1, r0) -# define absr_f(r0, r1) FABSS(r1, r0) -# define sqrtr_f(r0, r1) FSQRTS(r1, r0) -# else -# define negr_f(r0, r1) _negr_f(_jit, r0, r1) -static void _negr_f(jit_state_t*, int32_t, int32_t); -# define absr_f(r0, r1) _absr_f(_jit, r0, r1) -static void _absr_f(jit_state_t*, int32_t, int32_t); -# define sqrtr_f(r0, r1) _sqrtr_f(_jit, r0, r1) -static void _sqrtr_f(jit_state_t*, int32_t, int32_t); -# endif -# define extr_d(r0, r1) _extr_d(_jit, r0, r1) -static void _extr_d(jit_state_t*, int32_t, int32_t); -# define truncr_d_i(r0, r1) _truncr_d_i(_jit, r0, r1) -static void _truncr_d_i(jit_state_t*, int32_t, int32_t); -# if __WORDSIZE == 64 -# define truncr_d_l(r0, r1) _truncr_d_l(_jit, r0, r1) -static void _truncr_d_l(jit_state_t*, int32_t, int32_t); -# endif -# if __WORDSIZE == 32 -# define extr_f_d(r0, r1) FSTOD(r1, r0) -# else -# define extr_f_d(r0, r1) _extr_f_d(_jit, r0, r1) -static void _extr_f_d(jit_state_t*, int32_t, int32_t); -# endif -# define movi_d(r0, i0) _movi_d(_jit, r0, i0) -static void _movi_d(jit_state_t*, int32_t, jit_float64_t*); -# if __WORDSIZE == 32 -# define movr_d(r0, r1) _movr_d(_jit, r0, r1) -static void _movr_d(jit_state_t*, int32_t, int32_t); -# define negr_d(r0, r1) _negr_d(_jit, r0, r1) -static void _negr_d(jit_state_t*, int32_t, int32_t); -# define absr_d(r0, r1) _absr_d(_jit, r0, r1) -static void _absr_d(jit_state_t*, int32_t, int32_t); -# else -# define movr_d(r0, r1) FMOVD(r1, r0) -# define negr_d(r0, r1) FNEGD(r1, r0) -# define absr_d(r0, r1) FABSD(r1, r0) -# endif -# define sqrtr_d(r0, r1) FSQRTD(r1, r0) -# define fop1f(op, r0, r1, i0) _fop1f(_jit, op, r0, r1, i0) -static void _fop1f(jit_state_t*,int32_t, - int32_t,int32_t,jit_float32_t*); -# define rfop1f(op, r0, r1, i0) _rfop1f(_jit, op, r0, r1, i0) -static void _rfop1f(jit_state_t*,int32_t, - int32_t,int32_t,jit_float32_t*); -# define fop1d(op, r0, r1, i0) _fop1d(_jit, op, r0, r1, i0) -static void _fop1d(jit_state_t*,int32_t, - int32_t,int32_t,jit_float64_t*); -# define rfop1d(op, r0, r1, i0) _rfop1d(_jit, op, r0, r1, i0) -static void _rfop1d(jit_state_t*,int32_t, - int32_t,int32_t,jit_float64_t*); -# if __WORDSIZE == 32 -# define addr_f(r0, r1, r2) FADDS(r1, r2, r0) -# define subr_f(r0, r1, r2) FSUBS(r1, r2, r0) -# define mulr_f(r0, r1, r2) FMULS(r1, r2, r0) -# define divr_f(r0, r1, r2) FDIVS(r1, r2, r0) -# else -# define fop2f(op, r0, r1, r2) _fop2f(_jit, op, r0, r1, r2) -static void _fop2f(jit_state_t*, int32_t, - int32_t, int32_t, int32_t); -# define addr_f(r0, r1, r2) fop2f(SPARC_FADDS, r0, r1, r2) -# define subr_f(r0, r1, r2) fop2f(SPARC_FSUBS, r0, r1, r2) -# define mulr_f(r0, r1, r2) fop2f(SPARC_FMULS, r0, r1, r2) -# define divr_f(r0, r1, r2) fop2f(SPARC_FDIVS, r0, r1, r2) -# endif -# define addi_f(r0, r1, i0) fop1f(SPARC_FADDS, r0, r1, i0) -# define subi_f(r0, r1, i0) fop1f(SPARC_FSUBS, r0, r1, i0) -# define rsbr_f(r0, r1, r2) subr_f(r0, r2, r1) -# define rsbi_f(r0, r1, i0) rfop1f(SPARC_FSUBS, r0, r1, i0) -# define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1) -# define rsbi_d(r0, r1, i0) rfop1d(SPARC_FSUBD, r0, r1, i0) -# define muli_f(r0, r1, i0) fop1f(SPARC_FMULS, r0, r1, i0) -# define divi_f(r0, r1, i0) fop1f(SPARC_FDIVS, r0, r1, i0) -# define addr_d(r0, r1, r2) FADDD(r1, r2, r0) -# define addi_d(r0, r1, i0) fop1d(SPARC_FADDD, r0, r1, i0) -# define subr_d(r0, r1, r2) FSUBD(r1, r2, r0) -# define subi_d(r0, r1, i0) fop1d(SPARC_FSUBD, r0, r1, i0) -# define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1) -# define rsbi_d(r0, r1, i0) rfop1d(SPARC_FSUBD, r0, r1, i0) -# define mulr_d(r0, r1, r2) FMULD(r1, r2, r0) -# define muli_d(r0, r1, i0) fop1d(SPARC_FMULD, r0, r1, i0) -# define divr_d(r0, r1, r2) FDIVD(r1, r2, r0) -# define divi_d(r0, r1, i0) fop1d(SPARC_FDIVD, r0, r1, i0) -#define fcr(cc, r0, r1, r2) _fcr(_jit, cc, r0, r1, r2) -static void _fcr(jit_state_t*,int32_t,int32_t,int32_t,int32_t); -#define fcw(cc, r0, r1, i0) _fcw(_jit, cc, r0, r1, i0) -static void -_fcw(jit_state_t*,int32_t,int32_t,int32_t,jit_float32_t*); -# define ltr_f(r0, r1, r2) fcr(SPARC_FBL, r0, r1, r2) -# define lti_f(r0, r1, i0) fcw(SPARC_FBL, r0, r1, i0) -# define ler_f(r0, r1, r2) fcr(SPARC_FBLE, r0, r1, r2) -# define lei_f(r0, r1, i0) fcw(SPARC_FBLE, r0, r1, i0) -# define eqr_f(r0, r1, r2) fcr(SPARC_FBE, r0, r1, r2) -# define eqi_f(r0, r1, i0) fcw(SPARC_FBE, r0, r1, i0) -# define ger_f(r0, r1, r2) fcr(SPARC_FBGE, r0, r1, r2) -# define gei_f(r0, r1, i0) fcw(SPARC_FBGE, r0, r1, i0) -# define gtr_f(r0, r1, r2) fcr(SPARC_FBG, r0, r1, r2) -# define gti_f(r0, r1, i0) fcw(SPARC_FBG, r0, r1, i0) -# define ner_f(r0, r1, r2) fcr(SPARC_FBNE, r0, r1, r2) -# define nei_f(r0, r1, i0) fcw(SPARC_FBNE, r0, r1, i0) -# define unltr_f(r0, r1, r2) fcr(SPARC_FBUL, r0, r1, r2) -# define unlti_f(r0, r1, i0) fcw(SPARC_FBUL, r0, r1, i0) -# define unler_f(r0, r1, r2) fcr(SPARC_FBULE, r0, r1, r2) -# define unlei_f(r0, r1, i0) fcw(SPARC_FBULE, r0, r1, i0) -# define uneqr_f(r0, r1, r2) fcr(SPARC_FBUE, r0, r1, r2) -# define uneqi_f(r0, r1, i0) fcw(SPARC_FBUE, r0, r1, i0) -# define unger_f(r0, r1, r2) fcr(SPARC_FBUGE, r0, r1, r2) -# define ungei_f(r0, r1, i0) fcw(SPARC_FBUGE, r0, r1, i0) -# define ungtr_f(r0, r1, r2) fcr(SPARC_FBUG, r0, r1, r2) -# define ungti_f(r0, r1, i0) fcw(SPARC_FBUG, r0, r1, i0) -# define ltgtr_f(r0, r1, r2) fcr(SPARC_FBLG, r0, r1, r2) -# define ltgti_f(r0, r1, i0) fcw(SPARC_FBLG, r0, r1, i0) -# define ordr_f(r0, r1, r2) fcr(SPARC_FBO, r0, r1, r2) -# define ordi_f(r0, r1, i0) fcw(SPARC_FBO, r0, r1, i0) -# define unordr_f(r0, r1, r2) fcr(SPARC_FBU, r0, r1, r2) -# define unordi_f(r0, r1, i0) fcw(SPARC_FBU, r0, r1, i0) -#define dcr(cc, r0, r1, r2) _dcr(_jit, cc, r0, r1, r2) -static void _dcr(jit_state_t*,int32_t,int32_t,int32_t,int32_t); -#define dcw(cc, r0, r1, i0) _dcw(_jit, cc, r0, r1, i0) -static void -_dcw(jit_state_t*,int32_t,int32_t,int32_t,jit_float64_t*); -# define ltr_d(r0, r1, r2) dcr(SPARC_FBL, r0, r1, r2) -# define lti_d(r0, r1, i0) dcw(SPARC_FBL, r0, r1, i0) -# define ler_d(r0, r1, r2) dcr(SPARC_FBLE, r0, r1, r2) -# define lei_d(r0, r1, i0) dcw(SPARC_FBLE, r0, r1, i0) -# define eqr_d(r0, r1, r2) dcr(SPARC_FBE, r0, r1, r2) -# define eqi_d(r0, r1, i0) dcw(SPARC_FBE, r0, r1, i0) -# define ger_d(r0, r1, r2) dcr(SPARC_FBGE, r0, r1, r2) -# define gei_d(r0, r1, i0) dcw(SPARC_FBGE, r0, r1, i0) -# define gtr_d(r0, r1, r2) dcr(SPARC_FBG, r0, r1, r2) -# define gti_d(r0, r1, i0) dcw(SPARC_FBG, r0, r1, i0) -# define ner_d(r0, r1, r2) dcr(SPARC_FBNE, r0, r1, r2) -# define nei_d(r0, r1, i0) dcw(SPARC_FBNE, r0, r1, i0) -# define unltr_d(r0, r1, r2) dcr(SPARC_FBUL, r0, r1, r2) -# define unlti_d(r0, r1, i0) dcw(SPARC_FBUL, r0, r1, i0) -# define unler_d(r0, r1, r2) dcr(SPARC_FBULE, r0, r1, r2) -# define unlei_d(r0, r1, i0) dcw(SPARC_FBULE, r0, r1, i0) -# define uneqr_d(r0, r1, r2) dcr(SPARC_FBUE, r0, r1, r2) -# define uneqi_d(r0, r1, i0) dcw(SPARC_FBUE, r0, r1, i0) -# define unger_d(r0, r1, r2) dcr(SPARC_FBUGE, r0, r1, r2) -# define ungei_d(r0, r1, i0) dcw(SPARC_FBUGE, r0, r1, i0) -# define ungtr_d(r0, r1, r2) dcr(SPARC_FBUG, r0, r1, r2) -# define ungti_d(r0, r1, i0) dcw(SPARC_FBUG, r0, r1, i0) -# define ltgtr_d(r0, r1, r2) dcr(SPARC_FBLG, r0, r1, r2) -# define ltgti_d(r0, r1, i0) dcw(SPARC_FBLG, r0, r1, i0) -# define ordr_d(r0, r1, r2) dcr(SPARC_FBO, r0, r1, r2) -# define ordi_d(r0, r1, i0) dcw(SPARC_FBO, r0, r1, i0) -# define unordr_d(r0, r1, r2) dcr(SPARC_FBU, r0, r1, r2) -# define unordi_d(r0, r1, i0) dcw(SPARC_FBU, r0, r1, i0) -# if __WORDSIZE == 32 -# define ldr_f(r0, r1) LDF(r1, 0, r0) -# else -# define ldr_f(r0, r1) _ldr_f(_jit, r0, r1) -static void _ldr_f(jit_state_t*,int32_t,int32_t); -# endif -# define ldi_f(r0, i0) _ldi_f(_jit, r0, i0) -static void _ldi_f(jit_state_t*,int32_t,jit_word_t); -# if __WORDSIZE == 32 -# define ldxr_f(r0, r1, r2) LDF(r1, r2, r0) -# else -# define ldxr_f(r0, r1, r2) _ldxr_f(_jit, r0, r1, r2) -static void _ldxr_f(jit_state_t*,int32_t,int32_t,int32_t); -# endif -# 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); -# if __WORDSIZE == 32 -# define str_f(r0, r1) STF(r1, r0, 0) -# else -# define str_f(r0, r1) _str_f(_jit, r0, r1) -static void _str_f(jit_state_t*,int32_t,int32_t); -# endif -# define sti_f(r0, i0) _sti_f(_jit, r0, i0) -static void _sti_f(jit_state_t*,jit_word_t,int32_t); -# if __WORDSIZE == 32 -# define stxr_f(r0, r1, r2) STF(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); -# endif -# define stxi_f(r0, r1, i0) _stxi_f(_jit, r0, r1, i0) -static void _stxi_f(jit_state_t*,jit_word_t,int32_t,int32_t); -# define ldr_d(r0, r1) LDDF(r1, 0, 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) LDDF(r1, r2, r0) -# define ldxi_d(r0, r1, i0) _ldxi_d(_jit, r0, r1, i0) -static void _ldxi_d(jit_state_t*,int32_t,int32_t,int32_t); -# define str_d(r0, r1) STDF(r1, r0, 0) -# define sti_d(r0, i0) _sti_d(_jit, r0, i0) -static void _sti_d(jit_state_t*,jit_word_t,int32_t); -# define stxr_d(r0, r1, r2) STDF(r2, r1, r0) -# define stxi_d(r0, r1, i0) _stxi_d(_jit, r0, r1, i0) -static void _stxi_d(jit_state_t*,int32_t,int32_t,int32_t); -# define fbr(cc, i0, r0, r1) _fbr(_jit, cc, i0, r0, r1) -static jit_word_t -_fbr(jit_state_t*,int32_t,jit_word_t,int32_t,int32_t); -# define fbw(cc, i0, r0, i1) _fbw(_jit, cc, i0, r0, i1) -static jit_word_t -_fbw(jit_state_t*,int32_t,jit_word_t,int32_t,jit_float32_t*); -# define bltr_f(i0, r0, r1) fbr(SPARC_FBL, i0, r0, r1) -# define blti_f(i0, r0, i1) fbw(SPARC_FBL, i0, r0, i1) -# define bler_f(i0, r0, r1) fbr(SPARC_FBLE, i0, r0, r1) -# define blei_f(i0, r0, i1) fbw(SPARC_FBLE, i0, r0, i1) -# define beqr_f(i0, r0, r1) fbr(SPARC_FBE, i0, r0, r1) -# define beqi_f(i0, r0, i1) fbw(SPARC_FBE, i0, r0, i1) -# define bger_f(i0, r0, r1) fbr(SPARC_FBGE, i0, r0, r1) -# define bgei_f(i0, r0, i1) fbw(SPARC_FBGE, i0, r0, i1) -# define bgtr_f(i0, r0, r1) fbr(SPARC_FBG, i0, r0, r1) -# define bgti_f(i0, r0, i1) fbw(SPARC_FBG, i0, r0, i1) -# define bner_f(i0, r0, r1) fbr(SPARC_FBNE, i0, r0, r1) -# define bnei_f(i0, r0, i1) fbw(SPARC_FBNE, i0, r0, i1) -# define bunltr_f(i0, r0, r1) fbr(SPARC_FBUL, i0, r0, r1) -# define bunlti_f(i0, r0, i1) fbw(SPARC_FBUL, i0, r0, i1) -# define bunler_f(i0, r0, r1) fbr(SPARC_FBULE, i0, r0, r1) -# define bunlei_f(i0, r0, i1) fbw(SPARC_FBULE, i0, r0, i1) -# define buneqr_f(i0, r0, r1) fbr(SPARC_FBUE, i0, r0, r1) -# define buneqi_f(i0, r0, i1) fbw(SPARC_FBUE, i0, r0, i1) -# define bunger_f(i0, r0, r1) fbr(SPARC_FBUGE, i0, r0, r1) -# define bungei_f(i0, r0, i1) fbw(SPARC_FBUGE, i0, r0, i1) -# define bungtr_f(i0, r0, r1) fbr(SPARC_FBUG, i0, r0, r1) -# define bungti_f(i0, r0, i1) fbw(SPARC_FBUG, i0, r0, i1) -# define bltgtr_f(i0, r0, r1) fbr(SPARC_FBLG, i0, r0, r1) -# define bltgti_f(i0, r0, i1) fbw(SPARC_FBLG, i0, r0, i1) -# define bordr_f(i0, r0, r1) fbr(SPARC_FBO, i0, r0, r1) -# define bordi_f(i0, r0, i1) fbw(SPARC_FBO, i0, r0, i1) -# define bunordr_f(i0, r0, r1) fbr(SPARC_FBU, i0, r0, r1) -# define bunordi_f(i0, r0, i1) fbw(SPARC_FBU, i0, r0, i1) -# define dbr(cc, i0, r0, r1) _dbr(_jit, cc, i0, r0, r1) -static jit_word_t -_dbr(jit_state_t*,int32_t,jit_word_t,int32_t,int32_t); -# define dbw(cc, i0, r0, i1) _dbw(_jit, cc, i0, r0, i1) -static jit_word_t -_dbw(jit_state_t*,int32_t,jit_word_t,int32_t,jit_float64_t*); -# define bltr_d(i0, r0, r1) dbr(SPARC_FBL, i0, r0, r1) -# define blti_d(i0, r0, i1) dbw(SPARC_FBL, i0, r0, i1) -# define bler_d(i0, r0, r1) dbr(SPARC_FBLE, i0, r0, r1) -# define blei_d(i0, r0, i1) dbw(SPARC_FBLE, i0, r0, i1) -# define beqr_d(i0, r0, r1) dbr(SPARC_FBE, i0, r0, r1) -# define beqi_d(i0, r0, i1) dbw(SPARC_FBE, i0, r0, i1) -# define bger_d(i0, r0, r1) dbr(SPARC_FBGE, i0, r0, r1) -# define bgei_d(i0, r0, i1) dbw(SPARC_FBGE, i0, r0, i1) -# define bgtr_d(i0, r0, r1) dbr(SPARC_FBG, i0, r0, r1) -# define bgti_d(i0, r0, i1) dbw(SPARC_FBG, i0, r0, i1) -# define bner_d(i0, r0, r1) dbr(SPARC_FBNE, i0, r0, r1) -# define bnei_d(i0, r0, i1) dbw(SPARC_FBNE, i0, r0, i1) -# define bunltr_d(i0, r0, r1) dbr(SPARC_FBUL, i0, r0, r1) -# define bunlti_d(i0, r0, i1) dbw(SPARC_FBUL, i0, r0, i1) -# define bunler_d(i0, r0, r1) dbr(SPARC_FBULE, i0, r0, r1) -# define bunlei_d(i0, r0, i1) dbw(SPARC_FBULE, i0, r0, i1) -# define buneqr_d(i0, r0, r1) dbr(SPARC_FBUE, i0, r0, r1) -# define buneqi_d(i0, r0, i1) dbw(SPARC_FBUE, i0, r0, i1) -# define bunger_d(i0, r0, r1) dbr(SPARC_FBUGE, i0, r0, r1) -# define bungei_d(i0, r0, i1) dbw(SPARC_FBUGE, i0, r0, i1) -# define bungtr_d(i0, r0, r1) dbr(SPARC_FBUG, i0, r0, r1) -# define bungti_d(i0, r0, i1) dbw(SPARC_FBUG, i0, r0, i1) -# define bltgtr_d(i0, r0, r1) dbr(SPARC_FBLG, i0, r0, r1) -# define bltgti_d(i0, r0, i1) dbw(SPARC_FBLG, i0, r0, i1) -# define bordr_d(i0, r0, r1) dbr(SPARC_FBO, i0, r0, r1) -# define bordi_d(i0, r0, i1) dbw(SPARC_FBO, i0, r0, i1) -# define bunordr_d(i0, r0, r1) dbr(SPARC_FBU, i0, r0, r1) -# define bunordi_d(i0, r0, i1) dbw(SPARC_FBU, 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 -_f3f(jit_state_t *_jit, int32_t rd, - int32_t op3, int32_t rs1, int32_t opf, int32_t rs2) -{ - jit_instr_t v; -# if __WORDSIZE == 64 - if (rd > 31) { - assert(rd <= 63 && (rd & 1) == 0); - rd -= 31; - } - if (rs1 > 31) { - assert(rs1 <= 63 && (rs1 & 1) == 0); - rs1 -= 31; - } - if (rs2 > 31) { - assert(rs2 <= 63 && (rs2 & 1) == 0); - rs2 -= 31; - } -# endif - assert(!(rd & 0xffffffe0)); - assert(!(op3 & 0xffffffc0)); - assert(!(rs1 & 0xffffffe0)); - assert(!(opf & 0xfffffe00)); - assert(!(rs2 & 0xffffffe0)); - v.op.b = 2; - v.rd.b = rd; - v.op3.b = op3; - v.rs1.b = rs1; - v.opf.b = opf; - v.rs2.b = rs2; - ii(v.v); -} - -# if __WORDSIZE == 64 -static void -_movr_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t t0, t1; - if (r0 != r1) { - if (single_precision_p(r0)) { - if (single_precision_p(r1)) - FMOVS(r1, r0); - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FMOVS(rn(t1), r0); - jit_unget_reg(t1); - } - } - else { - if (single_precision_p(r1)) { - t0 = jit_get_reg(CLASS_SNG); - FMOVS(r1, rn(t0)); - movr_d(r0, rn(t0)); - jit_unget_reg(t0); - } - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FMOVS(rn(t1), rn(t1)); - movr_d(r0, rn(t1)); - jit_unget_reg(t1); - } - } - } -} - -static void -_negr_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t t0, t1; - if (single_precision_p(r0)) { - if (single_precision_p(r1)) - FNEGS(r1, r0); - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FNEGS(rn(t1), r0); - jit_unget_reg(t1); - } - } - else { - if (single_precision_p(r1)) { - t0 = jit_get_reg(CLASS_SNG); - FNEGS(r1, rn(t0)); - movr_d(r0, rn(t0)); - jit_unget_reg(t0); - } - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FNEGS(rn(t1), rn(t1)); - movr_d(r0, rn(t1)); - jit_unget_reg(t1); - } - } -} - -static void -_absr_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t t0, t1; - if (single_precision_p(r0)) { - if (single_precision_p(r1)) - FABSS(r1, r0); - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FABSS(rn(t1), r0); - jit_unget_reg(t1); - } - } - else { - if (single_precision_p(r1)) { - t0 = jit_get_reg(CLASS_SNG); - FABSS(r1, rn(t0)); - movr_d(r0, rn(t0)); - jit_unget_reg(t0); - } - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FABSS(rn(t1), rn(t1)); - movr_d(r0, rn(t1)); - jit_unget_reg(t1); - } - } -} - -static void -_sqrtr_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t t0, t1; - if (single_precision_p(r0)) { - if (single_precision_p(r1)) - FSQRTS(r1, r0); - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FSQRTS(rn(t1), r0); - jit_unget_reg(t1); - } - } - else { - if (single_precision_p(r1)) { - t0 = jit_get_reg(CLASS_SNG); - FSQRTS(r1, rn(t0)); - movr_d(r0, rn(t0)); - jit_unget_reg(t0); - } - else { - t1 = jit_get_reg(CLASS_SNG); - movr_d(rn(t1), r1); - FSQRTS(rn(t1), rn(t1)); - movr_d(r0, rn(t1)); - jit_unget_reg(t1); - } - } -} -# endif - -# if __WORDSIZE == 64 -static void -_extr_d_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - if (!single_precision_p(r0)) { - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r0); - FDTOS(r1, rn(reg)); - movr_d(r0, rn(reg)); - jit_unget_reg(reg); - } - else - FDTOS(r1, r0); -} -# endif - -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 & 0xffffffff); - stxi_i(BIAS(-8), _FP_REGNO, rn(reg)); - jit_unget_reg(reg); - ldxi_f(r0, _FP_REGNO, BIAS(-8)); - } - else - ldi_f(r0, (jit_word_t)i0); -} - -# if __WORDSIZE == 64 -static void -_extr_f_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - if (!single_precision_p(r1)) { - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r1); - FSTOD(rn(reg), r0); - jit_unget_reg(reg); - } - else - FSTOD(r1, r0); -} -# endif - -static void -_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0) -{ - union { -# if __WORDSIZE == 32 - int32_t i[2]; -# else - jit_word_t w; -# endif - jit_float64_t d; - } data; - int32_t reg; - - if (_jitc->no_data) { - data.d = *i0; - reg = jit_get_reg(jit_class_gpr); -# if __WORDSIZE == 32 - movi(rn(reg), data.i[0]); -# else - movi(rn(reg), data.w); -# endif - stxi(BIAS(-8), _FP_REGNO, rn(reg)); -# if __WORDSIZE == 32 - movi(rn(reg), data.i[1]); - stxi_i(BIAS(-4), _FP_REGNO, rn(reg)); -# endif - jit_unget_reg(reg); - ldxi_d(r0, _FP_REGNO, BIAS(-8)); - } - else - ldi_d(r0, (jit_word_t)i0); -} - -# if __WORDSIZE == 32 -static void -_movr_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - assert(!(r0 & 1)); - assert(!(r1 & 1)); - if (r0 != r1) { - FMOVS(r1, r0); - FMOVS(r1 + 1, r0 + 1); - } -} - -static void -_negr_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - assert(!(r0 & 1)); - assert(!(r1 & 1)); - FNEGS(r1, r0); - if (r0 != r1) - FMOVS(r1 + 1, r0 + 1); -} - -static void -_absr_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - assert(!(r0 & 1)); - assert(!(r1 & 1)); - FABSS(r1, r0); - if (r0 != r1) - FMOVS(r1 + 1, r0 + 1); -} -# endif - -# if __WORDSIZE == 64 -# define single_rrr(NAME, CODE) \ -static void \ -NAME(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) \ -{ \ - int32_t x0, t0, x1, t1, x2, t2, mask = 0; \ - if (!single_precision_p(r0)) { \ - mask |= 1; \ - t0 = jit_get_reg(CLASS_SNG); \ - x0 = rn(t0); \ - if (r0 == r1) { \ - x1 = x0; \ - movr_d(x1, r1); \ - if (r0 == r2) \ - x2 = x0; \ - } \ - else if (r0 == r2) { \ - x2 = x0; \ - movr_d(x2, r2); \ - } \ - } \ - else \ - x0 = r0; \ - if (!single_precision_p(r1)) { \ - if (r0 != r1) { \ - mask |= 2; \ - t1 = jit_get_reg(CLASS_SNG); \ - x1 = rn(t1); \ - movr_d(x1, r1); \ - if (r1 == r2) \ - x2 = x1; \ - } \ - } \ - else \ - x1 = r1; \ - if (!single_precision_p(r2)) { \ - if (r0 != r2 && r1 != r2) { \ - mask |= 4; \ - t2 = jit_get_reg(CLASS_SNG); \ - x2 = rn(t2); \ - movr_d(x2, r2); \ - } \ - } \ - else \ - x2 = r2; \ - CODE(x1, x2, x0); \ - if (mask & 1) { \ - movr_d(r0, x0); \ - jit_unget_reg(t0); \ - } \ - if (mask & 2) \ - jit_unget_reg(t1); \ - if (mask & 4) \ - jit_unget_reg(t2); \ -} - -static void -_fop2f(jit_state_t *_jit, int32_t op, - int32_t r0, int32_t r1, int32_t r2) -{ - int32_t x0, t0, x1, t1, x2, t2, mask = 0; - if (!single_precision_p(r0)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - if (r0 == r1) { - x1 = x0; - movr_d(x1, r1); - if (r0 == r2) - x2 = x0; - } - else if (r0 == r2) { - x2 = x0; - movr_d(x2, r2); - } - } - else - x0 = r0; - if (!single_precision_p(r1)) { - if (r0 != r1) { - mask |= 2; - t1 = jit_get_reg(CLASS_SNG); - x1 = rn(t1); - movr_d(x1, r1); - if (r1 == r2) - x2 = x1; - } - } - else - x1 = r1; - if (!single_precision_p(r2)) { - if (r0 != r2 && r1 != r2) { - mask |= 4; - t2 = jit_get_reg(CLASS_SNG); - x2 = rn(t2); - movr_d(x2, r2); - } - } - else - x2 = r2; - FPop1(x0, x1, op, x2); - if (mask & 1) { - movr_d(r0, x0); - jit_unget_reg(t0); - } - if (mask & 2) - jit_unget_reg(t1); - if (mask & 4) - jit_unget_reg(t2); -} -# endif - -static void -_fop1f(jit_state_t *_jit, int32_t op, - int32_t r0, int32_t r1, jit_float32_t *i0) -{ - int32_t reg; -# if __WORDSIZE == 64 - int32_t x0, t0, x1, t1, mask = 0; -# endif - reg = jit_get_reg(CLASS_SNG); - movi_f(rn(reg), i0); -# if __WORDSIZE == 64 - if (!single_precision_p(r0)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - if (r0 == r1) { - x1 = x0; - movr_d(x1, r1); - } - } - else - x0 = r0; - if (!single_precision_p(r1)) { - if (r0 != r1) { - mask |= 2; - t1 = jit_get_reg(CLASS_SNG); - x1 = rn(t1); - movr_d(x1, r1); - } - } - else - x1 = r1; - FPop1(x0, x1, op, rn(reg)); - if (mask & 1) { - movr_d(r0, x0); - jit_unget_reg(t0); - } - if (mask & 2) - jit_unget_reg(t1); -# else - FPop1(r0, r1, op, rn(reg)); -# endif - jit_unget_reg(reg); -} - -static void -_rfop1f(jit_state_t *_jit, int32_t op, - int32_t r0, int32_t r1, jit_float32_t *i0) -{ - int32_t reg; -# if __WORDSIZE == 64 - int32_t x0, t0, x1, t1, mask = 0; -# endif - reg = jit_get_reg(CLASS_SNG); - movi_f(rn(reg), i0); -# if __WORDSIZE == 64 - if (!single_precision_p(r0)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - if (r0 == r1) { - x1 = x0; - movr_d(x1, r1); - } - } - else - x0 = r0; - if (!single_precision_p(r1)) { - if (r0 != r1) { - mask |= 2; - t1 = jit_get_reg(CLASS_SNG); - x1 = rn(t1); - movr_d(x1, r1); - } - } - else - x1 = r1; - FPop1(x0, rn(reg), op, x1); - if (mask & 1) { - movr_d(r0, x0); - jit_unget_reg(t0); - } - if (mask & 2) - jit_unget_reg(t1); -# else - FPop1(r0, rn(reg), op, r1); -# endif - jit_unget_reg(reg); -} - -static void -_fop1d(jit_state_t *_jit, int32_t op, - int32_t r0, int32_t r1, jit_float64_t *i0) -{ - int32_t reg; - reg = jit_get_reg(CLASS_DBL); - movi_d(rn(reg), i0); - FPop1(r0, r1, op, rn(reg)); - jit_unget_reg(reg); -} - -static void -_rfop1d(jit_state_t *_jit, int32_t op, - int32_t r0, int32_t r1, jit_float64_t *i0) -{ - int32_t reg; - reg = jit_get_reg(CLASS_DBL); - movi_d(rn(reg), i0); - FPop1(r0, rn(reg), op, r1); - jit_unget_reg(reg); -} - -static void -_extr_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - stxi(BIAS(-8), _FP_REGNO, r1); -# if __WORDSIZE == 32 - ldxi_f(r0, _FP_REGNO, BIAS(-8)); - FITOS(r0, r0); -# else - ldxi_d(r0, _FP_REGNO, BIAS(-8)); - if (!single_precision_p(r0)) { - int32_t reg; - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r0); - FXTOS(rn(reg), rn(reg)); - movr_d(r0, rn(reg)); - jit_unget_reg(reg); - } - else - FXTOS(r0, r0); -# endif -} - -static void -_truncr_f_i(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - reg = jit_get_reg(CLASS_SNG); -# if __WORDSIZE == 64 - if (!single_precision_p(r1)) { - movr_d(rn(reg), r1); - FSTOI(rn(reg), rn(reg)); - } - else -# endif - FSTOI(r1, rn(reg)); - stxi_f(BIAS(-8), _FP_REGNO, rn(reg)); - ldxi_i(r0, _FP_REGNO, BIAS(-8)); - jit_unget_reg(reg); -} - -# if __WORDSIZE == 64 -static void -_truncr_f_l(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - reg = jit_get_reg(CLASS_SNG); -# if __WORDSIZE == 64 - if (!single_precision_p(r1)) { - movr_d(rn(reg), r1); - FSTOX(rn(reg), rn(reg)); - } - else -# endif - FSTOX(r1, rn(reg)); - stxi_d(BIAS(-8), _FP_REGNO, rn(reg)); - ldxi_l(r0, _FP_REGNO, BIAS(-8)); - jit_unget_reg(reg); -} -# endif - -static void -_fcr(jit_state_t *_jit, int32_t cc, - int32_t r0, int32_t r1, int32_t r2) -{ -# if __WORDSIZE == 64 - int32_t x0, t0, x1, t1, mask = 0; - if (!single_precision_p(r1)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - movr_d(x0, r1); - } - else - x0 = r1; - if (r1 == r2) - x1 = x0; - else if (!single_precision_p(r2)) { - mask |= 2; - t1 = jit_get_reg(CLASS_SNG); - x1 = rn(t1); - movr_d(x1, r2); - } - else - x1 = r2; - FCMPS(x0, x1); - if (mask & 1) - jit_unget_reg(t0); - if (mask & 2) - jit_unget_reg(t1); -# else - FCMPS(r1, r2); -# endif - FBa(cc, 3); - movi(r0, 1); - movi(r0, 0); -} - -static void -_fcw(jit_state_t *_jit, int32_t cc, - int32_t r0, int32_t r1, jit_float32_t *i0) -{ - int32_t reg; -# if __WORDSIZE == 64 - int32_t x0, t0, mask = 0; - if (!single_precision_p(r1)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - movr_d(x0, r1); - } - else - x0 = r1; -# endif - reg = jit_get_reg(CLASS_SNG); - movi_f(rn(reg), i0); -# if __WORDSIZE == 64 - FCMPS(x0, rn(reg)); - if (mask & 1) - jit_unget_reg(t0); -# else - FCMPS(r1, rn(reg)); -# endif - jit_unget_reg(reg); - FBa(cc, 3); - movi(r0, 1); - movi(r0, 0); -} - -static void -_dcr(jit_state_t *_jit, int32_t cc, - int32_t r0, int32_t r1, int32_t r2) -{ - FCMPD(r1, r2); - FBa(cc, 3); - movi(r0, 1); - movi(r0, 0); -} - -static void -_dcw(jit_state_t *_jit, int32_t cc, - int32_t r0, int32_t r1, jit_float64_t *i0) -{ - int32_t reg; - reg = jit_get_reg(CLASS_DBL); - movi_d(rn(reg), i0); - FCMPD(r1, rn(reg)); - jit_unget_reg(reg); - FBa(cc, 3); - movi(r0, 1); - movi(r0, 0); -} - -# if __WORDSIZE == 64 -static void -_ldr_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - if (!single_precision_p(r0)) { - reg = jit_get_reg(CLASS_SNG); - LDF(r1, 0, rn(reg)); - movr_d(r0, rn(reg)); - jit_unget_reg(reg); - } - else - LDF(r1, 0, r0); -} -# endif - -static void -_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 64 - if (!single_precision_p(r0)) { - reg = jit_get_reg(CLASS_SNG); - LDFI(0, i0, rn(reg)); - movr_d(r0, rn(reg)); - jit_unget_reg(reg); - } - else -# endif - LDFI(0, i0, r0); - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldr_f(r0, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - if (!single_precision_p(r0)) { - reg = jit_get_reg(CLASS_SNG); - LDF(r1, r2, rn(reg)); - movr_d(r0, rn(reg)); - jit_unget_reg(reg); - } - else - LDF(r1, r2, r0); -} -# endif - -static void -_ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 64 - if (!single_precision_p(r0)) { - reg = jit_get_reg(CLASS_SNG); - LDFI(r1, i0, rn(reg)); - movr_d(r0, rn(reg)); - jit_unget_reg(reg); - } - else -# endif - LDFI(r1, i0, r0); - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - ldxr_f(r0, r1, rn(reg)); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_str_f(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - if (!single_precision_p(r1)) { - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r1); - STF(rn(reg), r0, 0); - jit_unget_reg(reg); - } - else - STF(r1, r0, 0); -} -# endif - -static void -_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 64 - if (!single_precision_p(r0)) { - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r0); - STFI(rn(reg), 0, i0); - jit_unget_reg(reg); - } - else -# endif - STFI(r0, 0, i0); - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - str_f(rn(reg), r0); - jit_unget_reg(reg); - } -} - -# if __WORDSIZE == 64 -static void -_stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) -{ - int32_t reg; - if (!single_precision_p(r2)) { - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r2); - STF(rn(reg), r1, r0); - jit_unget_reg(reg); - } - else - STF(r2, r1, r0); -} -# endif - -static void -_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1) -{ - int32_t reg; - if (s13_p(i0)) { -# if __WORDSIZE == 64 - if (!single_precision_p(r1)) { - reg = jit_get_reg(CLASS_SNG); - movr_d(rn(reg), r1); - STFI(rn(reg), r0, i0); - jit_unget_reg(reg); - } - else -# endif - STFI(r1, r0, i0); - } - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - stxr_f(rn(reg), r0, r1); - jit_unget_reg(reg); - } -} - -static void -_extr_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - stxi(BIAS(-8), _FP_REGNO, r1); -# if __WORDSIZE == 32 - stxi(BIAS(-4), _FP_REGNO, 0); -# endif - ldxi_d(r0, _FP_REGNO, BIAS(-8)); -# if __WORDSIZE == 32 - FITOD(r0, r0); -# else - FXTOD(r0, r0); -# endif -} - -static void -_truncr_d_i(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - reg = jit_get_reg(CLASS_SNG); -# if __WORDSIZE == 64 - if (!single_precision_p(r1)) { - movr_d(rn(reg), r1); - FDTOI(rn(reg), rn(reg)); - } - else -# endif - FDTOI(r1, rn(reg)); - stxi_d(BIAS(-8), _FP_REGNO, rn(reg)); - ldxi_i(r0, _FP_REGNO, BIAS(-8)); - jit_unget_reg(reg); -} - -# if __WORDSIZE == 64 -static void -_truncr_d_l(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - int32_t reg; - reg = jit_get_reg(CLASS_DBL); - FDTOX(r1, rn(reg)); - stxi_d(BIAS(-8), _FP_REGNO, rn(reg)); - ldxi_l(r0, _FP_REGNO, BIAS(-8)); - jit_unget_reg(reg); -} -# endif - -static void -_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDDFI(0, i0, 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, int32_t i0) -{ - int32_t reg; - if (s13_p(i0)) - LDDFI(r1, i0, 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_d(jit_state_t *_jit, jit_word_t i0, int32_t r0) -{ - int32_t reg; - if (s13_p(i0)) - STDFI(r0, 0, i0); - 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, int32_t i0, int32_t r0, int32_t r1) -{ - int32_t reg; - if (s13_p(i0)) - STDFI(r1, r0, i0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - stxr_d(rn(reg), r0, r1); - jit_unget_reg(reg); - } -} - -static jit_word_t -_fbr(jit_state_t *_jit, int32_t cc, - jit_word_t i0, int32_t r0,int32_t r1) -{ -# if __WORDSIZE == 64 - int32_t x0, t0, x1, t1, mask = 0; -# endif - jit_word_t w; -# if __WORDSIZE == 64 - if (!single_precision_p(r0)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - movr_d(x0, r0); - } - else - x0 = r0; - if (r0 == r1) - x1 = x0; - else if (!single_precision_p(r1)) { - mask |= 2; - t1 = jit_get_reg(CLASS_SNG); - x1 = rn(t1); - movr_d(x1, r1); - } - else - x1 = r1; - FCMPS(x0, x1); - if (mask & 1) - jit_unget_reg(t0); - if (mask & 2) - jit_unget_reg(t1); -# else - FCMPS(r0, r1); -# endif - w = _jit->pc.w; - FB(cc, (i0 - w) >> 2); - NOP(); - return (w); -} - -static jit_word_t -_fbw(jit_state_t *_jit, int32_t cc, - jit_word_t i0, int32_t r0, jit_float32_t *i1) -{ - jit_word_t w; - int32_t reg; -# if __WORDSIZE == 64 - int32_t x0, t0, mask = 0; - if (!single_precision_p(r0)) { - mask |= 1; - t0 = jit_get_reg(CLASS_SNG); - x0 = rn(t0); - movr_d(x0, r0); - } - else - x0 = r0; -# endif - reg = jit_get_reg(CLASS_SNG); - movi_f(rn(reg), i1); -# if __WORDSIZE == 64 - FCMPS(x0, rn(reg)); - if (mask & 1) - jit_unget_reg(t0); -# else - FCMPS(r0, rn(reg)); -# endif - jit_unget_reg(reg); - w = _jit->pc.w; - FB(cc, (i0 - w) >> 2); - NOP(); - return (w); -} - -static jit_word_t -_dbr(jit_state_t *_jit, int32_t cc, - jit_word_t i0, int32_t r0, int32_t r1) -{ - jit_word_t w; - FCMPD(r0, r1); - w = _jit->pc.w; - FB(cc, (i0 - w) >> 2); - NOP(); - return (w); -} - -static jit_word_t -_dbw(jit_state_t *_jit, int32_t cc, - jit_word_t i0, int32_t r0, jit_float64_t *i1) -{ - jit_word_t w; - int32_t reg; - reg = jit_get_reg(CLASS_DBL); - movi_d(rn(reg), i1); - FCMPD(r0, rn(reg)); - jit_unget_reg(reg); - w = _jit->pc.w; - FB(cc, (i0 - w) >> 2); - NOP(); - return (w); -} - -static void -_vaarg_d(jit_state_t *_jit, int32_t r0, int32_t r1) -{ - assert(_jitc->function->self.call & jit_call_varargs); - - /* Load argument. */ - ldr_d(r0, r1); - - /* Update vararg stack pointer. */ - addi(r1, r1, 8); -} -#endif diff --git a/lightening/sparc.c b/lightening/sparc.c deleted file mode 100644 index 415f21335..000000000 --- a/lightening/sparc.c +++ /dev/null @@ -1,1948 +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 _SP -# define JIT_RET _I0 -# define JIT_FRET _F0 -/* - * Copyright (C) 2013-2018 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_arg_reg_p(i) ((i) >= 0 && (i) < 6) -#if __WORDSIZE == 32 -# define jit_arg_d_reg_p(i) ((i) >= 0 && (i) < 5) -# define BIAS(n) (n) -#else -# define jit_arg_d_reg_p(i) ((i) >= 0 && (i) < 16) -# define BIAS(n) ((n) + 2047) -#endif - -/* - * Types - */ -typedef jit_pointer_t jit_va_list_t; - -/* - * Prototypes - */ -#define patch(instr, node) _patch(_jit, instr, node) -static void _patch(jit_state_t*,jit_word_t,jit_node_t*); - -#define PROTO 1 -# include "sparc-cpu.c" -# include "sparc-fpu.c" -#undef PROTO - -/* - * Initialization - */ -static const jit_register_t _rvs[] = { - { 0x00, "%g0" }, - { 0x01, "%g1" }, - { rc(gpr) | 0x02, "%g2" }, - { rc(gpr) | 0x03, "%g3" }, - { rc(gpr) | 0x04, "%g4" }, - { 0x05, "%g5" }, - { 0x06, "%g6" }, - { 0x07, "%g7" }, - { rc(arg) | rc(gpr) | 0x08, "%o0" }, - { rc(arg) | rc(gpr) | 0x09, "%o1" }, - { rc(arg) | rc(gpr) | 0x0a, "%o2" }, - { rc(arg) | rc(gpr) | 0x0b, "%o3" }, - { rc(arg) | rc(gpr) | 0x0c, "%o4" }, - { rc(arg) | rc(gpr) | 0x0d, "%o5" }, - { rc(sav) | 0x0e, "%sp" }, - { 0x0f, "%o7" }, - { rc(sav) | rc(gpr) | 0x10, "%l0" }, - { rc(sav) | rc(gpr) | 0x11, "%l1" }, - { rc(sav) | rc(gpr) | 0x12, "%l2" }, - { rc(sav) | rc(gpr) | 0x13, "%l3" }, - { rc(sav) | rc(gpr) | 0x14, "%l4" }, - { rc(sav) | rc(gpr) | 0x15, "%l5" }, - { rc(sav) | rc(gpr) | 0x16, "%l6" }, - { rc(sav) | rc(gpr) | 0x17, "%l7" }, - { 0x18, "%i0" }, - { 0x19, "%i1" }, - { 0x1a, "%i2" }, - { 0x1b, "%i3" }, - { 0x1c, "%i4" }, - { 0x1d, "%i5" }, - { rc(sav) | 0x1e, "%fp" }, - { 0x1f, "%i7" }, -# if __WORDSIZE == 32 - { rc(fpr) | 0x00, "%f0" }, - { 0x01, "%f1" }, - { rc(fpr) | 0x02, "%f2" }, - { 0x03, "%f3" }, - { rc(fpr) | 0x04, "%f4" }, - { 0x05, "%f5" }, - { rc(fpr) | 0x06, "%f6" }, - { 0x07, "%f7" }, - { rc(fpr) | 0x08, "%f8" }, - { 0x09, "%f9" }, - { rc(fpr) | 0x0a, "%f10" }, - { 0x0b, "%f11" }, - { rc(fpr) | 0x0c, "%f12" }, - { 0x0d, "%f13" }, - { rc(fpr) | 0x0e, "%f14" }, - { 0x0f, "%f15" }, -# else - { rc(fpr) | rc(dbl) | 0x3e, "%f62" }, - { rc(fpr) | rc(dbl) | 0x3c, "%f60" }, - { rc(fpr) | rc(dbl) | 0x3a, "%f58" }, - { rc(fpr) | rc(dbl) | 0x38, "%f56" }, - { rc(fpr) | rc(dbl) | 0x36, "%f54" }, - { rc(fpr) | rc(dbl) | 0x34, "%f52" }, - { rc(fpr) | rc(dbl) | 0x32, "%f50" }, - { rc(fpr) | rc(dbl) | 0x30, "%f48" }, - { rc(fpr) | rc(dbl) | 0x2e, "%f46" }, - { rc(fpr) | rc(dbl) | 0x2c, "%f44" }, - { rc(fpr) | rc(dbl) | 0x2a, "%f42" }, - { rc(fpr) | rc(dbl) | 0x28, "%f40" }, - { rc(fpr) | rc(dbl) | 0x26, "%f38" }, - { rc(fpr) | rc(dbl) | 0x24, "%f36" }, - { rc(fpr) | rc(dbl) | 0x22, "%f34" }, - { rc(fpr) | rc(dbl) | 0x20, "%f32" }, - { 0x1f, "%f31" }, - { rc(arg)|rc(fpr)|rc(sng)|0x1e, "%f30" }, - { 0x1d, "%f29" }, - { rc(arg)|rc(fpr)|rc(sng)|0x1c, "%f28" }, - { 0x1b, "%f27" }, - { rc(arg)|rc(fpr)|rc(sng)|0x1a, "%f26" }, - { 0x19, "%f25" }, - { rc(arg)|rc(fpr)|rc(sng)|0x18, "%f24" }, - { 0x17, "%f23" }, - { rc(arg)|rc(fpr)|rc(sng)|0x16, "%f22" }, - { 0x15, "%f21" }, - { rc(arg)|rc(fpr)|rc(sng)|0x14, "%f20" }, - { 0x13, "%f19" }, - { rc(arg)|rc(fpr)|rc(sng)|0x12, "%f18" }, - { 0x11, "%f17" }, - { rc(arg)|rc(fpr)|rc(sng)|0x10, "%f16" }, - { 0x0f, "%f15" }, - { rc(arg)|rc(fpr)|rc(sng)|0x0e, "%f14" }, - { 0x0d, "%f13" }, - { rc(arg)|rc(fpr)|rc(sng)|0x0c, "%f12" }, - { 0x0b, "%f11" }, - { rc(arg)|rc(fpr)|rc(sng)|0x0a, "%f10" }, - { 0x09, "%f9" }, - { rc(arg)|rc(fpr)|rc(sng)|0x08, "%f8" }, - { 0x07, "%f7" }, - { rc(arg)|rc(fpr)|rc(sng)|0x06, "%f6" }, - { 0x05, "%f5" }, - { rc(arg)|rc(fpr)|rc(sng)|0x04, "%f4" }, - { 0x03, "%f3" }, - { rc(arg)|rc(fpr)|rc(sng)|0x02, "%f2" }, - { 0x01, "%f1" }, - { rc(arg)|rc(fpr)|rc(sng)|0x00, "%f0" }, -# endif - { _NOREG, "" }, -}; - -/* - * Implementation - */ -void -jit_get_cpu(void) -{ -} - -void -_jit_init(jit_state_t *_jit) -{ - _jitc->reglen = jit_size(_rvs) - 1; -# if __WORDSIZE == 64 - jit_carry = _NOREG; -# endif -} - -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 = stack_framesize; - _jitc->function->self.argi = _jitc->function->self.argf = - _jitc->function->self.aoff = _jitc->function->self.alen = 0; - /* float conversion */ -# if __WORDSIZE == 32 - _jitc->function->self.aoff = -8; -# else - /* extra slots in case qmul is called */ - _jitc->function->self.aoff = -24; -# endif - _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) -{ - assert(_jitc->function); - switch (length) { - case 0: case 1: break; - case 2: _jitc->function->self.aoff &= -2; break; - case 3: case 4: _jitc->function->self.aoff &= -4; break; - default: _jitc->function->self.aoff &= -8; break; - } - _jitc->function->self.aoff -= length; - if (!_jitc->realize) { - jit_inc_synth_ww(allocai, _jitc->function->self.aoff, length); - jit_dec_synth(); - } - return (BIAS(_jitc->function->self.aoff)); -} - -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_negr(reg, v); - jit_andi(reg, reg, -16); - jit_ldxi_i(u, JIT_FP, _jitc->function->aoffoff); - jit_addr(u, u, reg); - jit_addr(_SP, _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); - if (JIT_RET != u) - jit_movr(JIT_RET, u); - jit_live(JIT_RET); - 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); - if (JIT_FRET != u) - jit_movr_f(JIT_FRET, u); - else - jit_live(JIT_FRET); - 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); - if (JIT_FRET != u) - jit_movr_d(JIT_FRET, u); - else - jit_live(JIT_FRET); - 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) -{ -# if __WORDSIZE == 32 - if (u->code == jit_code_arg || u->code == jit_code_arg_f) - return (jit_arg_reg_p(u->u.w)); - assert(u->code == jit_code_arg_d); - return (jit_arg_d_reg_p(u->u.w)); -# else - if (u->code == jit_code_arg) - return (jit_arg_reg_p(u->u.w)); - assert(u->code == jit_code_arg_d || u->code == jit_code_arg_f); - return (jit_arg_d_reg_p(u->u.w)); -# endif -} - -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); - if (jit_arg_reg_p(_jitc->function->self.argi)) - offset = _jitc->function->self.argi++; - else { -# if __WORDSIZE == 64 - if (jit_arg_d_reg_p(_jitc->function->self.argi)) - ++_jitc->function->self.argi; -# endif - offset = BIAS(_jitc->function->self.size); - _jitc->function->self.size += sizeof(jit_word_t); - } - 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; -# if __WORDSIZE == 64 - jit_bool_t inc; -# endif - assert(_jitc->function); -# if __WORDSIZE == 32 - if (jit_arg_reg_p(_jitc->function->self.argi)) - offset = _jitc->function->self.argi++; - else { - offset = _jitc->function->self.size; - _jitc->function->self.size += sizeof(jit_word_t); - } -# else - inc = !jit_arg_reg_p(_jitc->function->self.argi); - if (jit_arg_d_reg_p(_jitc->function->self.argi)) - offset = _jitc->function->self.argi++; - else - offset = BIAS(_jitc->function->self.size); - if (inc) - _jitc->function->self.size += sizeof(jit_word_t); -# endif - 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; -# if __WORDSIZE == 64 - jit_bool_t inc; -# endif - assert(_jitc->function); -# if __WORDSIZE == 32 - if (jit_arg_d_reg_p(_jitc->function->self.argi)) { - offset = _jitc->function->self.argi; - _jitc->function->self.argi += 2; - } - else if (jit_arg_reg_p(_jitc->function->self.argi)) { - offset = _jitc->function->self.argi++; - _jitc->function->self.size += sizeof(jit_float32_t); - } - else { - offset = _jitc->function->self.size; - _jitc->function->self.size += sizeof(jit_float64_t); - } -# else - inc = !jit_arg_reg_p(_jitc->function->self.argi); - if (jit_arg_d_reg_p(_jitc->function->self.argi)) - offset = _jitc->function->self.argi++; - else - offset = BIAS(_jitc->function->self.size); - if (inc) - _jitc->function->self.size += sizeof(jit_word_t); -# endif - 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 (jit_arg_reg_p(v->u.w)) - jit_extr_c(u, _I0 + v->u.w); - else - jit_ldxi_c(u, JIT_FP, - v->u.w + (__WORDSIZE >> 3) - sizeof(int8_t)); - 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 (jit_arg_reg_p(v->u.w)) - jit_extr_uc(u, _I0 + v->u.w); - else - jit_ldxi_uc(u, JIT_FP, - v->u.w + (__WORDSIZE >> 3) - sizeof(uint8_t)); - 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 (jit_arg_reg_p(v->u.w)) - jit_extr_s(u, _I0 + v->u.w); - else - jit_ldxi_s(u, JIT_FP, - v->u.w + (__WORDSIZE >> 3) - sizeof(int16_t)); - 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 (jit_arg_reg_p(v->u.w)) - jit_extr_us(u, _I0 + v->u.w); - else - jit_ldxi_us(u, JIT_FP, - v->u.w + (__WORDSIZE >> 3) - sizeof(uint16_t)); - 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 (jit_arg_reg_p(v->u.w)) { -# if __WORDSIZE == 64 - jit_extr_i(u, _I0 + v->u.w); -# else - jit_movr(u, _I0 + v->u.w); -# endif - } - else - jit_ldxi_i(u, JIT_FP, - v->u.w + (__WORDSIZE >> 3) - sizeof(int32_t)); - jit_dec_synth(); -} - -# if __WORDSIZE == 64 -void -_jit_getarg_ui(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 (jit_arg_reg_p(v->u.w)) - jit_extr_ui(u, _I0 + v->u.w); - else - jit_ldxi_ui(u, JIT_FP, - v->u.w + (__WORDSIZE >> 3) - sizeof(int32_t)); - jit_dec_synth(); -} - -void -_jit_getarg_l(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 (jit_arg_reg_p(v->u.w)) - jit_movr(u, _I0 + v->u.w); - else - jit_ldxi_l(u, JIT_FP, v->u.w); - jit_dec_synth(); -} -# endif - -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 (jit_arg_reg_p(v->u.w)) - jit_movr(_I0 + 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 (jit_arg_reg_p(v->u.w)) - jit_movi(_I0 + 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); - assert(_jitc->function); - jit_inc_synth_wp(getarg_f, u, v); -# if __WORDSIZE == 32 - if (jit_arg_reg_p(v->u.w)) { - jit_stxi_i(-4, JIT_FP, _I0 + v->u.w); - jit_ldxi_f(u, JIT_FP, -4); - } -# else - if (jit_arg_d_reg_p(v->u.w)) { - jit_live(_F0 - (v->u.w << 1)); /* pair of registers is live */ - jit_movr_f(u, (_F0 - (v->u.w << 1)) - 1); - } -# endif - else - jit_ldxi_f(u, JIT_FP, v->u.w + (__WORDSIZE >> 3) - - sizeof(jit_float32_t)); - 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 __WORDSIZE == 32 - if (jit_arg_reg_p(v->u.w)) { - jit_stxi_f(-4, JIT_FP, u); - jit_ldxi_i(_I0 + v->u.w, JIT_FP, -4); - } -# else - if (jit_arg_d_reg_p(v->u.w)) { - jit_live(_F0 - (v->u.w << 1)); /* pair of registers is live */ - jit_movr_f((_F0 - (v->u.w << 1)) - 1, u); - } -# endif - else - jit_stxi_f(v->u.w + (__WORDSIZE >> 3) - - sizeof(jit_float32_t), 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 __WORDSIZE == 32 - regno = jit_get_reg(jit_class_fpr); - jit_movi_f(regno, u); - if (jit_arg_reg_p(v->u.w)) { - jit_stxi_f(-4, JIT_FP, regno); - jit_ldxi_i(_I0 + v->u.w, JIT_FP, -4); - } - else - jit_stxi_f(v->u.w, JIT_FP, regno); - jit_unget_reg(regno); -# else - if (jit_arg_d_reg_p(v->u.w)) { - jit_live(_F0 - (v->u.w << 1)); /* pair of registers is live */ - jit_movi_f((_F0 - (v->u.w << 1)) - 1, u); - } - else { - regno = jit_get_reg(jit_class_fpr | jit_class_sng); - jit_movi_f(regno, u); - jit_stxi_f(v->u.w + (__WORDSIZE >> 3) - - sizeof(jit_float32_t), JIT_FP, regno); - jit_unget_reg(regno); - } -# endif - 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); - assert(_jitc->function); - jit_inc_synth_wp(getarg_d, u, v); - if (jit_arg_d_reg_p(v->u.w)) { -# if __WORDSIZE == 32 - jit_stxi(-8, JIT_FP, _I0 + v->u.w); - jit_stxi(-4, JIT_FP, _I0 + v->u.w + 1); - jit_ldxi_d(u, JIT_FP, -8); -# else - jit_movr_d(u, _F0 - (v->u.w << 1)); -# endif - } -# if __WORDSIZE == 32 - else if (jit_arg_reg_p(v->u.w)) { - jit_stxi(-8, JIT_FP, _I0 + v->u.w); - jit_ldxi_f(u, JIT_FP, -8); - jit_ldxi_f(u + 1, JIT_FP, stack_framesize); - } -# endif - else { -# if __WORDSIZE == 32 - jit_ldxi_f(u, JIT_FP, v->u.w); - jit_ldxi_f(u + 1, JIT_FP, v->u.w + 4); -# else - jit_ldxi_d(u, JIT_FP, v->u.w); -# endif - } - jit_dec_synth(); -} - -void -_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v) -{ - int32_t regno; - assert(v->code == jit_code_arg_d); - jit_inc_synth_wp(putargr_d, u, v); -# if __WORDSIZE == 32 - if (jit_arg_d_reg_p(v->u.w)) { - jit_stxi_d(-8, JIT_FP, u); - jit_ldxi(_I0 + v->u.w, JIT_FP, -8); - jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4); - } - else if (jit_arg_reg_p(v->u.w)) { - regno = jit_get_reg(jit_class_gpr); - jit_stxi_d(-8, JIT_FP, u); - jit_ldxi(_I0 + v->u.w, JIT_FP, -8); - jit_ldxi(regno, JIT_FP, -4); - jit_stxi(stack_framesize, JIT_FP, regno); - jit_unget_reg(regno); - } - else if ((v->u.w & 7) == 0) - jit_stxi_d(v->u.w, JIT_FP, u); - else { - jit_stxi_d(-8, JIT_FP, u); - regno = jit_get_reg(jit_class_gpr); - jit_ldxi(regno, JIT_FP, -8); - jit_stxi(v->u.w, JIT_FP, regno); - jit_ldxi(regno, JIT_FP, -4); - jit_stxi(v->u.w + 4, JIT_FP, regno); - jit_unget_reg(regno); - } -# else - if (jit_arg_d_reg_p(v->u.w)) - jit_movr_d(_F0 - (v->u.w << 1), u); - else - jit_stxi_d(v->u.w, JIT_FP, u); -# endif - jit_dec_synth(); -} - -void -_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v) -{ -# if __WORDSIZE == 32 - int32_t gpr; -# endif - int32_t regno; - assert(v->code == jit_code_arg_d); - jit_inc_synth_dp(putargi_d, u, v); -# if __WORDSIZE == 32 - regno = jit_get_reg(jit_class_fpr); - jit_movi_d(regno, u); - if (jit_arg_d_reg_p(v->u.w)) { - jit_stxi_d(-8, JIT_FP, regno); - jit_ldxi(_I0 + v->u.w, JIT_FP, -8); - jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4); - } - else if (jit_arg_reg_p(v->u.w)) { - gpr = jit_get_reg(jit_class_gpr); - jit_stxi_d(-8, JIT_FP, regno); - jit_ldxi(_I0 + v->u.w, JIT_FP, -8); - jit_ldxi(gpr, JIT_FP, -4); - jit_stxi(stack_framesize, JIT_FP, gpr); - jit_unget_reg(gpr); - } - else if ((v->u.w & 7) == 0) - jit_stxi_d(v->u.w, JIT_FP, regno); - else { - jit_stxi_d(-8, JIT_FP, regno); - gpr = jit_get_reg(jit_class_gpr); - jit_ldxi(gpr, JIT_FP, -8); - jit_stxi(v->u.w, JIT_FP, gpr); - jit_ldxi(gpr, JIT_FP, -4); - jit_stxi(v->u.w + 4, JIT_FP, gpr); - jit_unget_reg(gpr); - } - jit_unget_reg(regno); -# else - if (jit_arg_d_reg_p(v->u.w)) - jit_movi_d(_F0 - (v->u.w << 1), u); - else { - regno = jit_get_reg(jit_class_fpr | jit_class_dbl); - jit_movi_d(regno, u); - jit_stxi_d(v->u.w, JIT_FP, regno); - jit_unget_reg(regno); - } -# endif - jit_dec_synth(); -} - -void -_jit_pushargr(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(pushargr, u); - jit_link_prepare(); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movr(_O0 + _jitc->function->call.argi, u); - ++_jitc->function->call.argi; - } - else { -# if __WORDSIZE == 64 - if (jit_arg_d_reg_p(_jitc->function->call.argi)) - ++_jitc->function->call.argi; -# endif - jit_stxi(BIAS(_jitc->function->call.size + stack_framesize), - JIT_SP, u); - _jitc->function->call.size += sizeof(jit_word_t); - } - jit_dec_synth(); -} - -void -_jit_pushargi(jit_state_t *_jit, jit_word_t u) -{ - int32_t regno; - jit_inc_synth_w(pushargi, u); - jit_link_prepare(); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_movi(_O0 + _jitc->function->call.argi, u); - ++_jitc->function->call.argi; - } - else { -# if __WORDSIZE == 64 - if (jit_arg_d_reg_p(_jitc->function->call.argi)) - ++_jitc->function->call.argi; -# endif - regno = jit_get_reg(jit_class_gpr); - jit_movi(regno, u); - jit_stxi(BIAS(_jitc->function->call.size + stack_framesize), - JIT_SP, regno); - jit_unget_reg(regno); - _jitc->function->call.size += sizeof(jit_word_t); - } - jit_dec_synth(); -} - -void -_jit_pushargr_f(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(pushargr_f, u); - jit_link_prepare(); -# if __WORDSIZE == 32 - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_stxi_f(-8, JIT_FP, u); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); - ++_jitc->function->call.argi; - } - else { - jit_stxi_f(_jitc->function->call.size + stack_framesize, - JIT_SP, u); - _jitc->function->call.size += sizeof(jit_float32_t); - } -# else - if ((_jitc->function->call.call & jit_call_varargs) && - jit_arg_reg_p(_jitc->function->call.argi)) { - jit_stxi_f(BIAS(-8), JIT_FP, u); - jit_ldxi_i(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8)); - ++_jitc->function->call.argi; - } - else if (!(_jitc->function->call.call & jit_call_varargs) && - jit_arg_d_reg_p(_jitc->function->call.argi)) { - /* pair of registers is live */ - jit_live(_F0 - (_jitc->function->call.argi << 1)); - jit_movr_f((_F0 - (_jitc->function->call.argi << 1)) - 1, u); - if (!jit_arg_reg_p(_jitc->function->call.argi)) - _jitc->function->call.size += sizeof(jit_float64_t); - ++_jitc->function->call.argi; - } - else { - jit_stxi_f(BIAS(_jitc->function->call.size + stack_framesize + 4), - JIT_SP, u); - _jitc->function->call.size += sizeof(jit_float64_t); - } -# endif - jit_dec_synth(); -} - -void -_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) -{ - int32_t regno; - jit_inc_synth_f(pushargi_f, u); - jit_link_prepare(); -# if __WORDSIZE == 32 - regno = jit_get_reg(jit_class_fpr); - jit_movi_f(regno, u); - if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_stxi_f(-8, JIT_FP, regno); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); - _jitc->function->call.argi++; - } - else { - jit_stxi_f(_jitc->function->call.size + stack_framesize, - JIT_SP, regno); - _jitc->function->call.size += sizeof(jit_float32_t); - } - jit_unget_reg(regno); -# else - if ((_jitc->function->call.call & jit_call_varargs) && - jit_arg_reg_p(_jitc->function->call.argi)) { - regno = jit_get_reg(jit_class_fpr | jit_class_sng); - jit_movi_f(regno, u); - jit_stxi_f(BIAS(-8), JIT_FP, regno); - jit_ldxi_i(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8)); - ++_jitc->function->call.argi; - jit_unget_reg(regno); - } - else if (!(_jitc->function->call.call & jit_call_varargs) && - jit_arg_d_reg_p(_jitc->function->call.argi)) { - /* pair of registers is live */ - jit_live(_F0 - (_jitc->function->call.argi << 1)); - jit_movi_f((_F0 - (_jitc->function->call.argi << 1)) - 1, u); - if (!jit_arg_reg_p(_jitc->function->call.argi)) - _jitc->function->call.size += sizeof(jit_float64_t); - ++_jitc->function->call.argi; - } - else { - regno = jit_get_reg(jit_class_fpr | jit_class_sng); - jit_movi_f(regno, u); - jit_stxi_f(BIAS(_jitc->function->call.size + stack_framesize + 4), - JIT_SP, regno); - jit_unget_reg(regno); - _jitc->function->call.size += sizeof(jit_float64_t); - } -# endif - jit_dec_synth(); -} - -void -_jit_pushargr_d(jit_state_t *_jit, int32_t u) -{ - jit_inc_synth_w(pushargr_d, u); - jit_link_prepare(); -# if __WORDSIZE == 32 - if (jit_arg_d_reg_p(_jitc->function->call.argi)) { - jit_stxi_d(BIAS(-8), JIT_FP, u); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8)); - jit_ldxi(_O0 + _jitc->function->call.argi + 1, JIT_FP, -4); - _jitc->function->call.argi += 2; - } - else if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_stxi_f(-8, JIT_FP, u); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); - ++_jitc->function->call.argi; - jit_stxi_f(stack_framesize, JIT_SP, u + 1); - _jitc->function->call.size += sizeof(jit_float32_t); - } - else { - jit_stxi_f(_jitc->function->call.size + stack_framesize, - JIT_SP, u); - jit_stxi_f(_jitc->function->call.size + stack_framesize + 4, - JIT_SP, u + 1); - _jitc->function->call.size += sizeof(jit_float64_t); - } -# else - if ((_jitc->function->call.call & jit_call_varargs) && - jit_arg_reg_p(_jitc->function->call.argi)) { - jit_stxi_d(BIAS(-8), JIT_FP, u); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8)); - ++_jitc->function->call.argi; - } - else if (!(_jitc->function->call.call & jit_call_varargs) && - jit_arg_d_reg_p(_jitc->function->call.argi)) { - jit_movr_d(_F0 - (_jitc->function->call.argi << 1), u); - if (!jit_arg_reg_p(_jitc->function->call.argi)) - _jitc->function->call.size += sizeof(jit_float64_t); - ++_jitc->function->call.argi; - } - else { - jit_stxi_d(BIAS(_jitc->function->call.size + stack_framesize), - JIT_SP, u); - _jitc->function->call.size += sizeof(jit_float64_t); - } -# endif - jit_dec_synth(); -} - -void -_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) -{ - int32_t regno; - jit_inc_synth_d(pushargi_d, u); - jit_link_prepare(); -# if __WORDSIZE == 32 - regno = jit_get_reg(jit_class_fpr); - jit_movi_d(regno, u); - if (jit_arg_d_reg_p(_jitc->function->call.argi)) { - jit_stxi_d(BIAS(-8), JIT_FP, regno); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8)); - jit_ldxi(_O0 + _jitc->function->call.argi + 1, JIT_FP, -4); - _jitc->function->call.argi += 2; - } - else if (jit_arg_reg_p(_jitc->function->call.argi)) { - jit_stxi_f(-8, JIT_FP, regno); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); - ++_jitc->function->call.argi; - jit_stxi_f(stack_framesize, JIT_SP, u + 1); - _jitc->function->call.size += sizeof(jit_float32_t); - } - else { - jit_stxi_f(_jitc->function->call.size + stack_framesize, - JIT_SP, regno); - jit_stxi_f(_jitc->function->call.size + stack_framesize + 4, - JIT_SP, regno + 1); - _jitc->function->call.size += sizeof(jit_float64_t); - } - jit_unget_reg(regno); -# else - if ((_jitc->function->call.call & jit_call_varargs) && - jit_arg_reg_p(_jitc->function->call.argi)) { - regno = jit_get_reg(jit_class_fpr | jit_class_dbl); - jit_movi_d(regno, u); - jit_stxi_d(BIAS(-8), JIT_FP, regno); - jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8)); - ++_jitc->function->call.argi; - jit_unget_reg(regno); - } - else if (!(_jitc->function->call.call & jit_call_varargs) && - jit_arg_d_reg_p(_jitc->function->call.argi)) { - jit_movi_d(_F0 - (_jitc->function->call.argi << 1), u); - if (!jit_arg_reg_p(_jitc->function->call.argi)) - _jitc->function->call.size += sizeof(jit_float64_t); - ++_jitc->function->call.argi; - } - else { - regno = jit_get_reg(jit_class_fpr | jit_class_dbl); - jit_movi_d(regno, u); - jit_stxi_d(BIAS(_jitc->function->call.size + stack_framesize), - JIT_SP, regno); - jit_unget_reg(regno); - _jitc->function->call.size += sizeof(jit_float64_t); - } -# endif - 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|jit_class_gpr)) == - (jit_class_arg|jit_class_gpr)) { - regno -= _O0; - if (regno >= 0 && regno < node->v.w) - return (1); - } -# if __WORDSIZE == 64 - if ((spec & (jit_class_arg|jit_class_fpr)) == - (jit_class_arg|jit_class_fpr)) { - regno = _F0 - (regno >> 1); - if (regno >= 0 && regno < node->v.w) - return (1); - } -# endif - - 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 = _jitc->function->self.argi; - call->w.w = _jitc->function->self.argf; - _jitc->function->call.argi = _jitc->function->call.argf = - _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 = _jitc->function->call.argi; - node->w.w = _jitc->function->call.argf; - _jitc->function->call.argi = _jitc->function->call.argf = - _jitc->function->call.size = 0; - _jitc->prepare = 0; - 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, _O0); - 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, _O0); - 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, _O0); - 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, _O0); - jit_dec_synth(); -} - -void -_jit_retval_i(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_i, r0); -# if __WORDSIZE == 32 - if (r0 != _O0) - jit_movr(r0, _O0); -# else - jit_extr_i(r0, _O0); -# endif - jit_dec_synth(); -} - -# if __WORDSIZE == 64 -void -_jit_retval_ui(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_i, r0); - if (r0 != _O0) - jit_extr_ui(r0, _O0); - jit_dec_synth(); -} - -void -_jit_retval_l(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_i, r0); - if (r0 != _O0) - jit_movr(r0, _O0); - jit_dec_synth(); -} -# endif - -void -_jit_retval_f(jit_state_t *_jit, int32_t r0) -{ - jit_inc_synth_w(retval_f, r0); - if (r0 != JIT_FRET) - 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); - if (r0 != JIT_FRET) - 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_rf(name) \ - case jit_code_##name##i##type: \ - assert(node->flag & jit_flag_data); \ - name##_f(rn(node->u.w), \ - (jit_float32_t *)node->v.n->u.w); \ - break -#define case_rd(name) \ - case jit_code_##name##i_d: \ - assert(node->flag & jit_flag_data); \ - name##_d(rn(node->u.w), \ - (jit_float64_t *)node->v.n->u.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: - if ((node->link || (node->flag & jit_flag_use)) && - (word = _jit->pc.w & (sizeof(jit_word_t) - 1))) - nop(sizeof(jit_word_t) - word); - /* 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_rrrr(qdiv,); - case_rrrw(qdiv,); - case_rrrr(qdiv, _u); - case_rrrw(qdiv, _u); - case_rrr(rem,); - case_rrw(rem,); - case_rrr(rem, _u); - case_rrw(rem, _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(trunc, _f_i); - case_rr(trunc, _d_i); -#if __WORDSIZE == 64 - case_rr(trunc, _f_l); - case_rr(trunc, _d_l); -#endif - 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); -#if __WORDSIZE == 64 - case_rr(ld, _ui); - case_rw(ld, _ui); - case_rr(ld, _l); - case_rw(ld, _l); -#endif - 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); -#if __WORDSIZE == 64 - case_rrr(ldx, _ui); - case_rrw(ldx, _ui); - case_rrr(ldx, _l); - case_rrw(ldx, _l); -#endif - case_rr(st, _c); - case_wr(st, _c); - case_rr(st, _s); - case_wr(st, _s); - case_rr(st, _i); - case_wr(st, _i); -#if __WORDSIZE == 64 - case_rr(st, _l); - case_wr(st, _l); -#endif - case_rrr(stx, _c); - case_wrr(stx, _c); - case_rrr(stx, _s); - case_wrr(stx, _s); - case_rrr(stx, _i); - case_wrr(stx, _i); -#if __WORDSIZE == 64 - case_rrr(stx, _l); - case_wrr(stx, _l); -#endif - case_rr(hton, _us); - case_rr(hton, _ui); -#if __WORDSIZE == 64 - case_rr(hton, _ul); -#endif - case_rr(ext, _c); - case_rr(ext, _uc); - case_rr(ext, _s); - case_rr(ext, _us); -#if __WORDSIZE == 64 - case_rr(ext, _i); - case_rr(ext, _ui); -#endif - 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_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(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_brr(bms,); - case_brw(bms,); - case_brr(bmc,); - case_brw(bmc,); - case_rrr(add, _f); - case_rrf(add, _f, 32); - case_rrr(sub, _f); - case_rrf(sub, _f, 32); - case_rrf(rsb, _f, 32); - case_rrr(mul, _f); - case_rrf(mul, _f, 32); - case_rrr(div, _f); - case_rrf(div, _f, 32); - case_rr(abs, _f); - case_rr(neg, _f); - case_rr(sqrt, _f); - case_rr(ext, _f); - case_rr(ext, _d_f); - case_rrr(lt, _f); - case_rrf(lt, _f, 32); - case_rrr(le, _f); - case_rrf(le, _f, 32); - case_rrr(eq, _f); - case_rrf(eq, _f, 32); - case_rrr(ge, _f); - case_rrf(ge, _f, 32); - case_rrr(gt, _f); - case_rrf(gt, _f, 32); - case_rrr(ne, _f); - case_rrf(ne, _f, 32); - case_rrr(unlt, _f); - case_rrf(unlt, _f, 32); - case_rrr(unle, _f); - case_rrf(unle, _f, 32); - case_rrr(uneq, _f); - case_rrf(uneq, _f, 32); - case_rrr(unge, _f); - case_rrf(unge, _f, 32); - case_rrr(ungt, _f); - case_rrf(ungt, _f, 32); - case_rrr(ltgt, _f); - case_rrf(ltgt, _f, 32); - case_rrr(ord, _f); - case_rrf(ord, _f, 32); - case_rrr(unord, _f); - case_rrf(unord, _f, 32); - case_rr(ld, _f); - case_rw(ld, _f); - case_rrr(ldx, _f); - case_rrw(ldx, _f); - case_rr(st, _f); - case_wr(st, _f); - case_rrr(stx, _f); - case_wrr(stx, _f); - case_rr(mov, _f); - case jit_code_movi_f: - assert(node->flag & jit_flag_data); - movi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w); - break; - case_brr(blt, _f); - case_brf(blt, _f, 32); - case_brr(ble, _f); - case_brf(ble, _f, 32); - case_brr(beq, _f); - case_brf(beq, _f, 32); - case_brr(bge, _f); - case_brf(bge, _f, 32); - case_brr(bgt, _f); - case_brf(bgt, _f, 32); - case_brr(bne, _f); - case_brf(bne, _f, 32); - case_brr(bunlt, _f); - case_brf(bunlt, _f, 32); - case_brr(bunle, _f); - case_brf(bunle, _f, 32); - case_brr(buneq, _f); - case_brf(buneq, _f, 32); - case_brr(bunge, _f); - case_brf(bunge, _f, 32); - case_brr(bungt, _f); - case_brf(bungt, _f, 32); - case_brr(bltgt, _f); - case_brf(bltgt, _f, 32); - case_brr(bord, _f); - case_brf(bord, _f, 32); - case_brr(bunord, _f); - case_brf(bunord, _f, 32); - case_rrr(add, _d); - case_rrf(add, _d, 64); - case_rrr(sub, _d); - case_rrf(sub, _d, 64); - case_rrf(rsb, _d, 64); - case_rrr(mul, _d); - case_rrf(mul, _d, 64); - case_rrr(div, _d); - case_rrf(div, _d, 64); - case_rr(abs, _d); - case_rr(neg, _d); - case_rr(sqrt, _d); - case_rr(ext, _d); - case_rr(ext, _f_d); - case_rrr(lt, _d); - case_rrf(lt, _d, 64); - case_rrr(le, _d); - case_rrf(le, _d, 64); - case_rrr(eq, _d); - case_rrf(eq, _d, 64); - case_rrr(ge, _d); - case_rrf(ge, _d, 64); - case_rrr(gt, _d); - case_rrf(gt, _d, 64); - case_rrr(ne, _d); - case_rrf(ne, _d, 64); - case_rrr(unlt, _d); - case_rrf(unlt, _d, 64); - case_rrr(unle, _d); - case_rrf(unle, _d, 64); - case_rrr(uneq, _d); - case_rrf(uneq, _d, 64); - case_rrr(unge, _d); - case_rrf(unge, _d, 64); - case_rrr(ungt, _d); - case_rrf(ungt, _d, 64); - case_rrr(ltgt, _d); - case_rrf(ltgt, _d, 64); - case_rrr(ord, _d); - case_rrf(ord, _d, 64); - case_rrr(unord, _d); - case_rrf(unord, _d, 64); - case_rr(ld, _d); - case_rw(ld, _d); - case_rrr(ldx, _d); - case_rrw(ldx, _d); - case_rr(st, _d); - case_wr(st, _d); - case_rrr(stx, _d); - case_wrr(stx, _d); - case_rr(mov, _d); - case jit_code_movi_d: - assert(node->flag & jit_flag_data); - movi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w); - break; - case_brr(blt, _d); - case_brf(blt, _d, 64); - case_brr(ble, _d); - case_brf(ble, _d, 64); - case_brr(beq, _d); - case_brf(beq, _d, 64); - case_brr(bge, _d); - case_brf(bge, _d, 64); - case_brr(bgt, _d); - case_brf(bgt, _d, 64); - case_brr(bne, _d); - case_brf(bne, _d, 64); - case_brr(bunlt, _d); - case_brf(bunlt, _d, 64); - case_brr(bunle, _d); - case_brf(bunle, _d, 64); - case_brr(buneq, _d); - case_brf(buneq, _d, 64); - case_brr(bunge, _d); - case_brf(bunge, _d, 64); - case_brr(bungt, _d); - case_brf(bungt, _d, 64); - case_brr(bltgt, _d); - case_brf(bltgt, _d, 64); - case_brr(bord, _d); - case_brf(bord, _d, 64); - case_brr(bunord, _d); - case_brf(bunord, _d, 64); - case jit_code_jmpr: - jmpr(rn(node->u.w)); - break; - case jit_code_jmpi: - if (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); - word = calli_p(temp->u.w); - if (!(temp->flag & jit_flag_patch)) - patch(word, node); - } - else - calli(node->u.w); - break; - case jit_code_prolog: - _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_ellipsis: - case jit_code_va_push: - case jit_code_allocai: case jit_code_allocar: - case jit_code_arg: - 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: -#if __WORDSIZE == 64 - case jit_code_getarg_ui: case jit_code_getarg_l: -#endif - 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: -#if __WORDSIZE == 64 - case jit_code_retval_ui: case jit_code_retval_l: -#endif - 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(); - } -# if __WORDSIZE == 64 - if (jit_carry != _NOREG) { - switch (node->code) { - case jit_code_note: - case jit_code_addcr: case jit_code_addci: - case jit_code_addxr: case jit_code_addxi: - case jit_code_subcr: case jit_code_subci: - case jit_code_subxr: case jit_code_subxi: - break; - default: - jit_unget_reg(jit_carry); - jit_carry = _NOREG; - break; - } - } -# endif - jit_regarg_clr(node, value); -# if __WORDSIZE == 64 - if (jit_carry == _NOREG) - assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); - else { - assert(jit_regset_scan1(&_jitc->regarg, 0) == jit_carry); - assert(jit_regset_scan1(&_jitc->regarg, jit_carry + 1) == ULONG_MAX); - } - assert(_jitc->synth == 0); -# else - assert(_jitc->regarg == 0 && _jitc->synth == 0); -# endif - 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_rf -#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 "sparc-cpu.c" -# include ", 2018sparc-fpu.c" -#undef CODE - -void -jit_flush(void *fptr, void *tptr) -{ -} - -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)); - memset(_jitc->patches.ptr + _jitc->patches.length, 0, - 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/sparc.h b/lightening/sparc.h deleted file mode 100644 index f74f5ff30..000000000 --- a/lightening/sparc.h +++ /dev/null @@ -1,102 +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_sparc_h -#define _jit_sparc_h - -#define JIT_HASH_CONSTS 1 -#define JIT_NUM_OPERANDS 3 - -/* - * Types - */ -#define JIT_FP _FP -typedef enum { -#define jit_r(i) (_G2 + (i)) -#define jit_r_num() 3 -#define jit_v(i) (_L0 + (i)) -#define jit_v_num() 8 -#if __WORDSIZE == 32 -# define jit_f(i) (_F0 + ((i) << 1)) -# define jit_f_num() 8 -#else -# define jit_f(i) (_F32 - (i)) -# define jit_f_num() 16 -#endif -#define JIT_R0 _G2 -#define JIT_R1 _G3 -#define JIT_R2 _G4 -#define JIT_V0 _L0 -#define JIT_V1 _L1 -#define JIT_V2 _L2 -#define JIT_V3 _L3 -#define JIT_V4 _L4 -#define JIT_V5 _L5 -#define JIT_V6 _L6 -#define JIT_V7 _L7 - _G0, _G1, _G2, _G3, _G4, _G5, _G6, _G7, - _O0, _O1, _O2, _O3, _O4, _O5, _SP, _O7, - _L0, _L1, _L2, _L3, _L4, _L5, _L6, _L7, - _I0, _I1, _I2, _I3, _I4, _I5, _FP, _I7, -#if __WORDSIZE == 32 -# define JIT_F0 _F0 -# define JIT_F1 _F2 -# define JIT_F2 _F4 -# define JIT_F3 _F6 -# define JIT_F4 _F8 -# define JIT_F5 _F10 -# define JIT_F6 _F12 -# define JIT_F7 _F14 - _F0, _F1, _F2, _F3, _F4, _F5, _F6, _F7, - _F8, _F9, _F10, _F11, _F12, _F13, _F14, _F15, -#else - /* All single precision operations have a high cost due to being - * stored on registers only encodable as double precision. - * The cost is due to needing to move values to a register with - * value <= 31. - * This is a limitation due to using fixed named registers in - * lightning. */ -# define JIT_F0 _F32 -# define JIT_F1 _F34 -# define JIT_F2 _F36 -# define JIT_F3 _F38 -# define JIT_F4 _F40 -# define JIT_F5 _F42 -# define JIT_F6 _F44 -# define JIT_F7 _F46 -# define JIT_F8 _F48 -# define JIT_F9 _F50 -# define JIT_F10 _F52 -# define JIT_F11 _F54 -# define JIT_F12 _F56 -# define JIT_F13 _F58 -# define JIT_F14 _F60 -# define JIT_F15 _F62 - _F62, _F60, _F58, _F56, _F54, _F52, _F50, _F48, - _F46, _F44, _F42, _F40, _F38, _F36, _F34, _F32, - _F31, _F30, _F29, _F28, _F27, _F26, _F25, _F24, - _F23, _F22, _F21, _F20, _F19, _F18, _F17, _F16, - _F15, _F14, _F13, _F12, _F11, _F10, _F9, _F8, - _F7, _F6, _F5, _F4, _F3, _F2, _F1, _F0, -#endif -#define JIT_NOREG _NOREG - _NOREG, -} jit_reg_t; - -#endif /* _jit_sparc_h */