/******************************** -*- 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 /* = [0-9]+ | (.+) -> add i, one parameter (imm) * = r -> add r, one parameter (imm) * = () -> add m, two parameters (imm,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 */