decoder.isa revision 2055
11689SN/A//////////////////////////////////////////////////////////////////// 27598Sminkyu.jeong@arm.com// 37598Sminkyu.jeong@arm.com// The actual MIPS32 ISA decoder 47598Sminkyu.jeong@arm.com// ----------------------------- 57598Sminkyu.jeong@arm.com// The following instructions are specified in the MIPS32 ISA 67598Sminkyu.jeong@arm.com// Specification. Decoding closely follows the style specified 77598Sminkyu.jeong@arm.com// in the MIPS32 ISAthe specification document starting with Table 87598Sminkyu.jeong@arm.com// A-2 (document available @ www.mips.com) 97598Sminkyu.jeong@arm.com// 107598Sminkyu.jeong@arm.com//@todo: Distinguish "unknown/future" use insts from "reserved" 117598Sminkyu.jeong@arm.com// ones 127598Sminkyu.jeong@arm.comdecode OPCODE_HI default FailUnimpl::unknown() { 137598Sminkyu.jeong@arm.com 142326SN/A // Derived From ... Table A-2 MIPS32 ISA Manual 151689SN/A 0x0: decode OPCODE_LO default FailUnimpl::reserved(){ 161689SN/A 171689SN/A 0x0: decode FUNCTION_HI { 181689SN/A 0x0: decode FUNCTION_LO { 191689SN/A 0x1: decode MOVCI { 201689SN/A format BasicOp { 211689SN/A 0: movf({{ if( xc->miscRegs.fpcr == 0) Rd = Rs}}); 221689SN/A 1: movt({{ if( xc->miscRegs.fpcr == 1) Rd = Rs}}); 231689SN/A } 241689SN/A } 251689SN/A 261689SN/A format BasicOp { 271689SN/A 281689SN/A //Table A-3 Note: "1. Specific encodings of the rt, rd, and sa fields 291689SN/A //are used to distinguish among the SLL, NOP, SSNOP and EHB functions." 301689SN/A 311689SN/A 0x0: sll({{ Rd = Rt.uw << SA; }}); 321689SN/A 331689SN/A 0x2: decode SRL { 341689SN/A 0: srl({{ Rd = Rt.uw >> SA; }}); 351689SN/A 361689SN/A //Hardcoded assuming 32-bit ISA, probably need parameter here 371689SN/A 1: rotr({{ Rd = (Rt.uw << (32 - SA)) | (Rt.uw >> SA);}}); 381689SN/A } 392665Ssaidi@eecs.umich.edu 402665Ssaidi@eecs.umich.edu 0x3: sra({{ Rd = Rt.sw >> SA; }}); 411689SN/A 421689SN/A 0x4: sllv({{ Rd = Rt.uw << Rs<4:0>; }}); 431060SN/A 441060SN/A 0x6: decode SRLV { 451689SN/A 0: srlv({{ Rd = Rt.uw >> Rs<4:0>; }}); 461060SN/A 471060SN/A //Hardcoded assuming 32-bit ISA, probably need parameter here 481060SN/A 1: rotrv({{ Rd = (Rt.uw << (32 - Rs<4:0>)) | (Rt.uw >> Rs<4:0>);}}); 497813Ssteve.reinhardt@amd.com } 506658Snate@binkert.org 512292SN/A 0x7: srav({{ Rd = Rt.sw >> Rs<4:0>; }}); 521717SN/A } 535529Snate@binkert.org } 541060SN/A 556221Snate@binkert.org 0x1: decode FUNCTION_LO { 566221Snate@binkert.org 571681SN/A //Table A-3 Note: "Specific encodings of the hint field are used 585529Snate@binkert.org //to distinguish JR from JR.HB and JALR from JALR.HB" 592873Sktlim@umich.edu format Jump { 604329Sktlim@umich.edu 0x0: jr(IsReturn); 614329Sktlim@umich.edu 0x1: jalr(IsCall,IsReturn); 624329Sktlim@umich.edu } 632292SN/A 642292SN/A format BasicOp { 652292SN/A 0x2: movz({{ if (Rt == 0) Rd = Rs; }}); 662292SN/A 0x3: movn({{ if (Rt != 0) Rd = Rs; }}); 672820Sktlim@umich.edu } 682292SN/A 692820Sktlim@umich.edu format WarnUnimpl { 702820Sktlim@umich.edu 0x4: syscall({{ xc->syscall()}},IsNonSpeculative); 715529Snate@binkert.org 0x5: break({{ }}); 722307SN/A 0x7: sync({{ }}); 731060SN/A } 742292SN/A } 752292SN/A 762292SN/A 0x2: decode FUNCTION_LO { 771060SN/A format BasicOp { 781060SN/A 0x0: mfhi({{ Rd = xc->miscRegs.hi; }}); 791060SN/A 0x1: mthi({{ xc->miscRegs.hi = Rs; }}); 801060SN/A 0x2: mflo({{ Rd = xc->miscRegs.lo; }}); 811060SN/A 0x3: mtlo({{ xc->miscRegs.lo = Rs; }}); 821060SN/A } 831681SN/A }; 846221Snate@binkert.org 856221Snate@binkert.org 0x3: decode FUNCTION_LO { 866221Snate@binkert.org format IntOp { 876221Snate@binkert.org 0x0: mult({{ 882292SN/A INT64 temp1 = Rs.sw * Rt.sw; 892292SN/A xc->miscRegs.hi->temp1<63:32>; 902820Sktlim@umich.edu xc->miscRegs.lo->temp1<31:0> 912820Sktlim@umich.edu }}); 922292SN/A 932292SN/A 0x1: multu({{ 942820Sktlim@umich.edu INT64 temp1 = Rs.uw * Rt.uw; 952820Sktlim@umich.edu xc->miscRegs.hi->temp1<63:32>; 962292SN/A xc->miscRegs.lo->temp1<31:0> 972292SN/A Rd.sw = Rs.uw * Rt.uw; 982292SN/A }}); 992292SN/A 1002292SN/A 0x2: div({{ 1012292SN/A xc->miscRegs.hi = Rs.sw % Rt.sw; 1022292SN/A xc->miscRegs.lo = Rs.sw / Rt.sw; 1032292SN/A }}); 1041060SN/A 1051060SN/A 0x3: divu({{ 1061681SN/A xc->miscRegs.hi = Rs.uw % Rt.uw; 1071062SN/A xc->miscRegs.lo = Rs.uw / Rt.uw; 1082292SN/A }}); 1091062SN/A } 1102301SN/A }; 1112301SN/A 1121062SN/A 0x4: decode FUNCTION_LO { 1132727Sktlim@umich.edu format IntOp { 1141062SN/A 0x0: add({{ Rd.sw = Rs.sw + Rt.sw;}}); 1151062SN/A 0x1: addu({{ Rd.uw = Rs.uw + Rt.uw;}}); 1161062SN/A 0x2: sub({{ Rd.sw = Rs.sw - Rt.sw;}}); 1171062SN/A 0x3: subu({{ Rd.uw = Rs.uw - Rt.uw;}}); 1181062SN/A 0x4: and({{ Rd.sw = Rs.uw & Rt.uw;}}); 1191062SN/A 0x5: or({{ Rd.sw = Rs.uw | Rt.uw;}}); 1201062SN/A 0x6: xor({{ Rd.sw = Rs.uw ^ Rt.uw;}}); 1211062SN/A 0x7: nor({{ Rd.sw = ~(Rs.uw | Rt.uw);}}); 1221062SN/A } 1231062SN/A } 1241062SN/A 1251062SN/A 0x5: decode FUNCTION_LO { 1261062SN/A format IntOp{ 1271062SN/A 0x2: slt({{ Rd.sw = ( Rs.sw < Rt.sw ) ? 1 : 0}}); 1281062SN/A 0x3: sltu({{ Rd.uw = ( Rs.uw < Rt.uw ) ? 1 : 0}}); 1291062SN/A } 1301062SN/A }; 1311062SN/A 1321062SN/A 0x6: decode FUNCTION_LO { 1331062SN/A format Trap { 1341062SN/A 0x0: tge({{ cond = (Rs.sw >= Rt.sw); }}); 1351062SN/A 0x1: tgeu({{ cond = (Rs.uw >= Rt.uw); }}); 1361062SN/A 0x2: tlt({{ cond = (Rs.sw < Rt.sw); }}); 1371062SN/A 0x3: tltu({{ cond = (Rs.uw >= Rt.uw); }}); 1381062SN/A 0x4: teq({{ cond = (Rs.sw == Rt.sw); }}); 1391062SN/A 0x6: tne({{ cond = (Rs.sw != Rt.sw); }}); 1401062SN/A } 1411062SN/A } 1421062SN/A } 1431062SN/A 1441062SN/A 0x1: decode REGIMM_HI { 1451062SN/A 0x0: decode REGIMM_LO { 1461062SN/A format Branch { 1471062SN/A 0x0: bltz({{ cond = (Rs.sq < 0); }}); 1481062SN/A 0x1: bgez({{ cond = (Rs.sq >= 0); }}); 1491062SN/A 1501062SN/A //MIPS obsolete instructions 1511062SN/A 0x2: bltzl({{ cond = (Rs.sq < 0); }}); 1521062SN/A 0x3: bgezl({{ cond = (Rs.sq >= 0); }}); 1531062SN/A } 1541062SN/A } 1552292SN/A 1562292SN/A 0x1: decode REGIMM_LO { 1572292SN/A format Trap { 1582292SN/A 0x0: tgei({{ cond = (Rs.sw >= INTIMM; }}); 1591062SN/A 0x1: tgeiu({{ cond = (Rs.uw < INTIMM); }}); 1601062SN/A 0x2: tlti({{ cond = (Rs.sw < INTIMM); }}); 1611062SN/A 0x3: tltiu({{ cond = (Rs.uw < INTIMM); }}); 1621062SN/A 0x4: teqi({{ cond = (Rs.sw == INTIMM); }}); 1631062SN/A 0x6: tnei({{ cond = (Rs.sw != INTIMM); }}); 1641062SN/A } 1651062SN/A } 1662292SN/A 1672292SN/A 0x2: decode REGIMM_LO { 1682292SN/A format Branch { 1692292SN/A 0x0: bltzal({{ cond = (Rs.sq < 0); }}); 1702292SN/A 0x1: bgezal({{ cond = (Rs.sq >= 0); }}); 1712292SN/A 1722292SN/A //MIPS obsolete instructions 1732292SN/A 0x2: bltzall({{ cond = (Rs.sq < 0); }}); 1742292SN/A 0x3: bgezall({{ cond = (Rs.sq >= 0); }}); 1752292SN/A } 1762301SN/A } 1772727Sktlim@umich.edu 1782353SN/A 0x3: decode REGIMM_LO { 1792727Sktlim@umich.edu format WarnUnimpl { 1802727Sktlim@umich.edu 0x7: synci({{ }}); 1812727Sktlim@umich.edu } 1826221Snate@binkert.org } 1832353SN/A } 1842727Sktlim@umich.edu 1852727Sktlim@umich.edu format Jump { 1862727Sktlim@umich.edu 0x2: j(); 1872727Sktlim@umich.edu 0x3: jal(IsCall); 1882353SN/A } 1892727Sktlim@umich.edu 1902727Sktlim@umich.edu format Branch { 1912727Sktlim@umich.edu 0x4: beq({{ cond = (Rs.sq == 0); }}); 1926221Snate@binkert.org 0x5: bne({{ cond = (Rs.sq != 0); }}); 1932301SN/A 0x6: blez({{ cond = (Rs.sq <= 0); }}); 1942301SN/A 0x7: bgtz({{ cond = (Rs.sq > 0); }}); 1952727Sktlim@umich.edu } 1962301SN/A }; 1972727Sktlim@umich.edu 1986221Snate@binkert.org 0x1: decode OPCODE_LO default FailUnimpl::reserved(){ 1992301SN/A format IntOp { 2002301SN/A 0x0: addi({{ Rt.sw = Rs.sw + INTIMM; }}); 2012727Sktlim@umich.edu 0x1: addiu({{ Rt.uw = Rs.uw + INTIMM;}}); 2022301SN/A 0x2: slti({{ Rt.sw = ( Rs.sw < INTIMM ) ? 1 : 0 }}); 2032727Sktlim@umich.edu 0x3: sltiu({{ Rt.uw = ( Rs.uw < INTIMM ) ? 1 : 0 }}); 2046221Snate@binkert.org 0x4: andi({{ Rt.sw = Rs.sw & INTIMM;}}); 2052301SN/A 0x5: ori({{ Rt.sw = Rs.sw | INTIMM;}}); 2062301SN/A 0x6: xori({{ Rt.sw = Rs.sw ^ INTIMM;}}); 2072727Sktlim@umich.edu 0x7: lui({{ Rt = INTIMM << 16}}); 2082301SN/A }; 2092727Sktlim@umich.edu }; 2106221Snate@binkert.org 2112301SN/A 0x2: decode OPCODE_LO default FailUnimpl::reserved(){ 2122301SN/A 2132727Sktlim@umich.edu //Table A-11 MIPS32 COP0 Encoding of rs Field 2142301SN/A 0x0: decode RS_MSB { 2152301SN/A 0x0: decode RS { 2162301SN/A 2172301SN/A format BasicOp { 2182727Sktlim@umich.edu 0x0: mfc0({{ 2192727Sktlim@umich.edu //The contents of the coprocessor 0 register specified by the 2202727Sktlim@umich.edu //combination of rd and sel are loaded into general register 2212727Sktlim@umich.edu //rt. Note that not all coprocessor 0 registers support the 2222727Sktlim@umich.edu //sel field. In those instances, the sel field must be zero. 2232727Sktlim@umich.edu 2242727Sktlim@umich.edu if (SEL > 0) 2252727Sktlim@umich.edu panic("Can't Handle Cop0 with register select yet\n"); 2262727Sktlim@umich.edu 2272301SN/A uint64_t reg_num = Rd.uw; 2282301SN/A 2296221Snate@binkert.org Rt = xc->miscRegs.cop0[reg_num]; 2302301SN/A }}); 2312301SN/A 2322727Sktlim@umich.edu 0xC: mtc0({{ 2332301SN/A //The contents of the coprocessor 0 register specified by the 2342326SN/A //combination of rd and sel are loaded into general register 2356221Snate@binkert.org //rt. Note that not all coprocessor 0 registers support the 2362301SN/A //sel field. In those instances, the sel field must be zero. 2372301SN/A 2382727Sktlim@umich.edu if (SEL > 0) 2392301SN/A panic("Can't Handle Cop0 with register select yet\n"); 2402326SN/A 2416221Snate@binkert.org uint64_t reg_num = Rd.uw; 2422301SN/A 2432301SN/A xc->miscRegs.cop0[reg_num] = Rt; 2442727Sktlim@umich.edu }}); 2452301SN/A 2462326SN/A 0xA: rdpgpr({{ 2476221Snate@binkert.org //Accessing Previous Shadow Set Register Number 2482301SN/A uint64_t prev = xc->miscRegs.cop0[SRSCtl][PSS]; 2492301SN/A uint64_t reg_num = Rt.uw; 2502727Sktlim@umich.edu 2512301SN/A Rd = xc->shadowIntRegFile[prev][reg_num]; 2522326SN/A }}); 2536221Snate@binkert.org } 2542301SN/A 2552301SN/A 0xB: decode SC { 2562727Sktlim@umich.edu format BasicOp { 2572301SN/A 0x0: di({{ 2582326SN/A //Accessing Coprocessor 0 "Status" Register 2592301SN/A Rt.sw = xc->miscRegs.cop0[12]; 2602301SN/A xc->miscRegs.cop0[12][INTERRUPT_ENABLE] = 0; 2612727Sktlim@umich.edu }}); 2622301SN/A 2632326SN/A 0x1: ei({{ 2642301SN/A //Accessing Coprocessor 0 "Status" Register 2652326SN/A Rt.sw = xc->miscRegs.cop0[12]; 2662301SN/A xc->miscRegs.cop0[12][INTERRUPT_ENABLE] = 1; 2672301SN/A }}); 2682727Sktlim@umich.edu } 2692301SN/A } 2702326SN/A 2712301SN/A 0xE: BasicOp::wrpgpr({{ 2722326SN/A //Accessing Previous Shadow Set Register Number 2732301SN/A uint64_t prev = xc->miscRegs.cop0[SRSCtl][PSS]; 2742301SN/A uint64_t reg_num = Rd.uw; 2752727Sktlim@umich.edu 2762326SN/A xc->shadowIntRegFile[prev][reg_num] = Rt; 2771062SN/A }}); 2781062SN/A } 2791681SN/A 2801060SN/A //Table A-12 MIPS32 COP0 Encoding of Function Field When rs=CO 2812292SN/A 0x1: decode FUNCTION { 2821060SN/A format Trap { 2836221Snate@binkert.org 0x01: tlbr({{ }}); 2842292SN/A 0x02: tlbwi({{ }}); 2852292SN/A 0x06: tlbwr({{ }}); 2862292SN/A 0x08: tlbp({{ }}); 2872292SN/A } 2882292SN/A 2892292SN/A format WarnUnimpl { 2902292SN/A 0x18: eret({{ }}); 2912292SN/A 0x1F: deret({{ }}); 2922292SN/A 0x20: wait({{ }}); 2932733Sktlim@umich.edu } 2941060SN/A } 2951060SN/A } 2961681SN/A 2971060SN/A //Table A-13 MIPS32 COP1 Encoding of rs Field 2982292SN/A 0x1: decode RS_MSB { 2991060SN/A 3001060SN/A 0x0: decode RS_HI { 3011060SN/A 0x0: decode RS_LO { 3021060SN/A format FloatOp { 3031060SN/A 0x0: mfc1({{ Rt = Fs<31:0>; }}); 3041060SN/A 0x2: cfc1({{ Rt = xc->miscRegs.fpcr[Fs];}}); 3051060SN/A 0x3: mfhc1({{ Rt = Fs<63:32>;}}); 3061060SN/A 0x4: mtc1({{ Fs<31:0> = Rt}}); 3071060SN/A 0x6: ctc1({{ xc->miscRegs.fpcr[Fs] = Rt;}}); 3082292SN/A 0x7: mftc1({{ Fs<63:32> = Rt}}); 3092292SN/A } 3101060SN/A } 3111060SN/A 3121060SN/A 0x1: decode ND { 3131060SN/A 0x0: decode TF { 3141681SN/A format Branch { 3151060SN/A 0x0: bc1f({{ cond = (xc->miscRegs.fpcr == 0); }}); 3162292SN/A 0x1: bc1t({{ cond = (xc->miscRegs.fpcr == 1); }}); 3171060SN/A } 3181060SN/A } 3191060SN/A 3201060SN/A 0x1: decode TF { 3211060SN/A format Branch { 3221060SN/A 0x0: bc1fl({{ cond = (xc->miscRegs.fpcr == 0); }}); 3231060SN/A 0x1: bc1tl({{ cond = (xc->miscRegs.fpcr == 1); }}); 3241681SN/A } 3251060SN/A } 3262292SN/A } 3271060SN/A } 3281060SN/A 3291060SN/A 0x1: decode RS_HI { 3301060SN/A 0x2: decode RS_LO { 3311060SN/A 3321060SN/A //Table A-14 MIPS32 COP1 Encoding of Function Field When rs=S 3331060SN/A //(( single-word )) 3341681SN/A 0x0: decode RS_HI { 3351060SN/A 0x0: decode RS_LO { 3366221Snate@binkert.org format FloatOp { 3371060SN/A 0x0: adds({{ Fd.sf = Fs.sf + Ft.sf;}}); 3382292SN/A 0x1: subs({{ Fd.sf = Fs.sf - Ft.sf;}}); 3392292SN/A 0x2: muls({{ Fd.sf = Fs.sf * Ft.sf;}}); 3402292SN/A 0x3: divs({{ Fd.sf = Fs.sf / Ft.sf;}}); 3412292SN/A 0x4: sqrts({{ Fd.sf = sqrt(Fs.sf);}}); 3421060SN/A 0x5: abss({{ Fd.sf = abs(Fs.sf);}}); 3431060SN/A 0x6: movs({{ Fd.sf = Fs.sf;}}); 3441681SN/A 0x7: negs({{ Fd.sf = -1 * Fs.sf;}}); 3451060SN/A } 3462292SN/A } 3471060SN/A 3482292SN/A 0x1: decode RS_LO { 3491060SN/A //only legal for 64 bit 3501060SN/A format Float64Op { 3512307SN/A 0x0: round_l_s({{ Fd = convert_and_round(Fs.sf,RND_NEAREST,FP_LONG,FP_SINGLE);}}); 3522863Sktlim@umich.edu 0x1: trunc_l_s({{ Fd = convert_and_round(Fs.sf,RND_ZERO,FP_LONG,FP_SINGLE);}}); 3532843Sktlim@umich.edu 0x2: ceil_l_s({{ Fd = convert_and_round(Fs.sf,RND_UP,FP_LONG,FP_SINGLE);}}); 3542307SN/A 0x3: floor_l_s({{ Fd = convert_and_round(Fs.sf,RND_DOWN,FP_LONG,FP_SINGLE);}}); 3552843Sktlim@umich.edu } 3562843Sktlim@umich.edu 3572863Sktlim@umich.edu format FloatOp { 3581681SN/A 0x4: round_w_s({{ Fd = convert_and_round(Fs.sf,RND_NEAREST,FP_WORD,FP_SINGLE);}}); 3591681SN/A 0x5: trunc_w_s({{ Fd = convert_and_round(Fs.sf,RND_ZERO,FP_WORD,FP_SINGLE);}}); 3602316SN/A 0x6: ceil_w_s({{ Fd = convert_and_round(Fs.sf,RND_UP,FP_WORD,FP_SINGLE);}}); 3611681SN/A 0x7: floor_w_s({{ Fd = convert_and_round(Fs.sf,RND_DOWN,FP_WORD,FP_SINGLE);}}); 3622843Sktlim@umich.edu } 3632843Sktlim@umich.edu } 3642843Sktlim@umich.edu 3652843Sktlim@umich.edu 0x2: decode RS_LO { 3662843Sktlim@umich.edu 0x1: decode MOVCF { 3672843Sktlim@umich.edu format FloatOp { 3682843Sktlim@umich.edu 0x0: movfs({{ if ( FPConditionCode(CC) == 0 ) Fd = Fs; }}); 3691681SN/A 0x1: movts({{ if ( FPConditionCode(CC) == 1 ) Fd = Fs;}}); 3702348SN/A } 3712307SN/A } 3722367SN/A 3732367SN/A format BasicOp { 3741681SN/A 0x2: movzs({{ if (Rt == 0) Fd = Fs; }}); 3752307SN/A 0x3: movns({{ if (Rt != 0) Fd = Fs; }}); 3762307SN/A } 3772307SN/A 3782307SN/A format Float64Op { 3796221Snate@binkert.org 0x2: recips({{ Fd = 1 / Fs; }}); 3806221Snate@binkert.org 0x3: rsqrts{{ Fd = 1 / sqrt(Fs); }}); 3816221Snate@binkert.org } 3826221Snate@binkert.org } 3836221Snate@binkert.org 3842307SN/A 0x4: decode RS_LO { 3851681SN/A 0x1: cvt_d_s({{ int rnd_mode = xc->miscRegs.fcsr; 3861681SN/A Fd = convert_and_round(Fs.sf,rnd_mode,FP_DOUBLE,FP_SINGLE); 3872307SN/A }}); 3881681SN/A 3892307SN/A 0x4: cvt_w_s({{ int rnd_mode = xc->miscRegs.fcsr; 3901060SN/A Fd = convert_and_round(Fs.sf,rnd_mode,FP_WORD,FP_SINGLE); 3912348SN/A }}); 3922307SN/A 3932307SN/A //only legal for 64 bit 3942307SN/A format Float64Op { 3952307SN/A 0x5: cvt_l_s({{ int rnd_mode = xc->miscRegs.fcsr; 3961060SN/A Fd = convert_and_round(Fs.sf,rnd_mode,FP_LONG,FP_SINGLE); 3972307SN/A }}); 3982307SN/A 3992307SN/A 0x6: cvt_ps_s({{ Fd.df = Fs.df<31:0> | Ft.df<31:0>; }}); 4001060SN/A } 4012307SN/A } 4022307SN/A } 4031060SN/A 4046221Snate@binkert.org //Table A-15 MIPS32 COP1 Encoding of Function Field When rs=D 4056221Snate@binkert.org 0x1: decode RS_HI { 4066221Snate@binkert.org 0x0: decode RS_LO { 4076221Snate@binkert.org format FloatOp { 4082307SN/A 0x0: addd({{ Fd.df = Fs.df + Ft.df;}}); 4091060SN/A 0x1: subd({{ Fd.df = Fs.df - Ft.df;}}); 4102307SN/A 0x2: muld({{ Fd.df = Fs.df * Ft.df;}}); 4112307SN/A 0x3: divd({{ Fd.df = Fs.df / Ft.df;}}); 4122873Sktlim@umich.edu 0x4: sqrtd({{ Fd.df = sqrt(Fs.df);}}); 4132307SN/A 0x5: absd({{ Fd.df = abs(Fs.df);}}); 4141060SN/A 0x6: movd({{ Fd.df = Fs.df;}}); 4151060SN/A 0x7: negd({{ Fd.df = -1 * Fs.df;}}); 4161060SN/A } 4171681SN/A } 4181060SN/A 4196221Snate@binkert.org 0x1: decode RS_LO { 4202107SN/A //only legal for 64 bit 4216221Snate@binkert.org format FloatOp64 { 4222107SN/A 0x0: round_l_d({{ Fd = convert_and_round(Fs.df,RND_NEAREST,FP_LONG,FP_DOUBLE); }}); 4232292SN/A 0x1: trunc_l_d({{ Fd = convert_and_round(Fs.df,RND_ZERO,FP_LONG,FP_DOUBLE);}}); 4242292SN/A 0x2: ceil_l_d({{ Fd = convert_and_round(Fs.df,RND_UP,FP_LONG,FP_DOUBLE);}}); 4252107SN/A 0x3: floor_l_d({{ Fd = convert_and_round(Fs.df,RND_DOWN,FP_LONG,FP_DOUBLE);}}); 4262292SN/A } 4272326SN/A 4282292SN/A format FloatOp { 4292107SN/A 0x4: round_w_d({{ Fd = convert_and_round(Fs.df,RND_NEAREST,FP_LONG,FP_DOUBLE); }}); 4302292SN/A 0x5: trunc_w_d({{ Fd = convert_and_round(Fs.df,RND_ZERO,FP_LONG,FP_DOUBLE); }}); 4312935Sksewell@umich.edu 0x6: ceil_w_d({{ Fd = convert_and_round(Fs.df,RND_UP,FP_LONG,FP_DOUBLE); }}); 4324632Sgblack@eecs.umich.edu 0x7: floor_w_d({{ Fd = convert_and_round(Fs.df,RND_DOWN,FP_LONG,FP_DOUBLE); }}); 4332935Sksewell@umich.edu } 4342292SN/A } 4352292SN/A 4362292SN/A 0x2: decode RS_LO { 4372292SN/A 0x1: decode MOVCF { 4382292SN/A format FloatOp { 4392107SN/A 0x0: movfd({{ if (FPConditionCode(CC) == 0) Fd.df = Fs.df; }}); 4402292SN/A 0x1: movtd({{ if (FPConditionCode(CC) == 1) Fd.df = Fs.df; }}); 4412107SN/A } 4422292SN/A } 4432292SN/A 4442107SN/A format BasicOp { 4452702Sktlim@umich.edu 0x2: movz({{ if (Rt == 0) Fd.df = Fs.df; }}); 4462107SN/A 0x3: movn({{ if (Rt != 0) Fd.df = Fs.df; }}); 4472107SN/A } 4482107SN/A 4492107SN/A format FloatOp64 { 4506221Snate@binkert.org 0x5: recipd({{ Fd.df = 1 / Fs.df}}); 4512292SN/A 0x6: rsqrtd{{ Fd.df = 1 / sqrt(Fs.df) }}); 4527720Sgblack@eecs.umich.edu } 4537720Sgblack@eecs.umich.edu } 4542292SN/A 4557852SMatt.Horsnell@arm.com 0x4: decode RS_LO { 4567852SMatt.Horsnell@arm.com format FloatOp { 4577852SMatt.Horsnell@arm.com 0x0: cvt_s_d({{ 4587852SMatt.Horsnell@arm.com int rnd_mode = xc->miscRegs.fcsr; 4597852SMatt.Horsnell@arm.com Fd = convert_and_round(Fs.df,rnd_mode,FP_SINGLE,FP_DOUBLE); 4607852SMatt.Horsnell@arm.com }}); 4617852SMatt.Horsnell@arm.com 4622935Sksewell@umich.edu 0x4: cvt_w_d({{ 4637852SMatt.Horsnell@arm.com int rnd_mode = xc->miscRegs.fcsr; 4647852SMatt.Horsnell@arm.com Fd = convert_and_round(Fs.df,rnd_mode,FP_WORD,FP_DOUBLE); 4652292SN/A }}); 4667852SMatt.Horsnell@arm.com } 4677852SMatt.Horsnell@arm.com 4687852SMatt.Horsnell@arm.com //only legal for 64 bit 4692292SN/A format FloatOp64 { 4707852SMatt.Horsnell@arm.com 0x5: cvt_l_d({{ 4717852SMatt.Horsnell@arm.com int rnd_mode = xc->miscRegs.fcsr; 4727852SMatt.Horsnell@arm.com Fd = convert_and_round(Fs.df,rnd_mode,FP_LONG,FP_DOUBLE); 4732292SN/A }}); 4742292SN/A } 4752292SN/A } 4762292SN/A } 4776221Snate@binkert.org 4782292SN/A //Table A-16 MIPS32 COP1 Encoding of Function Field When rs=W 4792292SN/A 0x4: decode FUNCTION { 4807720Sgblack@eecs.umich.edu format FloatOp { 4812292SN/A 0x10: cvt_s({{ 4827852SMatt.Horsnell@arm.com int rnd_mode = xc->miscRegs.fcsr; 4837852SMatt.Horsnell@arm.com Fd = convert_and_round(Fs.df,rnd_mode,FP_SINGLE,FP_WORD); 4847852SMatt.Horsnell@arm.com }}); 4857852SMatt.Horsnell@arm.com 4867852SMatt.Horsnell@arm.com 0x10: cvt_d({{ 4877852SMatt.Horsnell@arm.com int rnd_mode = xc->miscRegs.fcsr; 4887852SMatt.Horsnell@arm.com Fd = convert_and_round(Fs.df,rnd_mode,FP_DOUBLE,FP_WORD); 4897852SMatt.Horsnell@arm.com }}); 4902292SN/A } 4917852SMatt.Horsnell@arm.com } 4922292SN/A 4937852SMatt.Horsnell@arm.com //Table A-16 MIPS32 COP1 Encoding of Function Field When rs=L1 4947852SMatt.Horsnell@arm.com //Note: "1. Format type L is legal only if 64-bit floating point operations 4952292SN/A //are enabled." 4962292SN/A 0x5: decode FUNCTION_HI { 4972292SN/A format FloatOp { 4982292SN/A 0x10: cvt_s_l({{ 4996221Snate@binkert.org int rnd_mode = xc->miscRegs.fcsr; 5002292SN/A Fd = convert_and_round(Fs.df,rnd_mode,FP_SINGLE,FP_LONG); 5012292SN/A }}); 5027720Sgblack@eecs.umich.edu 5037852SMatt.Horsnell@arm.com 0x11: cvt_d_l({{ 5047852SMatt.Horsnell@arm.com int rnd_mode = xc->miscRegs.fcsr; 5057852SMatt.Horsnell@arm.com Fd = convert_and_round(Fs.df,rnd_mode,FP_DOUBLE,FP_LONG); 5062292SN/A }}); 5077852SMatt.Horsnell@arm.com } 5087852SMatt.Horsnell@arm.com } 5097852SMatt.Horsnell@arm.com 5102292SN/A //Table A-17 MIPS64 COP1 Encoding of Function Field When rs=PS1 5117852SMatt.Horsnell@arm.com //Note: "1. Format type PS is legal only if 64-bit floating point operations 5127852SMatt.Horsnell@arm.com //are enabled. " 5132292SN/A 0x6: decode RS_HI { 5147852SMatt.Horsnell@arm.com 0x0: decode RS_LO { 5152292SN/A format FloatOp64 { 5167852SMatt.Horsnell@arm.com 0x0: addps({{ //Must Check for Exception Here... Supposed to Operate on Upper and 5177852SMatt.Horsnell@arm.com //Lower Halves Independently but we take simulator shortcut 5182292SN/A Fd.df = Fs.df + Ft.df; 5192292SN/A }}); 5202292SN/A 5212292SN/A 0x1: subps({{ //Must Check for Exception Here... Supposed to Operate on Upper and 5226221Snate@binkert.org //Lower Halves Independently but we take simulator shortcut 5232292SN/A Fd.df = Fs.df - Ft.df; 5242292SN/A }}); 5252292SN/A 5262292SN/A 0x2: mulps({{ //Must Check for Exception Here... Supposed to Operate on Upper and 5272292SN/A //Lower Halves Independently but we take simulator shortcut 5282292SN/A Fd.df = Fs.df * Ft.df; 5292292SN/A }}); 5302292SN/A 5312292SN/A 0x5: absps({{ //Must Check for Exception Here... Supposed to Operate on Upper and 5322292SN/A //Lower Halves Independently but we take simulator shortcut 5332292SN/A Fd.df = abs(Fs.df); 5342292SN/A }}); 5352292SN/A 5362292SN/A 0x6: movps({{ //Must Check for Exception Here... Supposed to Operate on Upper and 5372292SN/A //Lower Halves Independently but we take simulator shortcut 5382292SN/A Fd.df = Fs<31:0> | Ft<31:0>; 5392292SN/A }}); 5402292SN/A 5416221Snate@binkert.org 0x7: negps({{ //Must Check for Exception Here... Supposed to Operate on Upper and 5422292SN/A //Lower Halves Independently but we take simulator shortcut 5432292SN/A Fd.df = -1 * Fs.df; 5442292SN/A }}); 5452292SN/A } 5462292SN/A } 5472292SN/A 5482292SN/A 0x2: decode RS_LO { 5492292SN/A 0x1: decode MOVCF { 5502292SN/A format FloatOp64 { 5512292SN/A 0x0: movfps({{ if ( FPConditionCode(CC) == 0) Fd = Fs;}}) 5522292SN/A 0x1: movtps({{ if ( FPConditionCode(CC) == 0) Fd = Fs;}}) 5532292SN/A } 5542292SN/A } 5552292SN/A 5562292SN/A } 5572292SN/A 5582292SN/A 0x4: decode RS_LO { 5591060SN/A 0x0: FloatOp64::cvt_s_pu({{ 5601681SN/A int rnd_mode = xc->miscRegs.fcsr; 5611060SN/A Fd = convert_and_round(Fs.df,rnd_mode,FP_DOUBLE,FP_PS_HI); 5621060SN/A }}); 5632292SN/A } 5642292SN/A 5652292SN/A 0x5: decode RS_LO { 5662292SN/A format FloatOp64 { 5672292SN/A 0x0: cvt_s_pl({{ 5682292SN/A int rnd_mode = xc->miscRegs.fcsr; 5691681SN/A Fd = convert_and_round(Fs.df,rnd_mode,FP_SINGLE,FP_PS_LO); 5701681SN/A }}); 5711060SN/A 0x4: pll({{ Fd.df = Fs<31:0> | Ft<31:0>}}); 5722292SN/A 0x5: plu({{ Fd.df = Fs<31:0> | Ft<63:32>}}); 5731060SN/A 0x6: pul({{ Fd.df = Fs<63:32> | Ft<31:0>}}); 5742292SN/A 0x7: puu({{ Fd.df = Fs<63:32 | Ft<63:32>}}); 5752292SN/A } 5761060SN/A } 5772292SN/A } 5782292SN/A } 5792292SN/A 5802292SN/A //Table A-19 MIPS32 COP2 Encoding of rs Field 5813221Sktlim@umich.edu 0x2: decode RS_MSB { 5823221Sktlim@umich.edu 0x0: decode RS_HI { 5833221Sktlim@umich.edu 0x0: decode RS_LO { 5843221Sktlim@umich.edu format WarnUnimpl { 5853221Sktlim@umich.edu 0x0: mfc2({{ }}); 5862292SN/A 0x2: cfc2({{ }}); 5872292SN/A 0x3: mfhc2({{ }}); 5882292SN/A 0x4: mtc2({{ }}); 5892292SN/A 0x6: ctc2({{ }}); 5902326SN/A 0x7: mftc2({{ }}); 5912292SN/A } 5922292SN/A } 5932820Sktlim@umich.edu 5942292SN/A 0x1: decode ND { 5952292SN/A 0x0: decode TF { 5962292SN/A format WarnUnimpl { 5972292SN/A 0x0: bc2f({{ cond = (xc->miscRegs.cop2cc == 0); }}, COP2); 5982353SN/A 0x1: bc2t({{ cond = (xc->miscRegs.cop2cc == 1); }}, COP2}}); 5992292SN/A } 6002292SN/A } 6012353SN/A 6022353SN/A 0x1: decode TF { 6032292SN/A format WarnUnimpl { 6042292SN/A 0x0: bc2fl({{ cond = (xc->miscRegs.cop2cc == 0); }}, COP2}}); 6052292SN/A 0x1: bc2tl({{ cond = (xc->miscRegs.cop2cc == 1); }}, COP2}}); 6062292SN/A } 6072292SN/A } 6082292SN/A } 6092292SN/A } 6102292SN/A } 6112292SN/A 6122292SN/A //Table A-20 MIPS64 COP1X Encoding of Function Field 1 6132292SN/A //Note: "COP1X instructions are legal only if 64-bit floating point 6142292SN/A //operations are enabled." 6152731Sktlim@umich.edu 0x3: decode FUNCTION_HI { 6162292SN/A 0x0: decode FUNCTION_LO { 6172292SN/A format Memory { 6182292SN/A 0x0: lwxc1({{ EA = Rs + Rt; }},{{ Ft<31:0> = Mem.uf; }}); 6192292SN/A 0x1: ldxc1({{ EA = Rs + Rt; }},{{ Ft<63:0> = Mem.df; }}); 6202292SN/A 0x5: luxc1({{ //Need to make EA<2:0> = 0 6212292SN/A EA = Rs + Rt; 6222292SN/A }}, 6232292SN/A {{ Ft<31:0> = Mem.df; }}); 6246221Snate@binkert.org } 6252292SN/A } 6262292SN/A 6272292SN/A 0x1: decode FUNCTION_LO { 6282292SN/A format Memory { 6292292SN/A 0x0: swxc1({{ EA = Rs + Rt; }},{{ Mem.uf = Ft<31:0>; }}); 6302292SN/A 0x1: sdxc1({{ EA = Rs + Rt; }},{{ Mem.uf = Ft<63:0>}}); 6312292SN/A 0x5: suxc1({{ //Need to make EA<2:0> = 0 6322292SN/A EA = Rs + Rt; 6337720Sgblack@eecs.umich.edu }}, 6342292SN/A {{ Mem.df = Ft<63:0>;}}); 6357720Sgblack@eecs.umich.edu 0x7: prefx({{ }}); 6362292SN/A } 6372292SN/A } 6382292SN/A 6392292SN/A format FloatOp { 6402292SN/A 0x3: WarnUnimpl::alnv_ps({{ }}); 6412292SN/A 6422292SN/A format BasicOp { 6432292SN/A 0x4: decode FUNCTION_LO { 6442292SN/A 0x0: madd_s({{ Fd.sf = (Fs.sf * Fs.sf) + Fr.sf; }}); 6452292SN/A 0x1: madd_d({{ Fd.df = (Fs.df * Fs.df) + Fr.df; }}); 6462292SN/A 0x6: madd_ps({{ 6472292SN/A //Must Check for Exception Here... Supposed to Operate on Upper and 6482292SN/A //Lower Halves Independently but we take simulator shortcut 6492292SN/A Fd.df = (Fs.df * Fs.df) + Fr.df; 6506221Snate@binkert.org }}); 6516221Snate@binkert.org } 6522292SN/A 6533867Sbinkertn@umich.edu 0x5: decode FUNCTION_LO { 6546221Snate@binkert.org 0x0: msub_s({{ Fd.sf = (Fs.sf * Fs.sf) - Fr.sf; }}); 6553867Sbinkertn@umich.edu 0x1: msub_d({{ Fd.df = (Fs.df * Fs.df) - Fr.df; }}); 6562292SN/A 0x6: msub_ps({{ 6572292SN/A //Must Check for Exception Here... Supposed to Operate on Upper and 6582292SN/A //Lower Halves Independently but we take simulator shortcut 6592292SN/A Fd.df = (Fs.df * Fs.df) - Fr.df; 6602292SN/A }}); 6612292SN/A } 6622292SN/A 6632292SN/A 0x6: decode FUNCTION_LO { 6642292SN/A 0x0: nmadd_s({{ Fd.sf = (-1 * Fs.sf * Fs.sf) - Fr.sf; }}); 6652292SN/A 0x1: nmadd_d({{ Fd.df = (-1 * Fs.df * Fs.df) + Fr.df; }}); 6662292SN/A 0x6: nmadd_ps({{ 6676221Snate@binkert.org //Must Check for Exception Here... Supposed to Operate on Upper and 6686221Snate@binkert.org //Lower Halves Independently but we take simulator shortcut 6692292SN/A Fd.df = (-1 * Fs.df * Fs.df) + Fr.df; 6703867Sbinkertn@umich.edu }}); 6716221Snate@binkert.org } 6723867Sbinkertn@umich.edu 6733867Sbinkertn@umich.edu 0x7: decode FUNCTION_LO { 6742292SN/A 0x0: nmsub_s({{ Fd.sf = (-1 * Fs.sf * Fs.sf) - Fr.sf; }}); 6752292SN/A 0x1: nmsub_d({{ Fd.df = (-1 * Fs.df * Fs.df) - Fr.df; }}); 6762292SN/A 0x6: nmsub_ps({{ 6772292SN/A //Must Check for Exception Here... Supposed to Operate on Upper and 6781062SN/A //Lower Halves Independently but we take simulator shortcut 6791062SN/A Fd.df = (-1 * Fs.df * Fs.df) + Fr.df; 6801681SN/A }}); 6811062SN/A } 6822292SN/A } 6831062SN/A } 6842292SN/A } 6851062SN/A 6866221Snate@binkert.org //MIPS obsolete instructions 6876221Snate@binkert.org format Branch { 6881062SN/A 0x4: beql({{ cond = (Rs.sq == 0); }}); 6893867Sbinkertn@umich.edu 0x5: bnel({{ cond = (Rs.sq != 0); }}); 6906221Snate@binkert.org 0x6: blezl({{ cond = (Rs.sq <= 0); }}); 6911062SN/A 0x7: bgtzl({{ cond = (Rs.sq > 0); }}); 6922292SN/A } 6932292SN/A }; 6942292SN/A 6952292SN/A 0x3: decode OPCODE_LO default FailUnimpl::reserved() { 6962292SN/A 6971062SN/A //Table A-5 MIPS32 SPECIAL2 Encoding of Function Field 6982292SN/A 0x4: decode FUNCTION_HI { 6992292SN/A 7002292SN/A 0x0: decode FUNCTION_LO { 7017897Shestness@cs.utexas.edu format IntOp { 7022292SN/A 0x0: madd({{ 7032292SN/A INT64 temp1 = Hi.sw << 32 | Lo.sw >> 32; 7042292SN/A temp1 = temp1 + (Rs.sw * Rt.sw); 7051062SN/A xc->miscRegs.hi->temp1<63:32>; 7062292SN/A xc->miscRegs.lo->temp1<31:0> 7071062SN/A }}); 7082292SN/A 7092292SN/A 0x1: maddu({{ 7102292SN/A INT64 temp1 = Hi.uw << 32 | Lo.uw >> 32; 7112292SN/A temp1 = temp1 + (Rs.uw * Rt.uw); 7122292SN/A xc->miscRegs.hi->temp1<63:32>; 7132292SN/A xc->miscRegs.lo->temp1<31:0> 7141062SN/A }}); 7152292SN/A 7161062SN/A 0x2: mul({{ Rd.sw = Rs.sw * Rt.sw; }}); 7172292SN/A 7181062SN/A 0x4: msub({{ 7191062SN/A INT64 temp1 = Hi.sw << 32 | Lo.sw >> 32; 7201062SN/A temp1 = temp1 - (Rs.sw * Rt.sw); 7211681SN/A xc->miscRegs.hi->temp1<63:32>; 7221062SN/A xc->miscRegs.lo->temp1<31:0> 7232292SN/A }}); 7241062SN/A 7252292SN/A 0x5: msubu({{ 7262292SN/A INT64 temp1 = Hi.uw << 32 | Lo.uw >> 32; 7272292SN/A temp1 = temp1 - (Rs.uw * Rt.uw); 7281062SN/A xc->miscRegs.hi->temp1<63:32>; 7292292SN/A xc->miscRegs.lo->temp1<31:0> 7302292SN/A }}); 7316221Snate@binkert.org } 7322292SN/A } 7332292SN/A 7342292SN/A 0x4: decode FUNCTION_LO { 7352292SN/A format BasicOp { 7361062SN/A 0x0: clz({{ 7372292SN/A int cnt = 0; 7382292SN/A int idx = 0; 7392292SN/A while ( Rs.uw<idx>!= 1) { 7402292SN/A cnt++; 7412292SN/A idx--; 7422292SN/A } 7432292SN/A 7442292SN/A Rd.uw = cnt; 7456221Snate@binkert.org }}); 7462292SN/A 7472292SN/A 0x1: clo({{ 7482292SN/A int cnt = 0; 7492292SN/A int idx = 0; 7502292SN/A while ( Rs.uw<idx>!= 0) { 7512292SN/A cnt++; 7522292SN/A idx--; 7532292SN/A } 7542292SN/A 7552292SN/A Rd.uw = cnt; 7562292SN/A }}); 7572292SN/A } 7582292SN/A } 7592292SN/A 7602292SN/A 0x7: decode FUNCTION_LO { 7612292SN/A 0x7: WarnUnimpl::sdbbp({{ }}); 7622292SN/A } 7632292SN/A } 7642292SN/A 7652292SN/A //Table A-6 MIPS32 SPECIAL3 Encoding of Function Field for Release 2 of the Architecture 7662292SN/A 0x7: decode FUNCTION_HI { 7672292SN/A 7682292SN/A 0x0: decode FUNCTION_LO { 7692292SN/A format WarnUnimpl { 7702292SN/A 0x1: ext({{ }}); 7712292SN/A 0x4: ins({{ }}); 7722292SN/A } 7732292SN/A } 7742292SN/A 7752292SN/A //Table A-10 MIPS32 BSHFL Encoding of sa Field 7762292SN/A 0x4: decode SA { 7772292SN/A 7782292SN/A 0x02: WarnUnimpl::wsbh({{ }}); 7792292SN/A 7802292SN/A format BasicOp { 7816221Snate@binkert.org 0x10: seb({{ Rd.sw = /* sext32(Rt<7>,24) | */ Rt<7:0>}}); 7822292SN/A 0x18: seh({{ Rd.sw = /* sext32(Rt<15>,16) | */ Rt<15:0>}}); 7832292SN/A } 7842292SN/A } 7852292SN/A 7862292SN/A 0x6: decode FUNCTION_LO { 7872292SN/A 0x7: BasicOp::rdhwr({{ Rt = xc->hwRegs[RD];}}); 7882292SN/A } 7892292SN/A } 7902292SN/A }; 7912292SN/A 7922292SN/A 0x4: decode OPCODE_LO default FailUnimpl::reserved() { 7932292SN/A format Memory { 7942292SN/A 0x0: lb({{ EA = Rs + disp; }}, {{ Rb.sw = Mem.sb; }}); 7952292SN/A 0x1: lh({{ EA = Rs + disp; }}, {{ Rb.sw = Mem.sh; }}); 7962292SN/A 0x2: lwl({{ EA = Rs + disp; }}, {{ Rb.sw = Mem.sw; }}, WordAlign); 7972292SN/A 0x3: lw({{ EA = Rs + disp; }}, {{ Rb.uq = Mem.sb; }}); 7982292SN/A 0x4: lbu({{ EA = Rs + disp; }}, {{ Rb.uw = Mem.ub; }}); 7992292SN/A 0x5: lhu({{ EA = Rs + disp; }}, {{ Rb.uw = Mem.uh; }}); 8002292SN/A 0x6: lwr({{ EA = Rs + disp; }}, {{ Rb.uw = Mem.uw; }}, WordAlign); 8012292SN/A }; 8022292SN/A 8032292SN/A 0x7: FailUnimpl::reserved({{ }}); 8042292SN/A }; 8052292SN/A 8062292SN/A 0x5: decode OPCODE_LO default FailUnimpl::reserved() { 8072702Sktlim@umich.edu format Memory { 8082292SN/A 0x0: sb({{ EA = Rs + disp; }}, {{ Mem.ub = Rt<7:0>; }}); 8092292SN/A 0x1: sh({{ EA = Rs + disp; }},{{ Mem.uh = Rt<15:0>; }}); 8102702Sktlim@umich.edu 0x2: swl({{ EA = Rs + disp; }},{{ Mem.ub = Rt<31:0>; }},WordAlign); 8112702Sktlim@umich.edu 0x3: sw({{ EA = Rs + disp; }},{{ Mem.ub = Rt<31:0>; }}); 8122292SN/A 0x6: swr({{ EA = Rs + disp; }},{{ Mem.ub = Rt<31:0>; }},WordAlign); 8132292SN/A }; 8142292SN/A 8152292SN/A format WarnUnimpl { 8162292SN/A 0x7: cache({{ }}); 8172292SN/A }; 8182292SN/A 8192292SN/A }; 8202292SN/A 8212292SN/A 0x6: decode OPCODE_LO default FailUnimpl::reserved() { 8222292SN/A 0x0: WarnUnimpl::ll({{ }}); 8232292SN/A 8242292SN/A format Memory { 8252292SN/A 0x1: lwc1({{ EA = Rs + disp; }},{{ Ft<31:0> = Mem.uf; }}); 8262292SN/A 0x5: ldc1({{ EA = Rs + disp; }},{{ Ft<63:0> = Mem.df; }}); 8272292SN/A }; 8282292SN/A }; 8292292SN/A 8302292SN/A 0x7: decode OPCODE_LO default FailUnimpl::reserved() { 8312292SN/A 0x0: WarnUnimpl::sc({{ }}); 8322292SN/A 8332292SN/A format Memory { 8342292SN/A 0x1: swc1({{ EA = Rs + disp; }},{{ Mem.uf = Ft<31:0>; }}); 8352292SN/A 0x5: sdc1({{ EA = Rs + disp; }},{{ Mem.df = Ft<63:0>; }}); 8362292SN/A }; 8372292SN/A 8382292SN/A } 8392292SN/A} 8402292SN/A 8412292SN/A 8422292SN/A