[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 04/05: Remove Sparc support
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 04/05: Remove Sparc support |
|
Date: |
Wed, 8 May 2019 15:49:44 -0400 (EDT) |
wingo pushed a commit to branch master
in repository guile.
commit 570f361c6c8308ddc574d6308b50263175cae59e
Author: Andy Wingo <address@hidden>
Date: Wed May 8 21:41:46 2019 +0200
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(-)
diff --git a/lightening.h b/lightening.h
index ae32737..c316348 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 8c9197e..0973d8a 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 81f92ce..0000000
--- 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 3305b4d..0000000
--- 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 415f213..0000000
--- 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, "<none>" },
-};
-
-/*
- * 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 f74f5ff..0000000
--- 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 */