forked from GitHub/gf-core
add the source code for GNU lightning in the source directory for the C runtime
This commit is contained in:
kr.angelov
647
src/runtime/c/pgf/lightning/ppc/asm.h
Normal file
647
src/runtime/c/pgf/lightning/ppc/asm.h
Normal file
@@ -0,0 +1,647 @@
|
||||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler for the PowerPC
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 1999, 2000, 2001, 2002 Ian Piumarta
|
||||
*
|
||||
* 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 2.1, 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.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
#ifndef __lightning_asm_h
|
||||
#define __lightning_asm_h
|
||||
|
||||
/* <imm> = [0-9]+ | (.+) -> add i, one parameter (imm)
|
||||
* <reg> = r<imm> -> add r, one parameter (imm)
|
||||
* <mem> = <imm>(<reg>) -> add m, two parameters (imm,reg)
|
||||
* <idx> = <reg>(<reg>) -> add x, two parameters (reg,reg)
|
||||
*
|
||||
* `x' operands have two forms. For example `stwu source, rega(regb)'
|
||||
* could be written as either
|
||||
* STWUrx(source, rega, regb)
|
||||
* or
|
||||
* STWUXrrr(source, rega, regb)
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*** a brief NOTE about halfwords and "shifted" operands
|
||||
*
|
||||
* LOGICAL insns require UNSIGNED args in 0..65535, whether or not shifted
|
||||
*
|
||||
* ARITHMETIC insns require SIGNED args in -32768..32767, even when shifted
|
||||
*
|
||||
* as a special case: "lis/addis" also accepts UNSIGNED arguments in
|
||||
* 0..65535 since it is often used immediately before "ori" to load a 32-bit
|
||||
* constant (this is consistent with the GNU rs/6000 and PowerPC assemblers)
|
||||
*
|
||||
* thus: lis rD, expression@hi
|
||||
* ori rD, rD, expression@lo ; load 32-bit constant
|
||||
*/
|
||||
|
||||
typedef unsigned int jit_insn;
|
||||
|
||||
#ifndef LIGHTNING_DEBUG
|
||||
#define _cr0 0
|
||||
#define _cr1 1
|
||||
#define _cr2 2
|
||||
#define _cr3 3
|
||||
#define _cr4 4
|
||||
#define _cr5 5
|
||||
#define _cr6 6
|
||||
#define _cr7 7
|
||||
|
||||
#define _lt 0
|
||||
#define _gt 1
|
||||
#define _eq 2
|
||||
#define _so 3
|
||||
#define _un 3
|
||||
|
||||
#define _d16(D) (_ck_d(16,(_jit_UL(D)-_jit_UL(_jit.x.pc))) & ~3)
|
||||
#define _d26(D) (_ck_d(26,(_jit_UL(D)-_jit_UL(_jit.x.pc))) & ~3)
|
||||
|
||||
/* primitive instruction forms [1, Section A.4] */
|
||||
|
||||
#define _FB( OP, BD,AA,LK ) (_jit_I_noinc((_u6(OP)<<26)| _d26(BD)| (_u1(AA)<<1)|_u1(LK)), _jit.x.pc++, 0)
|
||||
#define _FBA( OP, BD,AA,LK ) _jit_I((_u6(OP)<<26)| (_u26(BD)&~3)| (_u1(AA)<<1)|_u1(LK))
|
||||
#define _BB( OP,BO,BI, BD,AA,LK ) (_jit_I_noinc((_u6(OP)<<26)|(_u5(BO)<<21)|(_u5(BI)<<16)| _d16(BD)| (_u1(AA)<<1)|_u1(LK)), _jit.x.pc++, 0)
|
||||
#define _D( OP,RD,RA, DD ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _s16(DD) )
|
||||
#define _Du( OP,RD,RA, DD ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _u16(DD) )
|
||||
#define _Ds( OP,RD,RA, DD ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _su16(DD) )
|
||||
#define _X( OP,RD,RA,RB, XO,RC ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)| (_u10(XO)<<1)|_u1(RC))
|
||||
#define _XL( OP,BO,BI, XO,LK ) _jit_I((_u6(OP)<<26)|(_u5(BO)<<21)|(_u5(BI)<<16)|( _u5(00)<<11)| (_u10(XO)<<1)|_u1(LK))
|
||||
#define _XFX( OP,RD, SR,XO ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)| (_u10(SR)<<11)| (_u10(XO)<<1)|_u1(00))
|
||||
#define _XO( OP,RD,RA,RB,OE,XO,RC ) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)|(_u1(OE)<<10)|( _u9(XO)<<1)|_u1(RC))
|
||||
#define _M( OP,RS,RA,SH,MB,ME,RC ) _jit_I((_u6(OP)<<26)|(_u5(RS)<<21)|(_u5(RA)<<16)|( _u5(SH)<<11)|(_u5(MB)<< 6)|( _u5(ME)<<1)|_u1(RC))
|
||||
|
||||
|
||||
/* special purpose registers (form XFX) [1, Section 8.2, page 8-138] */
|
||||
|
||||
#define SPR_LR ((8<<5)|(0))
|
||||
|
||||
/* +++ intrinsic instructions */
|
||||
|
||||
#define ADDrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 0)
|
||||
#define ADD_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 1)
|
||||
#define ADDCrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 10, 0)
|
||||
#define ADDC_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 10, 1)
|
||||
#define ADDErrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 138, 0)
|
||||
#define ADDE_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 138, 1)
|
||||
#define ADDOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 0)
|
||||
#define ADDO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 1)
|
||||
#define ADDIrri(RD, RA, IMM) _D (14, RD, RA, IMM)
|
||||
#define ADDICrri(RD, RA, IMM) _D (12, RD, RA, IMM)
|
||||
#define ADDIC_rri(RD, RA, IMM) _D (13, RD, RA, IMM)
|
||||
#define ADDISrri(RD, RA, IMM) _Ds (15, RD, RA, IMM)
|
||||
|
||||
#define ANDrrr(RA, RS, RB) _X (31, RS, RA, RB, 28, 0)
|
||||
#define AND_rrr(RA, RS, RB) _X (31, RS, RA, RB, 28, 1)
|
||||
#define ANDCrrr(RA, RS, RB) _X (31, RS, RA, RB, 60, 0)
|
||||
#define ANDC_rrr(RA, RS, RB) _X (31, RS, RA, RB, 60, 1)
|
||||
#define ANDI_rri(RA, RS, IMM) _Du (28, RS, RA, IMM)
|
||||
#define ANDIS_rri(RA, RS, IMM) _Du (29, RS, RA, IMM)
|
||||
|
||||
#define Bi(BD) _FB (18, BD, 0, 0)
|
||||
#define BAi(BD) _FBA (18, BD, 1, 0)
|
||||
#define BLi(BD) _FB (18, BD, 0, 1)
|
||||
#define BLAi(BD) _FBA (18, BD, 1, 1)
|
||||
|
||||
#define BCiii(BO,BI,BD) _BB (16, BO, BI, BD, 0, 0)
|
||||
#define BCAiii(BO,BI,BD) _BB (16, BO, BI, BD, 1, 0)
|
||||
#define BCLiii(BO,BI,BD) _BB (16, BO, BI, BD, 0, 1)
|
||||
#define BCLAiii(BO,BI,BD) _BB (16, BO, BI, BD, 1, 1)
|
||||
|
||||
#define BCCTRii(BO,BI) _XL (19, BO, BI, 528, 0)
|
||||
#define BCCTRLii(BO,BI) _XL (19, BO, BI, 528, 1)
|
||||
|
||||
#define BCLRii(BO,BI) _XL (19, BO, BI, 16, 0)
|
||||
#define BCLRLii(BO,BI) _XL (19, BO, BI, 16, 1)
|
||||
|
||||
#define CMPiirr(CR, LL, RA, RB) _X (31, ((CR)<<2)|(LL), RA, RB, 0, 0)
|
||||
#define CMPIiiri(CR, LL, RA, IMM) _D (11, ((CR)<<2)|(LL), RA, IMM)
|
||||
|
||||
#define CMPLiirr(CR, LL, RA, RB) _X (31, ((CR)<<2)|(LL), RA, RB, 32, 0)
|
||||
#define CMPLIiiri(CR, LL, RA, IMM) _D (10, ((CR)<<2)|(LL), RA, IMM)
|
||||
|
||||
#define CRANDiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 257, 0)
|
||||
#define CRANDCiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 129, 0)
|
||||
#define CREQViii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 289, 0)
|
||||
#define CRNANDiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 225, 0)
|
||||
#define CRNORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 33, 0)
|
||||
#define CRORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 449, 0)
|
||||
#define CRORCiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 417, 0)
|
||||
#define CRXORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 193, 0)
|
||||
|
||||
#define DCBSTrr(RA,RB) _X (31, 00, RA, RB, 54, 0)
|
||||
|
||||
#define DIVWrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 491, 0)
|
||||
#define DIVW_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 491, 1)
|
||||
#define DIVWOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 491, 0)
|
||||
#define DIVWO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 491, 1)
|
||||
|
||||
#define DIVWUrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 459, 0)
|
||||
#define DIVWU_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 459, 1)
|
||||
#define DIVWUOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 459, 0)
|
||||
#define DIVWUO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 459, 1)
|
||||
|
||||
#define EQVrrr(Ra,RS,RB) _X (31, RS, RA, RB, 284, 0)
|
||||
#define EQV_rrr(Ra,RS,RB) _X (31, RS, RA, RB, 284, 1)
|
||||
|
||||
#define EXTSBrr(RA,RS) _X (31, RS, RA, 0, 954, 0)
|
||||
#define EXTSB_rr(RA,RS) _X (31, RS, RA, 0, 954, 1)
|
||||
|
||||
#define EXTSHrr(RA,RS) _X (31, RS, RA, 0, 922, 0)
|
||||
#define EXTSH_rr(RA,RS) _X (31, RS, RA, 0, 922, 1)
|
||||
|
||||
#define ICBIrr(RA,RB) _X (31, 00, RA, RB, 982, 0)
|
||||
|
||||
#define ISYNC() _X (19, 00, 00, 00, 150, 0)
|
||||
|
||||
#define LBZrm(RD,ID,RA) _D (34, RD, RA, ID)
|
||||
#define LBZUrm(RD,ID,RA) _D (35, RD, RA, ID)
|
||||
#define LBZUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 119, 0)
|
||||
#define LBZXrrr(RD,RA,RB) _X (31, RD, RA, RB, 87, 0)
|
||||
|
||||
#define LHArm(RD,ID,RA) _D (42, RD, RA, ID)
|
||||
#define LHAUrm(RD,ID,RA) _D (43, RD, RA, ID)
|
||||
#define LHAUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 375, 0)
|
||||
#define LHAXrrr(RD,RA,RB) _X (31, RD, RA, RB, 343, 0)
|
||||
#define LHBRXrrr(RD,RA,RB) _X (31, RD, RA, RB, 790, 0)
|
||||
|
||||
#define LHZrm(RD,ID,RA) _D (40, RD, RA, ID)
|
||||
#define LHZUrm(RD,ID,RA) _D (41, RD, RA, ID)
|
||||
#define LHZUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 311, 0)
|
||||
#define LHZXrrr(RD,RA,RB) _X (31, RD, RA, RB, 279, 0)
|
||||
|
||||
#define LMWrm(RD,ID,RA) _D (46, RD, RA, ID)
|
||||
|
||||
#define LWBRXrrr(RD,RA,RB) _X (31, RD, RA, RB, 534, 0)
|
||||
|
||||
#define LWZrm(RD, DISP, RA) _D (32, RD, RA, DISP)
|
||||
#define LWZUrm(RD, DISP, RA) _D (33, RD, RA, DISP)
|
||||
#define LWZUXrrr(RD, RA, RB) _X (31, RD, RA, RB, 56, 0)
|
||||
#define LWZXrrr(RD, RA, RB) _X (31, RD, RA, RB, 23, 0)
|
||||
|
||||
#define MCRFii(CD,CS) _X (19, ((CD)<<2), ((CS)<<2), 0, 0, 0)
|
||||
|
||||
#define MFCRr(RD) _X (31, RD, 0, 0, 19, 0)
|
||||
#define MCRXRi(RD) _XFX (31, (RD)<<2, 0, 512)
|
||||
|
||||
#define MFSPRri(RD, SPR) _XFX (31, RD, (SPR)<<5, 339)
|
||||
#define MTSPRir(SPR, RS) _XFX (31, RS, (SPR)<<5, 467)
|
||||
|
||||
#define MULHWrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 75, 0)
|
||||
#define MULHW_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 75, 1)
|
||||
#define MULHWUrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 11, 0)
|
||||
#define MULHWU_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 11, 1)
|
||||
|
||||
#define MULLIrri(RD,RA,IM) _D (07, RD, RA, IM)
|
||||
|
||||
#define MULLWrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 235, 0)
|
||||
#define MULLW_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 235, 1)
|
||||
#define MULLWOrrr(RD,RA,RB) _XO (31, RD, RA, RB, 1, 235, 0)
|
||||
#define MULLWO_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 1, 235, 1)
|
||||
|
||||
#define NANDrrr(RA,RS,RB) _X (31, RS, RA, RB, 476, 0)
|
||||
#define NAND_rrr(RA,RS,RB) _X (31, RS, RA, RB, 476, 1)
|
||||
|
||||
#define NEGrr(RD,RA) _XO (31, RD, RA, 0, 0, 104, 0)
|
||||
#define NEG_rr(RD,RA) _XO (31, RD, RA, 0, 0, 104, 1)
|
||||
#define NEGOrr(RD,RA) _XO (31, RD, RA, 0, 1, 104, 0)
|
||||
#define NEGO_rr(RD,RA) _XO (31, RD, RA, 0, 1, 104, 1)
|
||||
|
||||
#define NORrrr(RA,RS,RB) _X (31, RS, RA, RB, 124, 0)
|
||||
#define NOR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 124, 1)
|
||||
|
||||
#define ORrrr(RA,RS,RB) _X (31, RS, RA, RB, 444, 0)
|
||||
#define OR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 444, 1)
|
||||
#define ORCrrr(RA,RS,RB) _X (31, RS, RA, RB, 412, 0)
|
||||
#define ORC_rrr(RA,RS,RB) _X (31, RS, RA, RB, 412, 1)
|
||||
#define ORIrri(RA,RS,IM) _Du (24, RS, RA, IM)
|
||||
#define ORISrri(RA,RS,IM) _Du (25, RS, RA, IM)
|
||||
|
||||
#define RLWIMIrriii(RA,RS,SH,MB,ME) _M (20, RS, RA, SH, MB, ME, 0)
|
||||
#define RLWIMI_rriii(RA,RS,SH,MB,ME) _M (20, RS, RA, SH, MB, ME, 1)
|
||||
|
||||
#define RLWINMrriii(RA,RS,SH,MB,ME) _M (21, RS, RA, SH, MB, ME, 0)
|
||||
#define RLWINM_rriii(RA,RS,SH,MB,ME) _M (21, RS, RA, SH, MB, ME, 1)
|
||||
|
||||
#define RLWNMrrrii(RA,RS,RB,MB,ME) _M (23, RS, RA, RB, MB, ME, 0)
|
||||
#define RLWNM_rrrii(RA,RS,RB,MB,ME) _M (23, RS, RA, RB, MB, ME, 1)
|
||||
|
||||
#define SLWrrr(RA,RS,RB) _X (31, RS, RA, RB, 24, 0)
|
||||
#define SLW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 24, 1)
|
||||
|
||||
#define SRAWrrr(RA,RS,RB) _X (31, RS, RA, RB, 792, 0)
|
||||
#define SRAW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 792, 1)
|
||||
|
||||
#define SRAWIrri(RD, RS, SH) _X (31, RS, RD, SH, 824, 0)
|
||||
#define SRAWI_rri(RD, RS, SH) _X (31, RS, RD, SH, 824, 1)
|
||||
|
||||
#define SRWrrr(RA,RS,RB) _X (31, RS, RA, RB, 536, 0)
|
||||
#define SRW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 536, 1)
|
||||
|
||||
#define STBrm(RS,ID,RA) _D (38, RS, RA, ID)
|
||||
#define STBUrm(RS,ID,RA) _D (39, RS, RA, ID)
|
||||
#define STBUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 247, 0)
|
||||
#define STBXrrr(RS,RA,RB) _X (31, RS, RA, RB, 215, 0)
|
||||
|
||||
#define STHrm(RS,ID,RA) _D (44, RS, RA, ID)
|
||||
#define STHUrm(RS,ID,RA) _D (45, RS, RA, ID)
|
||||
#define STHBRXrrr(RS,RA,RB) _X (31, RS, RA, RB, 918, 0)
|
||||
#define STHUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 439, 0)
|
||||
#define STHXrrr(RS,RA,RB) _X (31, RS, RA, RB, 407, 0)
|
||||
|
||||
#define STMWrm(RS,ID,RA) _D (47, RS, RA, ID)
|
||||
|
||||
#define STWrm(RS,ID,RA) _D (36, RS, RA, ID)
|
||||
#define STWBRXrrr(RS,RA,RB) _X (31, RS, RA, RB, 662, 0)
|
||||
#define STWCXrrr(RS,RA,RB) _X (31, RS, RA, RB, 150, 0)
|
||||
#define STWCX_rrr(RS,RA,RB) _X (31, RS, RA, RB, 150, 1)
|
||||
#define STWUrm(RS,ID,RA) _D (37, RS, RA, ID)
|
||||
#define STWUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 183, 0)
|
||||
#define STWXrrr(RS,RA,RB) _X (31, RS, RA, RB, 151, 0)
|
||||
|
||||
#define SUBFrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 0)
|
||||
#define SUBF_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 1)
|
||||
#define SUBFrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 0)
|
||||
#define SUBF_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 1)
|
||||
#define SUBFErrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 136, 0)
|
||||
#define SUBFE_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 136, 1)
|
||||
#define SUBFCrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 8, 0)
|
||||
#define SUBFC_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 8, 1)
|
||||
#define SUBFCOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 8, 0)
|
||||
#define SUBFCO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 8, 1)
|
||||
#define SUBFICrri(RD, RA, IMM) _D (8, RD, RA, IMM)
|
||||
|
||||
#define ADDrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 0)
|
||||
#define ADDOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 0)
|
||||
#define ADDIrri(RD, RA, IMM) _D (14, RD, RA, IMM)
|
||||
#define ADDISrri(RD, RA, IMM) _Ds (15, RD, RA, IMM)
|
||||
|
||||
#define SYNC() _X (31, 00, 00, 00, 598, 0)
|
||||
|
||||
#define TWirr(TO,RA,RB) _X (31, TO, RA, RB, 4, 0)
|
||||
#define TWIiri(TO,RA,IM) _D (03, TO, RA, IM)
|
||||
|
||||
#define XORrrr(RA,RS,RB) _X (31, RS, RA, RB, 316, 0)
|
||||
#define XOR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 316, 1)
|
||||
#define XORIrri(RA,RS,IM) _Du (26, RS, RA, IM)
|
||||
#define XORISrri(RA,RS,IM) _Du (27, RS, RA, IM)
|
||||
|
||||
/* simplified mnemonics [1, Appendix F] */
|
||||
|
||||
#define MOVEIri2(R,H,L) (LISri(R,H), (L ? ORIrri(R,R,L) : 0))
|
||||
#define MOVEIri(R,I) (_siP(16,I) ? LIri(R,I) : \
|
||||
MOVEIri2(R, _HI(I), _LO(I)) )
|
||||
|
||||
#define SUBIrri(RD,RA,IM) ADDIrri(RD,RA,-_LO((IM))) /* [1, Section F.2.1] */
|
||||
#define SUBISrri(RD,RA,IM) ADDISrri(RD,RA,-_LO((IM)))
|
||||
#define SUBICrri(RD,RA,IM) ADDICrri(RD,RA,-_LO((IM)))
|
||||
#define SUBIC_rri(RD,RA,IM) ADDIC_rri(RD,RA,-_LO((IM)))
|
||||
|
||||
#define SUBrrr(RD,RA,RB) SUBFrrr(RD,RB,RA) /* [1, Section F.2.2] */
|
||||
#define SUBOrrr(RD,RA,RB) SUBFOrrr(RD,RB,RA)
|
||||
#define SUB_rrr(RD,RA,RB) SUBF_rrr(RD,RB,RA)
|
||||
#define SUBCrrr(RD,RA,RB) SUBFCrrr(RD,RB,RA)
|
||||
#define SUBCOrrr(RD,RA,RB) SUBFCOrrr(RD,RB,RA)
|
||||
#define SUBC_rrr(RD,RA,RB) SUBFC_rrr(RD,RB,RA)
|
||||
#define SUBErrr(RD,RA,RB) SUBFErrr(RD,RB,RA)
|
||||
#define SUBE_rrr(RD,RA,RB) SUBFE_rrr(RD,RB,RA)
|
||||
|
||||
#define CMPWIiri(C,RA,IM) CMPIiiri(C,0,RA,IM) /* [1, Table F-2] */
|
||||
#define CMPWirr(C,RA,RB) CMPiirr(C,0,RA,RB)
|
||||
#define CMPLWIiri(C,RA,IM) CMPLIiiri(C,0,RA,IM)
|
||||
#define CMPLWirr(C,RA,RB) CMPLiirr(C,0,RA,RB)
|
||||
|
||||
#define CMPWIri(RA,IM) CMPWIiri(0,RA,IM) /* with implicit _cr0 */
|
||||
#define CMPWrr(RA,RB) CMPWirr(0,RA,RB)
|
||||
#define CMPLWIri(RA,IM) CMPLWIiri(0,RA,IM)
|
||||
#define CMPLWrr(RA,RB) CMPLWirr(0,RA,RB)
|
||||
|
||||
#define EXTLWIrrii(RA,RS,N,B) RLWINMrriii(RA, RS, B, 0, (N)-1) /* [1, Table F-3] */
|
||||
#define EXTRWIrrii(RA,RS,N,B) RLWINMrriii(RA, RS, (B)+(N), 32-(N), 31)
|
||||
#define INSLWIrrii(RA,RS,N,B) RLWIMIrriii(RA, RS, 32-(B), B, (B)+(N)-1)
|
||||
#define INSRWIrrii(RA,RS,N,B) RLWIMIrriii(RA, RS, 32-((B)+(N)), B, (B)+(N)-1)
|
||||
#define ROTLWIrri(RA,RS,N) RLWINMrriii(RA, RS, N, 0, 31)
|
||||
#define ROTRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 32-(N), 0, 31)
|
||||
#define ROTLWrrr(RA,RS,RB) RLWNMrrrii( RA, RS, RB, 0, 31)
|
||||
#define SLWIrri(RA,RS,N) RLWINMrriii(RA, RS, N, 0, 31-(N))
|
||||
#define SRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 32-(N), N, 31)
|
||||
#define CLRLWIrri(RA,RS,N) RLWINMrriii(RA, RS, 0, N, 31)
|
||||
#define CLRRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 0, 0, 31-(N))
|
||||
#define CLRLSLWIrrii(RA,RS,B,N) RLWINMrriii(RA, RS, N, (B)-(N), 31-(N))
|
||||
|
||||
|
||||
/* 9 below inverts the branch condition and the branch prediction.
|
||||
* This has an incestuous knowledge of JIT_AUX */
|
||||
#define BC_EXT(A, C, D) (_siP(16, _jit_UL(D)-_jit_UL(_jit.x.pc)) \
|
||||
? BCiii((A), (C), (D)) \
|
||||
: (BCiii((A)^9, (C), _jit.x.pc+5), \
|
||||
LISri(JIT_AUX,_HI(D)), \
|
||||
ORIrri(JIT_AUX,JIT_AUX,_LO(D)), \
|
||||
MTLRr(JIT_AUX), BLR() ))
|
||||
|
||||
#define B_EXT(D) (_siP(16, _jit_UL(D)-_jit_UL(_jit.x.pc)) \
|
||||
? Bi((D)) \
|
||||
: (LISri(JIT_AUX,_HI(D)), \
|
||||
ORIrri(JIT_AUX,JIT_AUX,_LO(D)), \
|
||||
MTLRr(JIT_AUX), BLR()) )
|
||||
|
||||
#define BTii(C,D) BC_EXT(12, C, D) /* [1, Table F-5] */
|
||||
#define BFii(C,D) BC_EXT( 4, C, D)
|
||||
#define BDNZi(D) BCiii(16, 0, D)
|
||||
#define BDNZTii(C,D) BC_EXT( 8, C, D)
|
||||
#define BDNZFii(C,D) BC_EXT( 0, C, D)
|
||||
#define BDZi(D) BCiii(18, 0, D)
|
||||
#define BDZTii(C,D) BC_EXT(10, C, D)
|
||||
#define BDZFii(C,D) BC_EXT( 2, C, D)
|
||||
|
||||
#define BCTR() BCCTRii(20, 0) /* [1, Table F-6] */
|
||||
#define BCTRL() BCCTRLii(20, 0)
|
||||
|
||||
#define BLR() BCLRii(20, 0) /* [1, Table F-6] */
|
||||
#define BLRL() BCLRLii(20, 0)
|
||||
|
||||
|
||||
#define BLTLRi(CR) BCLRii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLELRi(CR) BCLRii( 4, ((CR)<<2)+1)
|
||||
#define BEQLRi(CR) BCLRii(12, ((CR)<<2)+2)
|
||||
#define BGELRi(CR) BCLRii( 4, ((CR)<<2)+0)
|
||||
#define BGTLRi(CR) BCLRii(12, ((CR)<<2)+1)
|
||||
#define BNLLRi(CR) BCLRii( 4, ((CR)<<2)+0)
|
||||
#define BNELRi(CR) BCLRii( 4, ((CR)<<2)+2)
|
||||
#define BNGLRi(CR) BCLRii( 4, ((CR)<<2)+1)
|
||||
#define BSOLRi(CR) BCLRii(12, ((CR)<<2)+3)
|
||||
#define BNSLRi(CR) BCLRii( 4, ((CR)<<2)+3)
|
||||
#define BUNLRi(CR) BCLRii(12, ((CR)<<2)+3)
|
||||
#define BNULRi(CR) BCLRii( 4, ((CR)<<2)+3)
|
||||
|
||||
#define BLTLRLi(CR) BCLRLii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLELRLi(CR) BCLRLii( 4, ((CR)<<2)+1)
|
||||
#define BEQLRLi(CR) BCLRLii(12, ((CR)<<2)+2)
|
||||
#define BGELRLi(CR) BCLRLii( 4, ((CR)<<2)+0)
|
||||
#define BGTLRLi(CR) BCLRLii(12, ((CR)<<2)+1)
|
||||
#define BNLLRLi(CR) BCLRLii( 4, ((CR)<<2)+0)
|
||||
#define BNELRLi(CR) BCLRLii( 4, ((CR)<<2)+2)
|
||||
#define BNGLRLi(CR) BCLRLii( 4, ((CR)<<2)+1)
|
||||
#define BSOLRLi(CR) BCLRLii(12, ((CR)<<2)+3)
|
||||
#define BNSLRLi(CR) BCLRLii( 4, ((CR)<<2)+3)
|
||||
#define BUNLRLi(CR) BCLRLii(12, ((CR)<<2)+3)
|
||||
#define BNULRLi(CR) BCLRLii( 4, ((CR)<<2)+3)
|
||||
|
||||
#define BLTCTRi(CR) BCCTRii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLECTRi(CR) BCCTRii( 4, ((CR)<<2)+1)
|
||||
#define BEQCTRi(CR) BCCTRii(12, ((CR)<<2)+2)
|
||||
#define BGECTRi(CR) BCCTRii( 4, ((CR)<<2)+0)
|
||||
#define BGTCTRi(CR) BCCTRii(12, ((CR)<<2)+1)
|
||||
#define BNLCTRi(CR) BCCTRii( 4, ((CR)<<2)+0)
|
||||
#define BNECTRi(CR) BCCTRii( 4, ((CR)<<2)+2)
|
||||
#define BNGCTRi(CR) BCCTRii( 4, ((CR)<<2)+1)
|
||||
#define BSOCTRi(CR) BCCTRii(12, ((CR)<<2)+3)
|
||||
#define BNSCTRi(CR) BCCTRii( 4, ((CR)<<2)+3)
|
||||
#define BUNCTRi(CR) BCCTRii(12, ((CR)<<2)+3)
|
||||
#define BNUCTRi(CR) BCCTRii( 4, ((CR)<<2)+3)
|
||||
|
||||
#define BLTCTRLi(CR) BCCTRLii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+1)
|
||||
#define BEQCTRLi(CR) BCCTRLii(12, ((CR)<<2)+2)
|
||||
#define BGECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+0)
|
||||
#define BGTCTRLi(CR) BCCTRLii(12, ((CR)<<2)+1)
|
||||
#define BNLCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+0)
|
||||
#define BNECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+2)
|
||||
#define BNGCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+1)
|
||||
#define BSOCTRLi(CR) BCCTRLii(12, ((CR)<<2)+3)
|
||||
#define BNSCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+3)
|
||||
#define BUNCTRLi(CR) BCCTRLii(12, ((CR)<<2)+3)
|
||||
#define BNUCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+3)
|
||||
|
||||
|
||||
#define BLTLR() BLTLRi(0) /* with implicit _cr0 */
|
||||
#define BLELR() BLELRi(0)
|
||||
#define BEQLR() BEQLRi(0)
|
||||
#define BGELR() BGELRi(0)
|
||||
#define BGTLR() BGTLRi(0)
|
||||
#define BNLLR() BNLLRi(0)
|
||||
#define BNELR() BNELRi(0)
|
||||
#define BNGLR() BNGLRi(0)
|
||||
#define BSOLR() BSOLRi(0)
|
||||
#define BNSLR() BNSLRi(0)
|
||||
#define BUNLR() BUNLRi(0)
|
||||
#define BNULR() BNULRi(0)
|
||||
|
||||
#define BLTLRL() BLTLRLi(0)
|
||||
#define BLELRL() BLELRLi(0)
|
||||
#define BEQLRL() BEQLRLi(0)
|
||||
#define BGELRL() BGELRLi(0)
|
||||
#define BGTLRL() BGTLRLi(0)
|
||||
#define BNLLRL() BNLLRLi(0)
|
||||
#define BNELRL() BNELRLi(0)
|
||||
#define BNGLRL() BNGLRLi(0)
|
||||
#define BSOLRL() BSOLRLi(0)
|
||||
#define BNSLRL() BNSLRLi(0)
|
||||
#define BUNLRL() BUNLRLi(0)
|
||||
#define BNULRL() BNULRLi(0)
|
||||
|
||||
#define BLTCTR() BLTCTRi(0)
|
||||
#define BLECTR() BLECTRi(0)
|
||||
#define BEQCTR() BEQCTRi(0)
|
||||
#define BGECTR() BGECTRi(0)
|
||||
#define BGTCTR() BGTCTRi(0)
|
||||
#define BNLCTR() BNLCTRi(0)
|
||||
#define BNECTR() BNECTRi(0)
|
||||
#define BNGCTR() BNGCTRi(0)
|
||||
#define BSOCTR() BSOCTRi(0)
|
||||
#define BNSCTR() BNSCTRi(0)
|
||||
#define BUNCTR() BUNCTRi(0)
|
||||
#define BNUCTR() BNUCTRi(0)
|
||||
|
||||
#define BLTCTRL() BLTCTRLi(0)
|
||||
#define BLECTRL() BLECTRLi(0)
|
||||
#define BEQCTRL() BEQCTRLi(0)
|
||||
#define BGECTRL() BGECTRLi(0)
|
||||
#define BGTCTRL() BGTCTRLi(0)
|
||||
#define BNLCTRL() BNLCTRLi(0)
|
||||
#define BNECTRL() BNECTRLi(0)
|
||||
#define BNGCTRL() BNGCTRLi(0)
|
||||
#define BSOCTRL() BSOCTRLi(0)
|
||||
#define BNSCTRL() BNSCTRLi(0)
|
||||
#define BUNCTRL() BUNCTRLi(0)
|
||||
#define BNUCTRL() BNUCTRLi(0)
|
||||
|
||||
|
||||
#define BLTii(C,D) BC_EXT(12, ((C)<<2)+0, D) /* [1, Table F-11] */
|
||||
#define BNLii(C,D) BC_EXT( 4, ((C)<<2)+0, D)
|
||||
#define BGEii(C,D) BC_EXT( 4, ((C)<<2)+0, D)
|
||||
#define BGTii(C,D) BC_EXT(12, ((C)<<2)+1, D)
|
||||
#define BNGii(C,D) BC_EXT( 4, ((C)<<2)+1, D)
|
||||
#define BLEii(C,D) BC_EXT( 4, ((C)<<2)+1, D)
|
||||
#define BEQii(C,D) BC_EXT(12, ((C)<<2)+2, D)
|
||||
#define BNEii(C,D) BC_EXT( 4, ((C)<<2)+2, D)
|
||||
#define BSOii(C,D) BC_EXT(12, ((C)<<2)+3, D)
|
||||
#define BNSii(C,D) BC_EXT( 4, ((C)<<2)+3, D)
|
||||
#define BUNii(C,D) BC_EXT(12, ((C)<<2)+3, D)
|
||||
#define BNUii(C,D) BC_EXT( 4, ((C)<<2)+3, D)
|
||||
|
||||
#define BLTi(D) BLTii(0,D) /* with implicit _cr0 */
|
||||
#define BLEi(D) BLEii(0,D)
|
||||
#define BEQi(D) BEQii(0,D)
|
||||
#define BGEi(D) BGEii(0,D)
|
||||
#define BGTi(D) BGTii(0,D)
|
||||
#define BNLi(D) BNLii(0,D)
|
||||
#define BNEi(D) BNEii(0,D)
|
||||
#define BNGi(D) BNGii(0,D)
|
||||
#define BSOi(D) BSOii(0,D)
|
||||
#define BNSi(D) BNSii(0,D)
|
||||
#define BUNi(D) BUNii(0,D)
|
||||
#define BNUi(D) BNUii(0,D)
|
||||
|
||||
#define BLTLii(C,D) BCLiii(12, ((C)<<2)+0, D) /* [1, Table F-??] */
|
||||
#define BLELii(C,D) BCLiii( 4, ((C)<<2)+1, D)
|
||||
#define BEQLii(C,D) BCLiii(12, ((C)<<2)+2, D)
|
||||
#define BGELii(C,D) BCLiii( 4, ((C)<<2)+0, D)
|
||||
#define BGTLii(C,D) BCLiii(12, ((C)<<2)+1, D)
|
||||
#define BNLLii(C,D) BCLiii( 4, ((C)<<2)+0, D)
|
||||
#define BNELii(C,D) BCLiii( 4, ((C)<<2)+2, D)
|
||||
#define BNGLii(C,D) BCLiii( 4, ((C)<<2)+1, D)
|
||||
#define BSOLii(C,D) BCLiii(12, ((C)<<2)+3, D)
|
||||
#define BNSLii(C,D) BCLiii( 4, ((C)<<2)+3, D)
|
||||
#define BUNLii(C,D) BCLiii(12, ((C)<<2)+3, D)
|
||||
#define BNULii(C,D) BCLiii( 4, ((C)<<2)+3, D)
|
||||
|
||||
#define BLTLi(D) BLTLii(0,D) /* with implicit _cr0 */
|
||||
#define BLELi(D) BLELii(0,D)
|
||||
#define BEQLi(D) BEQLii(0,D)
|
||||
#define BGELi(D) BGELii(0,D)
|
||||
#define BGTLi(D) BGTLii(0,D)
|
||||
#define BNLLi(D) BNLLii(0,D)
|
||||
#define BNELi(D) BNELii(0,D)
|
||||
#define BNGLi(D) BNGLii(0,D)
|
||||
#define BSOLi(D) BSOLii(0,D)
|
||||
#define BNSLi(D) BNSLii(0,D)
|
||||
#define BUNLi(D) BUNLii(0,D)
|
||||
#define BNULi(D) BNULii(0,D)
|
||||
|
||||
/* Note: there are many tens of other simplified branches that are not (yet?) defined here */
|
||||
|
||||
#define CRSETi(BX) CREQViii(BX, BX, BX) /* [1, Table F-15] */
|
||||
#define CRCLRi(BX) CRXORiii(BX, BX, BX)
|
||||
#define CRMOVEii(BX,BY) CRORiii(BX, BY, BY)
|
||||
#define CRNOTii(BX,BY) CRNORiii(BX, BY, BY)
|
||||
|
||||
#define MTLRr(RS) MTSPRir(8, RS) /* [1, Table F-20] */
|
||||
#define MFLRr(RD) MFSPRri(RD, 8)
|
||||
#define MTCTRr(RS) MTSPRir(9, RS)
|
||||
#define MFCTRr(RD) MFSPRri(RD, 9)
|
||||
#define MTXERr(RS) MTSPRir(1, RS)
|
||||
#define MFXERr(RD) MFSPRri(RD, 1)
|
||||
|
||||
#define NOP() ORIrri(0, 0, 0) /* [1, Section F.9] */
|
||||
#define LIri(RD,IM) ADDIrri(RD, 0, IM)
|
||||
#define LISri(RD,IM) ADDISrri(RD, 0, IM)
|
||||
#define LArm(RD,D,RA) ADDIrri(RD, RA, D)
|
||||
#define LArrr(RD,RB,RA) ADDIrrr(RD, RA, RB)
|
||||
#define MRrr(RA,RS) ORrrr(RA, RS, RS)
|
||||
#define NOTrr(RA,RS) NORrrr(RA, RS, RS)
|
||||
|
||||
/* alternative parenthesised forms of extended indexed load/store insns */
|
||||
|
||||
#define LBZUrx(RD,RA,RB) LBZUXrrr(RD,RA,RB)
|
||||
#define LBZrx(RD,RA,RB) LBZXrrr(RD,RA,RB)
|
||||
#define LHAUrx(RD,RA,RB) LHAUXrrr(RD,RA,RB)
|
||||
#define LHArx(RD,RA,RB) LHAXrrr(RD,RA,RB)
|
||||
#define LHBRrx(RD,RA,RB) LHBRXrrr(RD,RA,RB)
|
||||
#define LHZUrx(RD,RA,RB) LHZUXrrr(RD,RA,RB)
|
||||
#define LHZrx(RD,RA,RB) LHZXrrr(RD,RA,RB)
|
||||
#define LWBRrx(RD,RA,RB) LWBRXrrr(RD,RA,RB)
|
||||
#define LWZUrx(RD, RA, RB) LWZUXrrr(RD, RA, RB)
|
||||
#define LWZrx(RD, RA, RB) LWZXrrr(RD, RA, RB)
|
||||
#define STBUrx(RD,RA,RB) STBUXrrr(RD,RA,RB)
|
||||
#define STBrx(RD,RA,RB) STBXrrr(RD,RA,RB)
|
||||
#define STHBRrx(RS,RA,RB) STHBRXrrr(RS,RA,RB)
|
||||
#define STHUrx(RS,RA,RB) STHUXrrr(RS,RA,RB)
|
||||
#define STHrx(RS,RA,RB) STHXrrr(RS,RA,RB)
|
||||
#define STWBRrx(RS,RA,RB) STWBRXrrr(RS,RA,RB)
|
||||
#define STWCrx(RS,RA,RB) STWCXrrr(RS,RA,RB)
|
||||
#define STWCX_rx(RS,RA,RB) STWCX_rrr(RS,RA,RB)
|
||||
#define STWUrx(RS,RA,RB) STWUXrrr(RS,RA,RB)
|
||||
#define STWrx(RS,RA,RB) STWXrrr(RS,RA,RB)
|
||||
#define LArx(RD,RB,RA) LArrr(RD,RB,RA)
|
||||
|
||||
|
||||
#define _LO(I) (_jit_UL(I) & _MASK(16))
|
||||
#define _HI(I) (_jit_UL(I) >> (16))
|
||||
|
||||
#define _A(OP,RD,RA,RB,RC,XO,RCx) _jit_I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)|_u5(RC)<<6|(_u5(XO)<<1)|_u1(RCx))
|
||||
|
||||
#define LFDrri(RD,RA,imm) _D(50,RD,RA,imm)
|
||||
#define LFDUrri(RD,RA,imm) _D(51,RD,RA,imm)
|
||||
#define LFDUxrrr(RD,RA,RB) _X(31,RD,RA,RB,631,0)
|
||||
#define LFDxrrr(RD,RA,RB) _X(31,RD,RA,RB,599,0)
|
||||
|
||||
#define LFSrri(RD,RA,imm) _D(48,RD,RA,imm)
|
||||
#define LFSUrri(RD,RA,imm) _D(49,RD,RA,imm)
|
||||
#define LFSUxrrr(RD,RA,RB) _X(31,RD,RA,RB,567,0)
|
||||
#define LFSxrrr(RD,RA,RB) _X(31,RD,RA,RB,535,0)
|
||||
|
||||
#define STFDrri(RS,RA,imm) _D(54,RS,RA,imm)
|
||||
#define STFDUrri(RS,RA,imm) _D(55,RS,RA,imm)
|
||||
#define STFDUxrrr(RS,RA,RB) _X(31,RS,RA,RB,759,0)
|
||||
#define STFDxrrr(RS,RA,RB) _X(31,RS,RA,RB,727,0)
|
||||
|
||||
#define STFSrri(RS,RA,imm) _D(52,RS,RA,imm)
|
||||
#define STFSUrri(RS,RA,imm) _D(53,RS,RA,imm)
|
||||
#define STFSUxrrr(RS,RA,RB) _X(31,RS,RA,RB,695,0)
|
||||
#define STFSxrrr(RS,RA,RB) _X(31,RS,RA,RB,663,0)
|
||||
#define STFIWXrrr(RS,RA,RB) _X(31,RS,RA,RB,983,0)
|
||||
|
||||
#define FADDDrrr(RD,RA,RB) _A(63,RD,RA,RB,0,21,0)
|
||||
#define FADDSrrr(RD,RA,RB) _A(59,RD,RA,RB,0,21,0)
|
||||
#define FSUBDrrr(RD,RA,RB) _A(63,RD,RA,RB,0,20,0)
|
||||
#define FSUBSrrr(RD,RA,RB) _A(59,RD,RA,RB,0,20,0)
|
||||
#define FMULDrrr(RD,RA,RC) _A(63,RD,RA,0,RC,25,0)
|
||||
#define FMULSrrr(RD,RA,RC) _A(59,RD,RA,0,RC,25,0)
|
||||
#define FDIVDrrr(RD,RA,RB) _A(63,RD,RA,RB,0,18,0)
|
||||
#define FDIVSrrr(RD,RA,RB) _A(59,RD,RA,RB,0,25,0)
|
||||
#define FSQRTDrr(RD,RB) _A(63,RD,0,RB,0,22,0)
|
||||
#define FSQRTSrr(RD,RB) _A(59,RD,0,RB,0,22,0)
|
||||
#define FSELrrrr(RD,RA,RB,RC) _A(63,RD,RA,RB,RC,23,0)
|
||||
#define FCTIWrr(RD,RB) _X(63,RD,0,RB,14,0)
|
||||
#define FCTIWZrr(RD,RB) _X(63,RD,0,RB,15,0)
|
||||
#define FRSPrr(RD,RB) _X(63,RD,0,RB,12,0)
|
||||
#define FABSrr(RD,RB) _X(63,RD,0,RB,264,0)
|
||||
#define FNABSrr(RD,RB) _X(63,RD,0,RB,136,0)
|
||||
#define FNEGrr(RD,RB) _X(63,RD,0,RB,40,0)
|
||||
#define FMOVErr(RD,RB) _X(63,RD,0,RB,72,0)
|
||||
#define FCMPOrrr(CR,RA,RB) _X(63,_u3((CR)<<2),RA,RB,32,0)
|
||||
#define FCMPUrrr(CR,RA,RB) _X(63,_u3((CR)<<2),RA,RB,0,0)
|
||||
#define MTFSFIri(CR,IMM) _X(63,_u5((CR)<<2),0,_u5((IMM)<<1),134,0)
|
||||
|
||||
/*** References:
|
||||
*
|
||||
* [1] "PowerPC Microprocessor Family: The Programming Environments For 32-Bit Microprocessors", Motorola, 1997.
|
||||
*/
|
||||
|
||||
|
||||
#endif
|
||||
#endif /* __ccg_asm_ppc_h */
|
||||
298
src/runtime/c/pgf/lightning/ppc/core.h
Normal file
298
src/runtime/c/pgf/lightning/ppc/core.h
Normal file
@@ -0,0 +1,298 @@
|
||||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer (PowerPC version)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* 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 2.1, 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.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_core_h
|
||||
#define __lightning_core_h
|
||||
|
||||
struct jit_local_state {
|
||||
int nextarg_puti; /* number of integer args */
|
||||
int nextarg_putf; /* number of float args */
|
||||
int nextarg_putd; /* number of double args */
|
||||
int nextarg_geti; /* Next r20-r25 reg. to be read */
|
||||
int nextarg_getd; /* The FP args are picked up from FPR1 -> FPR10 */
|
||||
int nbArgs; /* Number of arguments for the prolog */
|
||||
};
|
||||
|
||||
#define JIT_SP 1
|
||||
#define JIT_RET 3
|
||||
#define JIT_R_NUM 3
|
||||
#define JIT_V_NUM 7
|
||||
#define JIT_R(i) (9+(i))
|
||||
#define JIT_V(i) (31-(i))
|
||||
#define JIT_AUX JIT_V(JIT_V_NUM) /* for 32-bit operands & shift counts */
|
||||
|
||||
#define jit_pfx_start() (_jit.jitl.trampolines)
|
||||
#define jit_pfx_end() (_jit.jitl.free)
|
||||
|
||||
/* If possible, use the `small' instruction (rd, rs, imm)
|
||||
* else load imm into r26 and use the `big' instruction (rd, rs, r26)
|
||||
*/
|
||||
#define jit_chk_ims(imm, small, big) (_siP(16,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) )
|
||||
#define jit_chk_imu(imm, small, big) (_uiP(16,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) )
|
||||
#define jit_chk_imu15(imm, small, big) (_uiP(15,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) )
|
||||
|
||||
#define jit_big_ims(imm, big) (MOVEIri(JIT_AUX, imm), (big))
|
||||
#define jit_big_imu(imm, big) (MOVEIri(JIT_AUX, imm), (big))
|
||||
|
||||
/* Helper macros for branches */
|
||||
#define jit_s_brai(rs, is, jmp) (jit_chk_ims (is, CMPWIri(rs, is), CMPWrr(rs, JIT_AUX)), jmp, _jit.x.pc)
|
||||
#define jit_s_brar(s1, s2, jmp) ( CMPWrr(s1, s2), jmp, _jit.x.pc)
|
||||
#define jit_u_brai(rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), jmp, _jit.x.pc)
|
||||
#define jit_u_brar(s1, s2, jmp) ( CMPLWrr(s1, s2), jmp, _jit.x.pc)
|
||||
|
||||
/* Helper macros for boolean tests. */
|
||||
#define jit_sbooli(d, rs, is, jmp) (jit_chk_ims (is, CMPWIri (rs, is), CMPWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_sboolr(d, s1, s2, jmp) ( CMPWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_sbooli2(d, rs, is, jmp) (jit_chk_ims (is, CMPWIri (rs, is), CMPWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
#define jit_sboolr2(d, s1, s2, jmp) ( CMPWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
#define jit_ubooli(d, rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_uboolr(d, s1, s2, jmp) ( CMPLWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_ubooli2(d, rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
#define jit_uboolr2(d, s1, s2, jmp) ( CMPLWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
|
||||
/* modulus with immediate
|
||||
* movei r26, imm
|
||||
* mtlr r31
|
||||
* divw r31, rs, r26 (or divwu)
|
||||
* mullw r31, r31, r26
|
||||
* sub rs, rs, r26
|
||||
* mflr r31
|
||||
*/
|
||||
|
||||
#define _jit_mod(div, rs, imm) (MOVEIri(JIT_AUX, (imm)), MTLRr(31), (div), \
|
||||
MULLWrrr(31, 31, JIT_AUX), SUBrrr((rs), (rs), JIT_AUX), \
|
||||
MFLRr(31))
|
||||
|
||||
/* Patch a movei instruction made of a LIS at lis_pc and an ORI at ori_pc. */
|
||||
#define jit_patch_movei(lis_pc, ori_pc, dest) \
|
||||
(*(lis_pc) &= ~_MASK(16), *(lis_pc) |= _HI(dest), \
|
||||
*(ori_pc) &= ~_MASK(16), *(ori_pc) |= _LO(dest)) \
|
||||
|
||||
/* Patch a branch instruction */
|
||||
#define jit_patch_branch(jump_pc,pv) \
|
||||
(*(jump_pc) &= ~_MASK(16) | 3, \
|
||||
*(jump_pc) |= (_jit_UL(pv) - _jit_UL(jump_pc)) & _MASK(16))
|
||||
|
||||
#define jit_patch_ucbranch(jump_pc,pv) \
|
||||
(*(jump_pc) &= ~_MASK(26) | 3, \
|
||||
(*(jump_pc) |= (_jit_UL((pv)) - _jit_UL(jump_pc)) & _MASK(26)))
|
||||
|
||||
#define _jit_b_encoding (18 << 26)
|
||||
#define _jit_blr_encoding ((19 << 26) | (20 << 21) | (00 << 16) | (00 << 11) | (16 << 1))
|
||||
#define _jit_is_ucbranch(a) (((*(a) & (63<<26)) == _jit_b_encoding))
|
||||
|
||||
#define jit_patch_at(jump_pc, value) ( \
|
||||
((*(jump_pc - 1) & ~1) == _jit_blr_encoding) \
|
||||
? jit_patch_movei(((jump_pc) - 4), ((jump_pc) - 3), (value)) \
|
||||
: ( _jit_is_ucbranch((jump_pc) - 1) \
|
||||
? jit_patch_ucbranch((jump_pc) - 1, (value)) \
|
||||
: jit_patch_branch((jump_pc) - 1, (value))))
|
||||
|
||||
#define jit_patch_movi(movi_pc, val) \
|
||||
jit_patch_movei((movi_pc) - 2, (movi_pc) - 1, (val))
|
||||
|
||||
#define jit_arg_c() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_i() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_l() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_p() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_s() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_uc() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_ui() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_ul() (_jitl.nextarg_geti--)
|
||||
#define jit_arg_us() (_jitl.nextarg_geti--)
|
||||
|
||||
/* Check Mach-O-Runtime documentation: Must skip GPR(s) whenever "corresponding" FPR is used */
|
||||
#define jit_arg_f() (_jitl.nextarg_geti-- ,_jitl.nextarg_getd++)
|
||||
#define jit_arg_d() (_jitl.nextarg_geti-=2,_jitl.nextarg_getd++)
|
||||
|
||||
#define jit_addi_i(d, rs, is) jit_chk_ims((is), ADDICrri((d), (rs), (is)), ADDrrr((d), (rs), JIT_AUX))
|
||||
#define jit_addr_i(d, s1, s2) ADDrrr((d), (s1), (s2))
|
||||
#define jit_addci_i(d, rs, is) jit_chk_ims((is), ADDICrri((d), (rs), (is)), ADDCrrr((d), (rs), JIT_AUX))
|
||||
#define jit_addcr_i(d, s1, s2) ADDCrrr((d), (s1), (s2))
|
||||
#define jit_addxi_i(d, rs, is) (MOVEIri(JIT_AUX, (is)), ADDErrr((d), (rs), JIT_AUX))
|
||||
#define jit_addxr_i(d, s1, s2) ADDErrr((d), (s1), (s2))
|
||||
#define jit_andi_i(d, rs, is) jit_chk_imu((is), ANDI_rri((d), (rs), (is)), ANDrrr((d), (rs), JIT_AUX))
|
||||
#define jit_andr_i(d, s1, s2) ANDrrr((d), (s1), (s2))
|
||||
#define jit_bmsi_i(label, rs, is) (jit_chk_imu((is), ANDI_rri(JIT_AUX, (rs), (is)), AND_rrr(JIT_AUX, (rs), JIT_AUX)), BGTi((label)), _jit.x.pc)
|
||||
#define jit_bmci_i(label, rs, is) (jit_chk_imu((is), ANDI_rri(JIT_AUX, (rs), (is)), AND_rrr(JIT_AUX, (rs), JIT_AUX)), BEQi((label)), _jit.x.pc)
|
||||
#define jit_bmsr_i(label, s1, s2) ( AND_rrr(JIT_AUX, (s1), (s2)), BGTi((label)), _jit.x.pc)
|
||||
#define jit_bmcr_i(label, s1, s2) ( AND_rrr(JIT_AUX, (s1), (s2)), BEQi((label)), _jit.x.pc)
|
||||
#define jit_beqi_i(label, rs, is) jit_s_brai((rs), (is), BEQi((label)) )
|
||||
#define jit_beqr_i(label, s1, s2) jit_s_brar((s1), (s2), BEQi((label)) )
|
||||
#define jit_bgei_i(label, rs, is) jit_s_brai((rs), (is), BGEi((label)) )
|
||||
#define jit_bgei_ui(label, rs, is) jit_u_brai((rs), (is), BGEi((label)) )
|
||||
#define jit_bger_i(label, s1, s2) jit_s_brar((s1), (s2), BGEi((label)) )
|
||||
#define jit_bger_ui(label, s1, s2) jit_u_brar((s1), (s2), BGEi((label)) )
|
||||
#define jit_bgti_i(label, rs, is) jit_s_brai((rs), (is), BGTi((label)) )
|
||||
#define jit_bgti_ui(label, rs, is) jit_u_brai((rs), (is), BGTi((label)) )
|
||||
#define jit_bgtr_i(label, s1, s2) jit_s_brar((s1), (s2), BGTi((label)) )
|
||||
#define jit_bgtr_ui(label, s1, s2) jit_u_brar((s1), (s2), BGTi((label)) )
|
||||
#define jit_blei_i(label, rs, is) jit_s_brai((rs), (is), BLEi((label)) )
|
||||
#define jit_blei_ui(label, rs, is) jit_u_brai((rs), (is), BLEi((label)) )
|
||||
#define jit_bler_i(label, s1, s2) jit_s_brar((s1), (s2), BLEi((label)) )
|
||||
#define jit_bler_ui(label, s1, s2) jit_u_brar((s1), (s2), BLEi((label)) )
|
||||
#define jit_blti_i(label, rs, is) jit_s_brai((rs), (is), BLTi((label)) )
|
||||
#define jit_blti_ui(label, rs, is) jit_u_brai((rs), (is), BLTi((label)) )
|
||||
#define jit_bltr_i(label, s1, s2) jit_s_brar((s1), (s2), BLTi((label)) )
|
||||
#define jit_bltr_ui(label, s1, s2) jit_u_brar((s1), (s2), BLTi((label)) )
|
||||
#define jit_bnei_i(label, rs, is) jit_s_brai((rs), (is), BNEi((label)) )
|
||||
#define jit_bner_i(label, s1, s2) jit_s_brar((s1), (s2), BNEi((label)) )
|
||||
#define jit_boaddi_i(label, rs, is) (MOVEIri(JIT_AUX, (is)), ADDOrrr((rs), (rs), JIT_AUX), MCRXRi(0), BGTi((label)), _jit.x.pc) /* GT = bit 1 of XER = OV */
|
||||
#define jit_bosubi_i(label, rs, is) (MOVEIri(JIT_AUX, (is)), SUBCOrrr((rs), (rs), JIT_AUX), MCRXRi(0), BGTi((label)), _jit.x.pc)
|
||||
#define jit_boaddr_i(label, s1, s2) ( ADDOrrr((s1), (s1), (s2)), MCRXRi(0), BGTi((label)), _jit.x.pc)
|
||||
#define jit_bosubr_i(label, s1, s2) ( SUBCOrrr((s1), (s1), (s2)), MCRXRi(0), BGTi((label)), _jit.x.pc)
|
||||
#define jit_boaddi_ui(label, rs, is) (jit_chk_ims ((is), ADDICri((rs), (rs), is), ADDCrr((rs), JIT_AUX)), MCRXRi(0), BEQi((label)), _jit.x.pc) /* EQ = bit 2 of XER = CA */
|
||||
#define jit_bosubi_ui(label, rs, is) (jit_chk_ims ((is), SUBICri((rs), (rs), is), SUBCrr((rs), JIT_AUX)), MCRXRi(0), BEQi((label)), _jit.x.pc)
|
||||
#define jit_boaddr_ui(label, s1, s2) ( ADDCrr((s1), (s1), (s2)), MCRXRi(0), BEQi((label)), _jit.x.pc)
|
||||
#define jit_bosubr_ui(label, s1, s2) ( SUBCrr((s1), (s1), (s2)), MCRXRi(0), BEQi((label)), _jit.x.pc)
|
||||
#define jit_calli(label) (jit_movi_p(JIT_AUX, (label)), MTCTRr(JIT_AUX), BCTRL(), _jitl.nextarg_puti = _jitl.nextarg_putf = _jitl.nextarg_putd = 0, _jit.x.pc)
|
||||
#define jit_callr(reg) (MTCTRr(reg), BCTRL())
|
||||
#define jit_divi_i(d, rs, is) jit_big_ims((is), DIVWrrr ((d), (rs), JIT_AUX))
|
||||
#define jit_divi_ui(d, rs, is) jit_big_imu((is), DIVWUrrr((d), (rs), JIT_AUX))
|
||||
#define jit_divr_i(d, s1, s2) DIVWrrr ((d), (s1), (s2))
|
||||
#define jit_divr_ui(d, s1, s2) DIVWUrrr((d), (s1), (s2))
|
||||
#define jit_eqi_i(d, rs, is) (jit_chk_ims((is), SUBIrri(JIT_AUX, (rs), (is)), SUBrrr(JIT_AUX, (rs), JIT_AUX)), SUBFICrri((d), JIT_AUX, 0), ADDErrr((d), (d), JIT_AUX))
|
||||
#define jit_eqr_i(d, s1, s2) (SUBrrr(JIT_AUX, (s1), (s2)), SUBFICrri((d), JIT_AUX, 0), ADDErrr((d), (d), JIT_AUX))
|
||||
#define jit_extr_c_i(d, rs) EXTSBrr((d), (rs))
|
||||
#define jit_extr_s_i(d, rs) EXTSHrr((d), (rs))
|
||||
#define jit_gei_i(d, rs, is) jit_sbooli2((d), (rs), (is), _lt)
|
||||
#define jit_gei_ui(d, rs, is) jit_ubooli2((d), (rs), (is), _lt)
|
||||
#define jit_ger_i(d, s1, s2) jit_sboolr2((d), (s1), (s2), _lt)
|
||||
#define jit_ger_ui(d, s1, s2) jit_uboolr2((d), (s1), (s2), _lt)
|
||||
#define jit_gti_i(d, rs, is) jit_sbooli ((d), (rs), (is), _gt)
|
||||
#define jit_gti_ui(d, rs, is) jit_ubooli ((d), (rs), (is), _gt)
|
||||
#define jit_gtr_i(d, s1, s2) jit_sboolr ((d), (s1), (s2), _gt)
|
||||
#define jit_gtr_ui(d, s1, s2) jit_uboolr ((d), (s1), (s2), _gt)
|
||||
#define jit_hmuli_i(d, rs, is) jit_big_ims((is), MULHWrrr ((d), (rs), JIT_AUX))
|
||||
#define jit_hmuli_ui(d, rs, is) jit_big_imu((is), MULHWUrrr((d), (rs), JIT_AUX))
|
||||
#define jit_hmulr_i(d, s1, s2) MULHWrrr ((d), (s1), (s2))
|
||||
#define jit_hmulr_ui(d, s1, s2) MULHWUrrr((d), (s1), (s2))
|
||||
#define jit_jmpi(label) (B_EXT((label)), _jit.x.pc)
|
||||
#define jit_jmpr(reg) (MTLRr(reg), BLR())
|
||||
#define jit_ldxi_c(d, rs, is) (jit_ldxi_uc((d), (rs), (is)), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldxr_c(d, s1, s2) (jit_ldxr_uc((d), (s1), (s2)), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldxi_i(d, rs, is) jit_chk_ims((d), LWZrm((d), (is), (rs)), LWZrx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxi_s(d, rs, is) jit_chk_ims((d), LHArm((d), (is), (rs)), LHArx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxi_uc(d, rs, is) jit_chk_ims((d), LBZrm((d), (is), (rs)), LBZrx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxi_us(d, rs, is) jit_chk_ims((d), LHZrm((d), (is), (rs)), LHZrx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxr_i(d, s1, s2) LWZrx((d), (s1), (s2))
|
||||
#define jit_ldxr_s(d, s1, s2) LHArx((d), (s1), (s2))
|
||||
#define jit_ldxr_uc(d, s1, s2) LBZrx((d), (s1), (s2))
|
||||
#define jit_ldxr_us(d, s1, s2) LHZrx((d), (s1), (s2))
|
||||
#define jit_lei_i(d, rs, is) jit_sbooli2((d), (rs), (is), _gt )
|
||||
#define jit_lei_ui(d, rs, is) jit_ubooli2((d), (rs), (is), _gt )
|
||||
#define jit_ler_i(d, s1, s2) jit_sboolr2((d), (s1), (s2), _gt )
|
||||
#define jit_ler_ui(d, s1, s2) jit_uboolr2((d), (s1), (s2), _gt )
|
||||
#define jit_lshi_i(d, rs, is) SLWIrri((d), (rs), (is))
|
||||
#define jit_lshr_i(d, s1, s2) (ANDI_rri(JIT_AUX, (s2), 31), SLWrrr ((d), (s1), JIT_AUX))
|
||||
#define jit_lti_i(d, rs, is) jit_sbooli ((d), (rs), (is), _lt )
|
||||
#define jit_lti_ui(d, rs, is) jit_ubooli ((d), (rs), (is), _lt )
|
||||
#define jit_ltr_i(d, s1, s2) jit_sboolr ((d), (s1), (s2), _lt )
|
||||
#define jit_ltr_ui(d, s1, s2) jit_uboolr ((d), (s1), (s2), _lt )
|
||||
#define jit_modi_i(d, rs, is) _jit_mod(jit_divi_i (31, (rs), JIT_AUX), (rs), (is))
|
||||
#define jit_modi_ui(d, rs, is) _jit_mod(jit_divi_ui(31, (rs), JIT_AUX), (rs), (is))
|
||||
#define jit_modr_i(d, s1, s2) (DIVWrrr(JIT_AUX, (s1), (s2)), MULLWrrr(JIT_AUX, JIT_AUX, (s2)), SUBrrr((d), (s1), JIT_AUX))
|
||||
#define jit_modr_ui(d, s1, s2) (DIVWUrrr(JIT_AUX, (s1), (s2)), MULLWrrr(JIT_AUX, JIT_AUX, (s2)), SUBrrr((d), (s1), JIT_AUX))
|
||||
#define jit_movi_i(d, is) MOVEIri((d), (is))
|
||||
#define jit_movi_p(d, is) (LISri((d), _HI((is))),ORIrri((d),(d),_LO((is))),_jit.x.pc)
|
||||
|
||||
#define jit_movr_i(d, rs) MRrr((d), (rs))
|
||||
#define jit_muli_i(d, rs, is) jit_chk_ims ((is), MULLIrri((d), (rs), (is)), MULLWrrr((d), (rs), JIT_AUX))
|
||||
#define jit_muli_ui(d, rs, is) jit_chk_imu15((is), MULLIrri((d), (rs), (is)), MULLWrrr((d), (rs), JIT_AUX))
|
||||
#define jit_mulr_i(d, s1, s2) MULLWrrr((d), (s1), (s2))
|
||||
#define jit_mulr_ui(d, s1, s2) MULLWrrr((d), (s1), (s2))
|
||||
#define jit_nei_i(d, rs, is) (jit_chk_ims((is), SUBIrri(JIT_AUX, (rs), (is)), SUBrrr(JIT_AUX, (rs), JIT_AUX)), ADDICrri((d), JIT_AUX, -1), SUBFErrr((d), (d), JIT_AUX))
|
||||
#define jit_ner_i(d, s1, s2) (SUBrrr(JIT_AUX, (s1), (s2)), ADDICrri((d), JIT_AUX, -1), SUBFErrr((d), (d), JIT_AUX))
|
||||
#define jit_nop() NOP()
|
||||
#define jit_ori_i(d, rs, is) jit_chk_imu((is), ORIrri((d), (rs), (is)), ORrrr((d), (rs), JIT_AUX))
|
||||
#define jit_orr_i(d, s1, s2) ORrrr((d), (s1), (s2))
|
||||
#define jit_popr_i(rs) (LWZrm((rs), 0, 1), ADDIrri(1, 1, 4))
|
||||
#define jit_prepare_i(numi) (_jitl.nextarg_puti = numi)
|
||||
#define jit_prepare_f(numf) (_jitl.nextarg_putf = numf)
|
||||
#define jit_prepare_d(numd) (_jitl.nextarg_putd = numd)
|
||||
#define jit_prolog(n) _jit_prolog(&_jit, (n))
|
||||
#define jit_pushr_i(rs) STWUrm((rs), -4, 1)
|
||||
#define jit_pusharg_i(rs) (--_jitl.nextarg_puti, MRrr((3 + _jitl.nextarg_putd * 2 + _jitl.nextarg_putf + _jitl.nextarg_puti), (rs)))
|
||||
#define jit_ret() _jit_epilog(&_jit)
|
||||
#define jit_retval_i(rd) MRrr((rd), 3)
|
||||
#define jit_rsbi_i(d, rs, is) jit_chk_ims((is), SUBFICrri((d), (rs), (is)), SUBFCrrr((d), (rs), JIT_AUX))
|
||||
#define jit_rshi_i(d, rs, is) SRAWIrri((d), (rs), (is))
|
||||
#define jit_rshi_ui(d, rs, is) SRWIrri ((d), (rs), (is))
|
||||
#define jit_rshr_i(d, s1, s2) (ANDI_rri(JIT_AUX, (s2), 31), SRAWrrr ((d), (s1), JIT_AUX))
|
||||
#define jit_rshr_ui(d, s1, s2) (ANDI_rri(JIT_AUX, (s2), 31), SRWrrr ((d), (s1), JIT_AUX))
|
||||
#define jit_stxi_c(id, rd, rs) jit_chk_ims((id), STBrm((rs), (id), (rd)), STBrx((rs), (rd), JIT_AUX))
|
||||
#define jit_stxi_i(id, rd, rs) jit_chk_ims((id), STWrm((rs), (id), (rd)), STWrx((rs), (rd), JIT_AUX))
|
||||
#define jit_stxi_s(id, rd, rs) jit_chk_ims((id), STHrm((rs), (id), (rd)), STHrx((rs), (rd), JIT_AUX))
|
||||
#define jit_stxr_c(d1, d2, rs) STBrx((rs), (d1), (d2))
|
||||
#define jit_stxr_i(d1, d2, rs) STWrx((rs), (d1), (d2))
|
||||
#define jit_stxr_s(d1, d2, rs) STHrx((rs), (d1), (d2))
|
||||
#define jit_subr_i(d, s1, s2) SUBrrr((d), (s1), (s2))
|
||||
#define jit_subcr_i(d, s1, s2) SUBCrrr((d), (s1), (s2))
|
||||
#define jit_subxi_i(d, rs, is) jit_big_ims((is), SUBErrr((d), (rs), JIT_AUX))
|
||||
#define jit_subxr_i(d, s1, s2) SUBErrr((d), (s1), (s2))
|
||||
#define jit_xori_i(d, rs, is) jit_chk_imu((is), XORIrri((d), (rs), (is)), XORrrr((d), (rs), JIT_AUX))
|
||||
#define jit_xorr_i(d, s1, s2) XORrrr((d), (s1), (s2))
|
||||
|
||||
/* Cannot use JIT_RZERO because having 0 in a register field on the PowerPC
|
||||
* does not mean `a register whose value is 0', but rather `no register at
|
||||
* all' */
|
||||
|
||||
#define jit_negr_i(d, rs) jit_rsbi_i((d), (rs), 0)
|
||||
#define jit_negr_l(d, rs) jit_rsbi_l((d), (rs), 0)
|
||||
#define jit_ldr_c(rd, rs) jit_ldxr_c((rd), 0, (rs))
|
||||
#define jit_str_c(rd, rs) jit_stxr_c(0, (rd), (rs))
|
||||
#define jit_ldr_s(rd, rs) jit_ldxr_s((rd), 0, (rs))
|
||||
#define jit_str_s(rd, rs) jit_stxr_s(0, (rd), (rs))
|
||||
#define jit_ldr_i(rd, rs) jit_ldxr_i((rd), 0, (rs))
|
||||
#define jit_str_i(rd, rs) jit_stxr_i(0, (rd), (rs))
|
||||
#define jit_ldr_uc(rd, rs) jit_ldxr_uc((rd), 0, (rs))
|
||||
#define jit_ldr_us(rd, rs) jit_ldxr_us((rd), 0, (rs))
|
||||
|
||||
/* e.g.
|
||||
* 0x01234567 _HA << 16 = 0x01230000 _LA = 0x00004567 _HA << 16 + LA = 0x01234567
|
||||
* 0x89abcdef _HA << 16 = 0x89ac0000 _LA = 0xffffcdef _HA << 16 + LA = 0x89abcdef
|
||||
*/
|
||||
#define _HA(addr) ((_jit_UL(addr) >> 16) + (_jit_US(_jit_UL(addr)) >> 15))
|
||||
#define _LA(addr) (_jit_UL(addr) - (_HA(addr) << 16))
|
||||
|
||||
#define jit_ldi_c(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_c((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_sti_c(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_c(_LA(id), JIT_AUX, (rs)))
|
||||
#define jit_ldi_s(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_s((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_sti_s(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_s(_LA(id), JIT_AUX, (rs)))
|
||||
#define jit_ldi_i(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_i((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_sti_i(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_i(_LA(id), JIT_AUX, (rs)))
|
||||
#define jit_ldi_uc(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_uc((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_ldi_us(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_us((rd), JIT_AUX, _LA(is)))
|
||||
|
||||
#endif /* __lightning_core_h */
|
||||
211
src/runtime/c/pgf/lightning/ppc/fp.h
Normal file
211
src/runtime/c/pgf/lightning/ppc/fp.h
Normal file
@@ -0,0 +1,211 @@
|
||||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler & support macros for the Sparc math unit
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* 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 2.1, 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.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_asm_fp_h
|
||||
#define __lightning_asm_fp_h
|
||||
|
||||
|
||||
#define JIT_FPR_NUM 6
|
||||
#define JIT_FPR(i) (8+(i))
|
||||
|
||||
#define JIT_FPFR 0
|
||||
|
||||
/* Make space for 1 or 2 words, store address in REG */
|
||||
#define jit_data(REG, D1) (_FBA (18, 8, 0, 1), _jit_L(D1), MFLRr(REG))
|
||||
|
||||
#define jit_addr_d(rd,s1,s2) FADDDrrr((rd),(s1),(s2))
|
||||
#define jit_subr_d(rd,s1,s2) FSUBDrrr((rd),(s1),(s2))
|
||||
#define jit_mulr_d(rd,s1,s2) FMULDrrr((rd),(s1),(s2))
|
||||
#define jit_divr_d(rd,s1,s2) FDIVDrrr((rd),(s1),(s2))
|
||||
|
||||
#define jit_addr_f(rd,s1,s2) FADDSrrr((rd),(s1),(s2))
|
||||
#define jit_subr_f(rd,s1,s2) FSUBSrrr((rd),(s1),(s2))
|
||||
#define jit_mulr_f(rd,s1,s2) FMULSrrr((rd),(s1),(s2))
|
||||
#define jit_divr_f(rd,s1,s2) FDIVSrrr((rd),(s1),(s2))
|
||||
|
||||
#define jit_movr_d(rd,rs) ( (rd) == (rs) ? 0 : FMOVErr((rd),(rs)))
|
||||
#define jit_movi_d(reg0,d) do { \
|
||||
double _v = (d); \
|
||||
_FBA (18, 12, 0, 1); \
|
||||
memcpy(_jit.x.uc_pc, &_v, sizeof (double)); \
|
||||
_jit.x.uc_pc += sizeof (double); \
|
||||
MFLRr (JIT_AUX); \
|
||||
jit_ldxi_d((reg0), JIT_AUX, 0); \
|
||||
} while(0)
|
||||
|
||||
|
||||
#define jit_movr_f(rd,rs) ( (rd) == (rs) ? 0 : FMOVErr((rd),(rs)))
|
||||
#define jit_movi_f(reg0,f) do { \
|
||||
float _v = (f); \
|
||||
_FBA (18, 8, 0, 1); \
|
||||
memcpy(_jit.x.uc_pc, &_v, sizeof (float)); \
|
||||
_jit.x.uc_pc += sizeof (float); \
|
||||
MFLRr (JIT_AUX); \
|
||||
jit_ldxi_f((reg0), JIT_AUX, 0); \
|
||||
} while(0)
|
||||
|
||||
|
||||
#define jit_abs_d(rd,rs) FABSrr((rd),(rs))
|
||||
#define jit_negr_d(rd,rs) FNEGrr((rd),(rs))
|
||||
#define jit_sqrt_d(rd,rs) FSQRTDrr((rd),(rs))
|
||||
|
||||
|
||||
#define jit_ldxi_f(reg0, rs, is) (_siP(16,(is)) ? LFSrri((reg0),(rs),(is)) : (MOVEIri(JIT_AUX,(is)),LFSxrrr((reg0),(rs),JIT_AUX)))
|
||||
#define jit_ldxi_d(reg0, rs, is) (_siP(16,(is)) ? LFDrri((reg0),(rs),(is)) : (MOVEIri(JIT_AUX,(is)),LFDxrrr((reg0),(rs),JIT_AUX)))
|
||||
#define jit_ldxr_f(reg0, s1, s2) LFSxrrr((reg0),(s1),(s2))
|
||||
#define jit_ldxr_d(reg0, s1, s2) LFDxrrr((reg0),(s1),(s2))
|
||||
#define jit_ldi_f(reg0, is) (_siP(16,(is)) ? LFSrri((reg0),0,(is)) : (MOVEIri(JIT_AUX,(is)),LFSrri((reg0),JIT_AUX,0)))
|
||||
#define jit_ldi_d(reg0, is) (_siP(16,(is)) ? LFDrri((reg0),0,(is)) : (MOVEIri(JIT_AUX,(is)),LFDrri((reg0),JIT_AUX,0)))
|
||||
#define jit_ldr_f(reg0, rs) LFSrri((reg0),(rs),0)
|
||||
#define jit_ldr_d(reg0, rs) LFDrri((reg0),(rs),0)
|
||||
#define jit_stxi_f(id, rd, reg0) (_siP(16,(id)) ? STFSrri((reg0),(rd),(id)) : (MOVEIri(JIT_AUX,(id)),STFSrri((reg0),(rd),JIT_AUX)))
|
||||
#define jit_stxi_d(id, rd, reg0) (_siP(16,(id)) ? STFDrri((reg0),(rd),(id)) : (MOVEIri(JIT_AUX,(id)),STFDrri((reg0),(rd),JIT_AUX)))
|
||||
#define jit_stxr_f(d1, d2, reg0) STFSxrrr((reg0),(d1),(d2))
|
||||
#define jit_stxr_d(d1, d2, reg0) STFDxrrr((reg0),(d1),(d2))
|
||||
#define jit_sti_f(id, reg0) (_siP(16,(id)) ? STFSrri((reg0),0,(id)) : (MOVEIri(JIT_AUX,(id)),STFSrri((reg0),JIT_AUX,0)))
|
||||
#define jit_sti_d(id, reg0) (_siP(16,(id)) ? STFDrri((reg0),0,(id)) : (MOVEIri(JIT_AUX,(id)),STFDrri((reg0),JIT_AUX,0)))
|
||||
#define jit_str_f(rd, reg0) STFSrri((reg0),(rd),0)
|
||||
#define jit_str_d(rd, reg0) STFDrri((reg0),(rd),0)
|
||||
|
||||
#define jit_fpboolr(d, s1, s2, rcbit) ( \
|
||||
FCMPOrrr(_cr0,(s1),(s2)), \
|
||||
MFCRr((d)), \
|
||||
EXTRWIrrii((d), (d), 1, (rcbit)))
|
||||
|
||||
#define jit_fpboolr_neg(d, s1, s2,rcbit) ( \
|
||||
FCMPOrrr(_cr0,(s1),(s2)), \
|
||||
MFCRr((d)), \
|
||||
EXTRWIrrii((d), (d), 1, (rcbit)), \
|
||||
XORIrri((d), (d), 1))
|
||||
|
||||
#define jit_fpboolur(d, s1, s2, rcbit) ( \
|
||||
FCMPUrrr(_cr0,(s1),(s2)), \
|
||||
MFCRr((d)), \
|
||||
EXTRWIrrii((d), (d), 1, (rcbit)))
|
||||
|
||||
#define jit_fpboolur_neg(d, s1, s2,rcbit) ( \
|
||||
FCMPUrrr(_cr0,(s1),(s2)), \
|
||||
MFCRr((d)), \
|
||||
EXTRWIrrii((d), (d), 1, (rcbit)), \
|
||||
XORIrri((d), (d), 1))
|
||||
|
||||
#define jit_fpboolur_or(d, s1, s2, bit1, bit2) (\
|
||||
FCMPUrrr(_cr0,(s1),(s2)), \
|
||||
CRORiii((bit1), (bit1), (bit2)), \
|
||||
MFCRr((d)), \
|
||||
EXTRWIrrii((d), (d), 1, (bit1)))
|
||||
|
||||
#define jit_gtr_d(d, s1, s2) jit_fpboolr ((d),(s1),(s2),_gt)
|
||||
#define jit_ger_d(d, s1, s2) jit_fpboolr_neg((d),(s1),(s2),_lt)
|
||||
#define jit_ltr_d(d, s1, s2) jit_fpboolr ((d),(s1),(s2),_lt)
|
||||
#define jit_ler_d(d, s1, s2) jit_fpboolr_neg((d),(s1),(s2),_gt)
|
||||
#define jit_eqr_d(d, s1, s2) jit_fpboolr ((d),(s1),(s2),_eq)
|
||||
#define jit_ner_d(d, s1, s2) jit_fpboolr_neg((d),(s1),(s2),_eq)
|
||||
#define jit_unordr_d(d, s1, s2) jit_fpboolur ((d),(s1),(s2),_un)
|
||||
#define jit_ordr_d(d, s1, s2) jit_fpboolur_neg((d),(s1),(s2),_un)
|
||||
#define jit_unler_d(d, s1, s2) jit_fpboolur_neg ((d), (s1), (s2), _gt)
|
||||
#define jit_unltr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _un, _lt)
|
||||
#define jit_unger_d(d, s1, s2) jit_fpboolur_neg ((d), (s1), (s2), _lt)
|
||||
#define jit_ungtr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _un, _gt)
|
||||
#define jit_ltgtr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _gt, _lt)
|
||||
#define jit_uneqr_d(d, s1, s2) jit_fpboolur_or ((d), (s1), (s2), _un, _eq)
|
||||
|
||||
#define jit_fpbr(d, s1, s2, rcbit) ( \
|
||||
FCMPOrrr(_cr0,(s1),(s2)), \
|
||||
BTii ((rcbit), (d)))
|
||||
|
||||
#define jit_fpbr_neg(d, s1, s2,rcbit) ( \
|
||||
FCMPOrrr(_cr0,(s1),(s2)), \
|
||||
BFii ((rcbit), (d)))
|
||||
|
||||
#define jit_fpbur(d, s1, s2, rcbit) ( \
|
||||
FCMPUrrr(_cr0,(s1),(s2)), \
|
||||
BTii ((rcbit), (d)))
|
||||
|
||||
#define jit_fpbur_neg(d, s1, s2,rcbit) ( \
|
||||
FCMPUrrr(_cr0,(s1),(s2)), \
|
||||
BFii ((rcbit), (d)))
|
||||
|
||||
#define jit_fpbur_or(d, s1, s2, bit1, bit2) ( \
|
||||
FCMPUrrr(_cr0,(s1),(s2)), \
|
||||
CRORiii((bit1), (bit1), (bit2)), \
|
||||
BTii ((bit1), (d)))
|
||||
|
||||
#define jit_bgtr_d(d, s1, s2) jit_fpbr ((d),(s1),(s2),_gt)
|
||||
#define jit_bger_d(d, s1, s2) jit_fpbr_neg((d),(s1),(s2),_lt)
|
||||
#define jit_bltr_d(d, s1, s2) jit_fpbr ((d),(s1),(s2),_lt)
|
||||
#define jit_bler_d(d, s1, s2) jit_fpbr_neg((d),(s1),(s2),_gt)
|
||||
#define jit_beqr_d(d, s1, s2) jit_fpbr ((d),(s1),(s2),_eq)
|
||||
#define jit_bner_d(d, s1, s2) jit_fpbr_neg((d),(s1),(s2),_eq)
|
||||
#define jit_bunordr_d(d, s1, s2) jit_fpbur ((d),(s1),(s2),_un)
|
||||
#define jit_bordr_d(d, s1, s2) jit_fpbur_neg((d),(s1),(s2),_un)
|
||||
#define jit_bunler_d(d, s1, s2) jit_fpbur_neg ((d), (s1), (s2), _gt)
|
||||
#define jit_bunltr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _un, _lt)
|
||||
#define jit_bunger_d(d, s1, s2) jit_fpbur_neg ((d), (s1), (s2), _lt)
|
||||
#define jit_bungtr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _un, _gt)
|
||||
#define jit_bltgtr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _gt, _lt)
|
||||
#define jit_buneqr_d(d, s1, s2) jit_fpbur_or ((d), (s1), (s2), _un, _eq)
|
||||
|
||||
#define jit_getarg_f(rd, ofs) jit_movr_f((rd),(ofs))
|
||||
#define jit_getarg_d(rd, ofs) jit_movr_d((rd),(ofs))
|
||||
#define jit_pusharg_d(rs) (_jitl.nextarg_putd--,jit_movr_d((_jitl.nextarg_putf+_jitl.nextarg_putd+1), (rs)))
|
||||
#define jit_pusharg_f(rs) (_jitl.nextarg_putf--,jit_movr_f((_jitl.nextarg_putf+_jitl.nextarg_putd+1), (rs)))
|
||||
#define jit_retval_d(op1) jit_movr_d(1, (op1))
|
||||
#define jit_retval_f(op1) jit_movr_f(1, (op1))
|
||||
|
||||
|
||||
#define jit_floorr_d_i(rd,rs) (MTFSFIri(7,3), \
|
||||
FCTIWrr(7,(rs)), \
|
||||
MOVEIri(JIT_AUX,-4), \
|
||||
STFIWXrrr(7,JIT_SP,JIT_AUX), \
|
||||
LWZrm((rd),-4,JIT_SP))
|
||||
|
||||
#define jit_ceilr_d_i(rd,rs) (MTFSFIri(7,2), \
|
||||
FCTIWrr(7,(rs)), \
|
||||
MOVEIri(JIT_AUX,-4), \
|
||||
STFIWXrrr(7,JIT_SP,JIT_AUX), \
|
||||
LWZrm((rd),-4,JIT_SP))
|
||||
|
||||
#define jit_roundr_d_i(rd,rs) (MTFSFIri(7,0), \
|
||||
FCTIWrr(7,(rs)), \
|
||||
MOVEIri(JIT_AUX,-4), \
|
||||
STFIWXrrr(7,JIT_SP,JIT_AUX), \
|
||||
LWZrm((rd),-4,JIT_SP))
|
||||
|
||||
#define jit_truncr_d_i(rd,rs) (FCTIWZrr(7,(rs)), \
|
||||
MOVEIri(JIT_AUX,-4), \
|
||||
STFIWXrrr(7,JIT_SP,JIT_AUX), \
|
||||
LWZrm((rd),-4,JIT_SP))
|
||||
|
||||
#endif /* __lightning_asm_h */
|
||||
164
src/runtime/c/pgf/lightning/ppc/funcs.h
Normal file
164
src/runtime/c/pgf/lightning/ppc/funcs.h
Normal file
@@ -0,0 +1,164 @@
|
||||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer inline functions (PowerPC)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* 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 2.1, 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.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_funcs_h
|
||||
#define __lightning_funcs_h
|
||||
|
||||
#if !defined(__GNUC__) && !defined(__GNUG__)
|
||||
#error Go get GNU C, I do not know how to flush the cache
|
||||
#error with this compiler.
|
||||
#else
|
||||
static void
|
||||
jit_flush_code(void *start, void *end)
|
||||
{
|
||||
#ifndef LIGHTNING_CROSS
|
||||
register char *ddest, *idest;
|
||||
|
||||
static int cache_line_size;
|
||||
if (cache_line_size == 0) {
|
||||
char buffer[8192];
|
||||
int i, probe;
|
||||
|
||||
/* Find out the size of a cache line by zeroing one */
|
||||
memset(buffer, 0xFF, 8192);
|
||||
__asm__ __volatile__ ("dcbz 0,%0" : : "r"(buffer + 4096));
|
||||
|
||||
/* Probe for the beginning of the cache line. */
|
||||
for(i = 0, probe = 4096; probe; probe >>= 1)
|
||||
if (buffer[i | probe] != 0x00)
|
||||
i |= probe;
|
||||
|
||||
/* i is now just before the start of the cache line */
|
||||
i++;
|
||||
for(cache_line_size = 1; i + cache_line_size < 8192; cache_line_size <<= 1)
|
||||
if (buffer[i + cache_line_size] != 0x00)
|
||||
break;
|
||||
}
|
||||
|
||||
start -= ((long) start) & (cache_line_size - 1);
|
||||
end -= ((long) end) & (cache_line_size - 1);
|
||||
|
||||
/* Force data cache write-backs */
|
||||
for (ddest = (char *) start; ddest <= (char *) end; ddest += cache_line_size) {
|
||||
__asm__ __volatile__ ("dcbst 0,%0" : : "r"(ddest));
|
||||
}
|
||||
__asm__ __volatile__ ("sync" : : );
|
||||
|
||||
/* Now invalidate the instruction cache */
|
||||
for (idest = (char *) start; idest <= (char *) end; idest += cache_line_size) {
|
||||
__asm__ __volatile__ ("icbi 0,%0" : : "r"(idest));
|
||||
}
|
||||
__asm__ __volatile__ ("isync" : : );
|
||||
#endif /* !LIGHTNING_CROSS */
|
||||
}
|
||||
#endif /* __GNUC__ || __GNUG__ */
|
||||
|
||||
#define _jit (*jit)
|
||||
|
||||
static void
|
||||
_jit_epilog(jit_state *jit)
|
||||
{
|
||||
int n = _jitl.nbArgs;
|
||||
int frame_size, ofs;
|
||||
int first_saved_reg = JIT_AUX - n;
|
||||
int num_saved_regs = 32 - first_saved_reg;
|
||||
|
||||
frame_size = 24 + 32 + num_saved_regs * 4; /* r24..r31 + args */
|
||||
frame_size += 15; /* the stack must be quad-word */
|
||||
frame_size &= ~15; /* aligned */
|
||||
|
||||
#ifdef _CALL_DARWIN
|
||||
LWZrm(0, frame_size + 8, 1); /* lwz r0, x+8(r1) (ret.addr.) */
|
||||
#else
|
||||
LWZrm(0, frame_size + 4, 1); /* lwz r0, x+4(r1) (ret.addr.) */
|
||||
#endif
|
||||
MTLRr(0); /* mtspr LR, r0 */
|
||||
|
||||
ofs = frame_size - num_saved_regs * 4;
|
||||
LMWrm(first_saved_reg, ofs, 1); /* lmw rI, ofs(r1) */
|
||||
ADDIrri(1, 1, frame_size); /* addi r1, r1, x */
|
||||
BLR(); /* blr */
|
||||
}
|
||||
|
||||
/* Emit a prolog for a function.
|
||||
Upon entrance to the trampoline:
|
||||
- LR = address where the real code for the function lies
|
||||
- R3-R8 = parameters
|
||||
Upon finishing the trampoline:
|
||||
- R0 = return address for the function
|
||||
- R25-R20 = parameters (order is reversed, 1st argument is R25)
|
||||
|
||||
The +32 in frame_size computation is to accound for the parameter area of
|
||||
a function frame.
|
||||
|
||||
On PPC the frame must have space to host the arguments of any callee.
|
||||
However, as it currently stands, the argument to jit_trampoline (n) is
|
||||
the number of arguments of the caller we generate. Therefore, the
|
||||
callee can overwrite a part of the stack (saved register area when it
|
||||
flushes its own parameter on the stack. The addition of a constant
|
||||
offset = 32 is enough to hold eight 4 bytes arguments. This is less
|
||||
than perfect but is a reasonable work around for now.
|
||||
Better solution must be investigated. */
|
||||
static void
|
||||
_jit_prolog(jit_state *jit, int n)
|
||||
{
|
||||
int frame_size;
|
||||
int ofs, i;
|
||||
int first_saved_reg = JIT_AUX - n;
|
||||
int num_saved_regs = 32 - first_saved_reg;
|
||||
|
||||
_jitl.nextarg_geti = JIT_AUX - 1;
|
||||
_jitl.nextarg_getd = 1;
|
||||
_jitl.nbArgs = n;
|
||||
|
||||
frame_size = 24 + 32 + num_saved_regs * 4; /* r27..r31 + args */
|
||||
frame_size += 15; /* the stack must be quad-word */
|
||||
frame_size &= ~15; /* aligned */
|
||||
|
||||
MFLRr(0);
|
||||
STWUrm(1, -frame_size, 1); /* stwu r1, -x(r1) */
|
||||
|
||||
ofs = frame_size - num_saved_regs * 4;
|
||||
STMWrm(first_saved_reg, ofs, 1); /* stmw rI, ofs(r1) */
|
||||
#ifdef _CALL_DARWIN
|
||||
STWrm(0, frame_size + 8, 1); /* stw r0, x+8(r1) */
|
||||
#else
|
||||
STWrm(0, frame_size + 4, 1); /* stw r0, x+4(r1) */
|
||||
#endif
|
||||
for (i = 0; i < n; i++)
|
||||
MRrr(JIT_AUX-1-i, 3+i); /* save parameters below r24 */
|
||||
}
|
||||
|
||||
#undef _jit
|
||||
|
||||
#endif /* __lightning_funcs_h */
|
||||
Reference in New Issue
Block a user