Lines Matching refs:mnemonic
1210 // Depending on the instruction mnemonic, certain bits may be or-ed into
1240 // Depending on the instruction mnemonic, certain bits may be or-ed into
1299 // Depending on the instruction mnemonic, certain bits may be or-ed into
1874 // MI operand, but writes out an extended mnemonic for better readability.
1877 // - Specific patterns for each extended mnemonic, where the condition mask
1881 // assembler parser is not able to decode part of an instruction mnemonic
1882 // into an operand. Thus we provide separate patterns for each mnemonic.
1902 // The suffix to use for the extended assembler mnemonic.
2114 class InherentRRE<string mnemonic, bits<16> opcode, RegisterOperand cls,
2117 mnemonic#"\t$R1",
2122 class InherentDualRRE<string mnemonic, bits<16> opcode, RegisterOperand cls>
2124 mnemonic#"\t$R1, $R2", []>;
2126 class InherentVRIa<string mnemonic, bits<16> opcode, bits<16> value>
2127 : InstVRIa<opcode, (outs VR128:$V1), (ins), mnemonic#"\t$V1", []> {
2132 class StoreInherentS<string mnemonic, bits<16> opcode,
2135 mnemonic#"\t$BD2", [(operator bdaddr12only:$BD2)]> {
2140 class SideEffectInherentE<string mnemonic, bits<16>opcode>
2141 : InstE<opcode, (outs), (ins), mnemonic, []>;
2143 class SideEffectInherentS<string mnemonic, bits<16> opcode,
2145 : InstS<opcode, (outs), (ins), mnemonic, [(operator)]> {
2149 class SideEffectInherentRRE<string mnemonic, bits<16> opcode>
2150 : InstRRE<opcode, (outs), (ins), mnemonic, []> {
2156 class CallRI<string mnemonic, bits<12> opcode>
2158 mnemonic#"\t$R1, $RI2", []>;
2161 class CallRIL<string mnemonic, bits<12> opcode>
2163 mnemonic#"\t$R1, $RI2", []>;
2165 class CallRR<string mnemonic, bits<8> opcode>
2167 mnemonic#"\t$R1, $R2", []>;
2169 class CallRX<string mnemonic, bits<8> opcode>
2171 mnemonic#"\t$R1, $XBD2", []>;
2173 class CondBranchRI<string mnemonic, bits<12> opcode,
2176 !subst("#", "${M1}", mnemonic)#"\t$RI2",
2181 class AsmCondBranchRI<string mnemonic, bits<12> opcode>
2183 mnemonic#"\t$M1, $RI2", []>;
2185 class FixedCondBranchRI<CondVariant V, string mnemonic, bits<12> opcode,
2188 !subst("#", V.suffix, mnemonic)#"\t$RI2", [(operator bb:$RI2)]> {
2194 class CondBranchRIL<string mnemonic, bits<12> opcode>
2196 !subst("#", "${M1}", mnemonic)#"\t$RI2", []> {
2200 class AsmCondBranchRIL<string mnemonic, bits<12> opcode>
2202 mnemonic#"\t$M1, $RI2", []>;
2204 class FixedCondBranchRIL<CondVariant V, string mnemonic, bits<12> opcode>
2206 !subst("#", V.suffix, mnemonic)#"\t$RI2", []> {
2212 class CondBranchRR<string mnemonic, bits<8> opcode>
2214 !subst("#", "${R1}", mnemonic)#"\t$R2", []> {
2218 class AsmCondBranchRR<string mnemonic, bits<8> opcode>
2220 mnemonic#"\t$R1, $R2", []>;
2222 class FixedCondBranchRR<CondVariant V, string mnemonic, bits<8> opcode,
2225 !subst("#", V.suffix, mnemonic)#"\t$R2", [(operator ADDR64:$R2)]> {
2231 class CondBranchRX<string mnemonic, bits<8> opcode>
2233 !subst("#", "${M1}", mnemonic)#"\t$XBD2", []> {
2237 class AsmCondBranchRX<string mnemonic, bits<8> opcode>
2239 mnemonic#"\t$M1, $XBD2", []>;
2241 class FixedCondBranchRX<CondVariant V, string mnemonic, bits<8> opcode>
2243 !subst("#", V.suffix, mnemonic)#"\t$XBD2", []> {
2249 class CondBranchRXY<string mnemonic, bits<16> opcode>
2251 !subst("#", "${M1}", mnemonic)#"\t$XBD2", []> {
2256 class AsmCondBranchRXY<string mnemonic, bits<16> opcode>
2258 mnemonic#"\t$M1, $XBD2", []> {
2262 class FixedCondBranchRXY<CondVariant V, string mnemonic, bits<16> opcode,
2265 !subst("#", V.suffix, mnemonic)#"\t$XBD2",
2273 class CmpBranchRIEa<string mnemonic, bits<16> opcode,
2276 mnemonic#"$M3\t$R1, $I2", []>;
2278 class AsmCmpBranchRIEa<string mnemonic, bits<16> opcode,
2281 mnemonic#"\t$R1, $I2, $M3", []>;
2283 class FixedCmpBranchRIEa<CondVariant V, string mnemonic, bits<16> opcode,
2286 mnemonic#V.suffix#"\t$R1, $I2", []> {
2292 multiclass CmpBranchRIEaPair<string mnemonic, bits<16> opcode,
2295 def "" : CmpBranchRIEa<mnemonic, opcode, cls, imm>;
2296 def Asm : AsmCmpBranchRIEa<mnemonic, opcode, cls, imm>;
2299 class CmpBranchRIEb<string mnemonic, bits<16> opcode,
2303 mnemonic#"$M3\t$R1, $R2, $RI4", []>;
2305 class AsmCmpBranchRIEb<string mnemonic, bits<16> opcode,
2309 mnemonic#"\t$R1, $R2, $M3, $RI4", []>;
2311 class FixedCmpBranchRIEb<CondVariant V, string mnemonic, bits<16> opcode,
2314 mnemonic#V.suffix#"\t$R1, $R2, $RI4", []> {
2320 multiclass CmpBranchRIEbPair<string mnemonic, bits<16> opcode,
2323 def "" : CmpBranchRIEb<mnemonic, opcode, cls>;
2324 def Asm : AsmCmpBranchRIEb<mnemonic, opcode, cls>;
2327 class CmpBranchRIEc<string mnemonic, bits<16> opcode,
2331 mnemonic#"$M3\t$R1, $I2, $RI4", []>;
2333 class AsmCmpBranchRIEc<string mnemonic, bits<16> opcode,
2337 mnemonic#"\t$R1, $I2, $M3, $RI4", []>;
2339 class FixedCmpBranchRIEc<CondVariant V, string mnemonic, bits<16> opcode,
2342 mnemonic#V.suffix#"\t$R1, $I2, $RI4", []> {
2348 multiclass CmpBranchRIEcPair<string mnemonic, bits<16> opcode,
2351 def "" : CmpBranchRIEc<mnemonic, opcode, cls, imm>;
2352 def Asm : AsmCmpBranchRIEc<mnemonic, opcode, cls, imm>;
2355 class CmpBranchRRFc<string mnemonic, bits<16> opcode,
2358 mnemonic#"$M3\t$R1, $R2", []>;
2360 class AsmCmpBranchRRFc<string mnemonic, bits<16> opcode,
2363 mnemonic#"\t$R1, $R2, $M3", []>;
2365 multiclass CmpBranchRRFcPair<string mnemonic, bits<16> opcode,
2368 def "" : CmpBranchRRFc<mnemonic, opcode, cls>;
2369 def Asm : AsmCmpBranchRRFc<mnemonic, opcode, cls>;
2372 class FixedCmpBranchRRFc<CondVariant V, string mnemonic, bits<16> opcode,
2375 mnemonic#V.suffix#"\t$R1, $R2", []> {
2381 class CmpBranchRRS<string mnemonic, bits<16> opcode,
2385 mnemonic#"$M3\t$R1, $R2, $BD4", []>;
2387 class AsmCmpBranchRRS<string mnemonic, bits<16> opcode,
2391 mnemonic#"\t$R1, $R2, $M3, $BD4", []>;
2393 class FixedCmpBranchRRS<CondVariant V, string mnemonic, bits<16> opcode,
2396 mnemonic#V.suffix#"\t$R1, $R2, $BD4", []> {
2402 multiclass CmpBranchRRSPair<string mnemonic, bits<16> opcode,
2405 def "" : CmpBranchRRS<mnemonic, opcode, cls>;
2406 def Asm : AsmCmpBranchRRS<mnemonic, opcode, cls>;
2409 class CmpBranchRIS<string mnemonic, bits<16> opcode,
2413 mnemonic#"$M3\t$R1, $I2, $BD4", []>;
2415 class AsmCmpBranchRIS<string mnemonic, bits<16> opcode,
2419 mnemonic#"\t$R1, $I2, $M3, $BD4", []>;
2421 class FixedCmpBranchRIS<CondVariant V, string mnemonic, bits<16> opcode,
2424 mnemonic#V.suffix#"\t$R1, $I2, $BD4", []> {
2430 multiclass CmpBranchRISPair<string mnemonic, bits<16> opcode,
2433 def "" : CmpBranchRIS<mnemonic, opcode, cls, imm>;
2434 def Asm : AsmCmpBranchRIS<mnemonic, opcode, cls, imm>;
2437 class CmpBranchRSYb<string mnemonic, bits<16> opcode,
2440 mnemonic#"$M3\t$R1, $BD2", []>;
2442 class AsmCmpBranchRSYb<string mnemonic, bits<16> opcode,
2445 mnemonic#"\t$R1, $M3, $BD2", []>;
2447 multiclass CmpBranchRSYbPair<string mnemonic, bits<16> opcode,
2450 def "" : CmpBranchRSYb<mnemonic, opcode, cls>;
2451 def Asm : AsmCmpBranchRSYb<mnemonic, opcode, cls>;
2454 class FixedCmpBranchRSYb<CondVariant V, string mnemonic, bits<16> opcode,
2457 mnemonic#V.suffix#"\t$R1, $BD2", []> {
2463 class BranchUnaryRI<string mnemonic, bits<12> opcode, RegisterOperand cls>
2465 mnemonic#"\t$R1, $RI2", []> {
2470 class BranchUnaryRIL<string mnemonic, bits<12> opcode, RegisterOperand cls>
2472 mnemonic#"\t$R1, $RI2", []> {
2477 class BranchUnaryRR<string mnemonic, bits<8> opcode, RegisterOperand cls>
2479 mnemonic#"\t$R1, $R2", []> {
2484 class BranchUnaryRRE<string mnemonic, bits<16> opcode, RegisterOperand cls>
2486 mnemonic#"\t$R1, $R2", []> {
2491 class BranchUnaryRX<string mnemonic, bits<8> opcode, RegisterOperand cls>
2493 mnemonic#"\t$R1, $XBD2", []> {
2498 class BranchUnaryRXY<string mnemonic, bits<16> opcode, RegisterOperand cls>
2500 mnemonic#"\t$R1, $XBD2", []> {
2505 class BranchBinaryRSI<string mnemonic, bits<8> opcode, RegisterOperand cls>
2507 mnemonic#"\t$R1, $R3, $RI2", []> {
2512 class BranchBinaryRIEe<string mnemonic, bits<16> opcode, RegisterOperand cls>
2515 mnemonic#"\t$R1, $R3, $RI2", []> {
2520 class BranchBinaryRS<string mnemonic, bits<8> opcode, RegisterOperand cls>
2523 mnemonic#"\t$R1, $R3, $BD2", []> {
2528 class BranchBinaryRSY<string mnemonic, bits<16> opcode, RegisterOperand cls>
2531 mnemonic#"\t$R1, $R3, $BD2", []> {
2536 class LoadMultipleRS<string mnemonic, bits<8> opcode, RegisterOperand cls,
2539 mnemonic#"\t$R1, $R3, $BD2", []> {
2543 class LoadMultipleRSY<string mnemonic, bits<16> opcode, RegisterOperand cls,
2546 mnemonic#"\t$R1, $R3, $BD2", []> {
2550 multiclass LoadMultipleRSPair<string mnemonic, bits<8> rsOpcode,
2552 let DispKey = mnemonic # cls in {
2554 def "" : LoadMultipleRS<mnemonic, rsOpcode, cls, bdaddr12pair>;
2556 def Y : LoadMultipleRSY<mnemonic#"y", rsyOpcode, cls, bdaddr20pair>;
2560 class LoadMultipleSSe<string mnemonic, bits<8> opcode, RegisterOperand cls>
2563 mnemonic#"\t$R1, $R3, $BD2, $BD4", []> {
2567 multiclass LoadMultipleVRSaAlign<string mnemonic, bits<16> opcode> {
2571 mnemonic#"\t$V1, $V3, $BD2, $M4", []>;
2575 mnemonic#"\t$V1, $V3, $BD2", []>;
2579 class StoreRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
2582 mnemonic#"\t$R1, $RI2",
2591 class StoreRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
2595 mnemonic#"\t$R1, $XBD2",
2597 let OpKey = mnemonic#"r"#cls;
2603 class StoreRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
2607 mnemonic#"\t$R1, $XBD2",
2609 let OpKey = mnemonic#"r"#cls;
2615 multiclass StoreRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
2618 let DispKey = mnemonic # cls in {
2620 def "" : StoreRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
2622 def Y : StoreRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
2627 class StoreVRX<string mnemonic, bits<16> opcode, SDPatternOperator operator,
2630 mnemonic#"\t$V1, $XBD2",
2637 class StoreVRXGeneric<string mnemonic, bits<16> opcode>
2639 mnemonic#"\t$V1, $XBD2, $M3", []> {
2643 multiclass StoreVRXAlign<string mnemonic, bits<16> opcode> {
2647 mnemonic#"\t$V1, $XBD2, $M3", []>;
2650 mnemonic#"\t$V1, $XBD2", []>;
2654 class StoreLengthVRSb<string mnemonic, bits<16> opcode,
2657 mnemonic#"\t$V1, $R3, $BD2",
2664 class StoreLengthVRSd<string mnemonic, bits<16> opcode,
2667 mnemonic#"\t$V1, $R3, $BD2",
2673 class StoreLengthVSI<string mnemonic, bits<16> opcode,
2676 mnemonic#"\t$V1, $BD2, $I3",
2682 class StoreMultipleRS<string mnemonic, bits<8> opcode, RegisterOperand cls,
2685 mnemonic#"\t$R1, $R3, $BD2", []> {
2689 class StoreMultipleRSY<string mnemonic, bits<16> opcode, RegisterOperand cls,
2692 mnemonic#"\t$R1, $R3, $BD2", []> {
2696 multiclass StoreMultipleRSPair<string mnemonic, bits<8> rsOpcode,
2698 let DispKey = mnemonic # cls in {
2700 def "" : StoreMultipleRS<mnemonic, rsOpcode, cls, bdaddr12pair>;
2702 def Y : StoreMultipleRSY<mnemonic#"y", rsyOpcode, cls, bdaddr20pair>;
2706 multiclass StoreMultipleVRSaAlign<string mnemonic, bits<16> opcode> {
2710 mnemonic#"\t$V1, $V3, $BD2, $M4", []>;
2714 mnemonic#"\t$V1, $V3, $BD2", []>;
2724 class StoreSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
2727 mnemonic#"\t$BD1, $I2",
2732 class StoreSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
2735 mnemonic#"\t$BD1, $I2",
2740 class StoreSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
2743 mnemonic#"\t$BD1, $I2",
2748 multiclass StoreSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
2750 let DispKey = mnemonic in {
2752 def "" : StoreSI<mnemonic, siOpcode, operator, imm>;
2754 def Y : StoreSIY<mnemonic#"y", siyOpcode, operator, imm>;
2758 class StoreSSE<string mnemonic, bits<16> opcode>
2760 mnemonic#"\t$BD1, $BD2", []> {
2764 class CondStoreRSY<string mnemonic, bits<16> opcode,
2768 mnemonic#"$M3\t$R1, $BD2", []> {
2775 // mask is the third operand rather than being part of the mnemonic.
2776 class AsmCondStoreRSY<string mnemonic, bits<16> opcode,
2780 mnemonic#"\t$R1, $BD2, $M3", []> {
2786 class FixedCondStoreRSY<CondVariant V, string mnemonic, bits<16> opcode,
2790 mnemonic#V.suffix#"\t$R1, $BD2", []> {
2798 multiclass CondStoreRSYPair<string mnemonic, bits<16> opcode,
2802 def "" : CondStoreRSY<mnemonic, opcode, cls, bytes, mode>;
2803 def Asm : AsmCondStoreRSY<mnemonic, opcode, cls, bytes, mode>;
2806 class SideEffectUnaryI<string mnemonic, bits<8> opcode, ImmOpWithPattern imm>
2808 mnemonic#"\t$I1", []>;
2810 class SideEffectUnaryRR<string mnemonic, bits<8>opcode, RegisterOperand cls>
2812 mnemonic#"\t$R1", []> {
2816 class SideEffectUnaryRRE<string mnemonic, bits<16> opcode, RegisterOperand cls,
2819 mnemonic#"\t$R1", [(operator cls:$R1)]> {
2823 class SideEffectUnaryS<string mnemonic, bits<16> opcode,
2827 mnemonic#"\t$BD2", [(operator mode:$BD2)]> {
2832 class SideEffectUnarySIY<string mnemonic, bits<16> opcode,
2836 mnemonic#"\t$BD1", []> {
2842 class SideEffectAddressS<string mnemonic, bits<16> opcode,
2846 mnemonic#"\t$BD2", [(operator mode:$BD2)]>;
2848 class LoadAddressRX<string mnemonic, bits<8> opcode,
2851 mnemonic#"\t$R1, $XBD2",
2854 class LoadAddressRXY<string mnemonic, bits<16> opcode,
2857 mnemonic#"\t$R1, $XBD2",
2860 multiclass LoadAddressRXPair<string mnemonic, bits<8> rxOpcode,
2862 let DispKey = mnemonic in {
2864 def "" : LoadAddressRX<mnemonic, rxOpcode, operator, laaddr12pair>;
2866 def Y : LoadAddressRXY<mnemonic#"y", rxyOpcode, operator, laaddr20pair>;
2870 class LoadAddressRIL<string mnemonic, bits<12> opcode,
2873 mnemonic#"\t$R1, $RI2",
2876 class UnaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
2879 mnemonic#"\t$R1, $R2",
2881 let OpKey = mnemonic#cls1;
2885 class UnaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
2888 mnemonic#"\t$R1, $R2",
2890 let OpKey = mnemonic#cls1;
2894 class UnaryTiedRRE<string mnemonic, bits<16> opcode, RegisterOperand cls>
2896 mnemonic#"\t$R1", []> {
2902 class UnaryMemRRFc<string mnemonic, bits<16> opcode,
2905 mnemonic#"\t$R1, $R2", []> {
2911 class UnaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
2914 mnemonic#"\t$R1, $I2",
2917 class UnaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
2920 mnemonic#"\t$R1, $I2",
2923 class UnaryRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
2926 mnemonic#"\t$R1, $RI2",
2935 class CondUnaryRSY<string mnemonic, bits<16> opcode,
2940 mnemonic#"$M3\t$R1, $BD2",
2949 let OpKey = mnemonic#"r"#cls;
2951 let MemKey = mnemonic#cls;
2956 // mask is the third operand rather than being part of the mnemonic.
2957 class AsmCondUnaryRSY<string mnemonic, bits<16> opcode,
2961 mnemonic#"\t$R1, $BD2, $M3", []> {
2969 class FixedCondUnaryRSY<CondVariant V, string mnemonic, bits<16> opcode,
2973 mnemonic#V.suffix#"\t$R1, $BD2", []> {
2983 multiclass CondUnaryRSYPair<string mnemonic, bits<16> opcode,
2988 def "" : CondUnaryRSY<mnemonic, opcode, operator, cls, bytes, mode>;
2989 def Asm : AsmCondUnaryRSY<mnemonic, opcode, cls, bytes, mode>;
2992 class UnaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
2996 mnemonic#"\t$R1, $XBD2",
2998 let OpKey = mnemonic#"r"#cls;
3004 class UnaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3007 mnemonic#"\t$R1, $XBD2",
3009 let OpKey = mnemonic#"r"#cls;
3016 class UnaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3020 mnemonic#"\t$R1, $XBD2",
3022 let OpKey = mnemonic#"r"#cls;
3028 multiclass UnaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
3031 let DispKey = mnemonic # cls in {
3033 def "" : UnaryRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
3035 def Y : UnaryRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
3040 class UnaryVRIa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3043 mnemonic#"\t$V1, $I2",
3048 class UnaryVRIaGeneric<string mnemonic, bits<16> opcode, ImmOpWithPattern imm>
3050 mnemonic#"\t$V1, $I2, $M3", []>;
3052 class UnaryVRRa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3056 mnemonic#"\t$V1, $V2",
3065 class UnaryVRRaGeneric<string mnemonic, bits<16> opcode, bits<4> m4 = 0,
3068 mnemonic#"\t$V1, $V2, $M3", []> {
3073 class UnaryVRRaFloatGeneric<string mnemonic, bits<16> opcode, bits<4> m5 = 0>
3076 mnemonic#"\t$V1, $V2, $M3, $M4", []> {
3084 multiclass UnaryExtraVRRaSPair<string mnemonic, bits<16> opcode,
3091 mnemonic#"\t$V1, $V2, $M5", []>;
3094 def : InstAlias<mnemonic#"\t$V1, $V2",
3097 def S : UnaryVRRa<mnemonic#"s", opcode, operator_cc, tr1, tr2,
3101 multiclass UnaryExtraVRRaSPairGeneric<string mnemonic, bits<16> opcode> {
3105 mnemonic#"\t$V1, $V2, $M3, $M5", []>;
3106 def : InstAlias<mnemonic#"\t$V1, $V2, $M3",
3111 class UnaryVRX<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3114 mnemonic#"\t$V1, $XBD2",
3121 class UnaryVRXGeneric<string mnemonic, bits<16> opcode>
3123 mnemonic#"\t$V1, $XBD2, $M3", []> {
3127 multiclass UnaryVRXAlign<string mnemonic, bits<16> opcode> {
3131 mnemonic#"\t$V1, $XBD2, $M3", []>;
3134 mnemonic#"\t$V1, $XBD2", []>;
3138 class SideEffectBinaryRX<string mnemonic, bits<8> opcode,
3141 mnemonic#"\t$R1, $XBD2", []>;
3143 class SideEffectBinaryRXY<string mnemonic, bits<16> opcode,
3146 mnemonic#"\t$R1, $XBD2", []>;
3148 class SideEffectBinaryRILPC<string mnemonic, bits<12> opcode,
3151 mnemonic#"\t$R1, $RI2", []> {
3158 class SideEffectBinaryRRE<string mnemonic, bits<16> opcode,
3161 mnemonic#"\t$R1, $R2", []>;
3163 class SideEffectBinaryRRFa<string mnemonic, bits<16> opcode,
3166 mnemonic#"\t$R1, $R2", []> {
3171 class SideEffectBinaryRRFc<string mnemonic, bits<16> opcode,
3174 mnemonic#"\t$R1, $R2", []> {
3178 class SideEffectBinaryIE<string mnemonic, bits<16> opcode,
3181 mnemonic#"\t$I1, $I2", []>;
3183 class SideEffectBinarySI<string mnemonic, bits<8> opcode, Operand imm>
3185 mnemonic#"\t$BD1, $I2", []>;
3187 class SideEffectBinarySIL<string mnemonic, bits<16> opcode,
3190 mnemonic#"\t$BD1, $I2", [(operator bdaddr12only:$BD1, imm:$I2)]>;
3192 class SideEffectBinarySSa<string mnemonic, bits<8> opcode>
3194 mnemonic#"\t$BDL1, $BD2", []>;
3196 class SideEffectBinarySSb<string mnemonic, bits<8> opcode>
3199 mnemonic#"\t$BDL1, $BDL2", []>;
3201 class SideEffectBinarySSf<string mnemonic, bits<8> opcode>
3203 mnemonic#"\t$BD1, $BDL2", []>;
3205 class SideEffectBinarySSE<string mnemonic, bits<16> opcode>
3207 mnemonic#"\t$BD1, $BD2", []>;
3209 class SideEffectBinaryMemMemRR<string mnemonic, bits<8> opcode,
3212 mnemonic#"\t$R1, $R2", []> {
3217 class SideEffectBinaryMemRRE<string mnemonic, bits<16> opcode,
3220 mnemonic#"\t$R1, $R2", []> {
3225 class SideEffectBinaryMemMemRRE<string mnemonic, bits<16> opcode,
3228 mnemonic#"\t$R1, $R2", []> {
3233 class SideEffectBinaryMemMemRRFc<string mnemonic, bits<16> opcode,
3236 mnemonic#"\t$R1, $R2", []> {
3242 class BinaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
3245 mnemonic#"\t$R1, $R2",
3247 let OpKey = mnemonic#cls1;
3253 class BinaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3256 mnemonic#"\t$R1, $R2",
3258 let OpKey = mnemonic#cls1;
3264 class BinaryRRD<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3267 mnemonic#"\t$R1, $R3, $R2",
3269 let OpKey = mnemonic#cls;
3273 class BinaryRRFa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3277 mnemonic#"\t$R1, $R2, $R3",
3280 let OpKey = mnemonic#cls1;
3284 multiclass BinaryRRAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
3287 let NumOpsKey = mnemonic in {
3289 def K : BinaryRRFa<mnemonic#"k", opcode2, operator, cls1, cls1, cls2>,
3292 def "" : BinaryRR<mnemonic, opcode1, operator, cls1, cls2>;
3296 multiclass BinaryRREAndK<string mnemonic, bits<16> opcode1, bits<16> opcode2,
3299 let NumOpsKey = mnemonic in {
3301 def K : BinaryRRFa<mnemonic#"k", opcode2, operator, cls1, cls1, cls2>,
3304 def "" : BinaryRRE<mnemonic, opcode1, operator, cls1, cls2>;
3308 class BinaryRRFb<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3312 mnemonic#"\t$R1, $R3, $R2",
3317 class BinaryRRFc<string mnemonic, bits<16> opcode,
3320 mnemonic#"\t$R1, $R2, $M3", []>;
3322 class BinaryMemRRFc<string mnemonic, bits<16> opcode,
3325 mnemonic#"\t$R1, $R2, $M3", []> {
3330 multiclass BinaryMemRRFcOpt<string mnemonic, bits<16> opcode,
3332 def "" : BinaryMemRRFc<mnemonic, opcode, cls1, cls2, imm32zx4>;
3333 def Opt : UnaryMemRRFc<mnemonic, opcode, cls1, cls2>;
3336 class BinaryRRFd<string mnemonic, bits<16> opcode, RegisterOperand cls1,
3339 mnemonic#"\t$R1, $R2, $M4", []>;
3341 class BinaryRRFe<string mnemonic, bits<16> opcode, RegisterOperand cls1,
3344 mnemonic#"\t$R1, $M3, $R2", []> {
3348 class CondBinaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
3352 mnemonic#"$M3\t$R1, $R2",
3358 let NumOpsKey = !subst("loc", "sel", mnemonic);
3360 let OpKey = mnemonic#cls1;
3365 // mask is the third operand rather than being part of the mnemonic.
3366 class AsmCondBinaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
3370 mnemonic#"\t$R1, $R2, $M3", []> {
3376 class FixedCondBinaryRRF<CondVariant V, string mnemonic, bits<16> opcode,
3379 mnemonic#V.suffix#"\t$R1, $R2", []> {
3387 multiclass CondBinaryRRFPair<string mnemonic, bits<16> opcode,
3390 def "" : CondBinaryRRF<mnemonic, opcode, cls1, cls2>;
3391 def Asm : AsmCondBinaryRRF<mnemonic, opcode, cls1, cls2>;
3394 class CondBinaryRRFa<string mnemonic, bits<16> opcode, RegisterOperand cls1,
3398 mnemonic#"$M4\t$R1, $R2, $R3",
3402 let NumOpsKey = mnemonic;
3404 let OpKey = mnemonic#cls1;
3409 // mask is the third operand rather than being part of the mnemonic.
3410 class AsmCondBinaryRRFa<string mnemonic, bits<16> opcode, RegisterOperand cls1,
3413 mnemonic#"\t$R1, $R2, $R3, $M4", []>;
3416 class FixedCondBinaryRRFa<CondVariant V, string mnemonic, bits<16> opcode,
3420 mnemonic#V.suffix#"\t$R1, $R2, $R3", []> {
3426 multiclass CondBinaryRRFaPair<string mnemonic, bits<16> opcode,
3430 def "" : CondBinaryRRFa<mnemonic, opcode, cls1, cls2, cls3>;
3431 def Asm : AsmCondBinaryRRFa<mnemonic, opcode, cls1, cls2, cls3>;
3434 class BinaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
3437 mnemonic#"\t$R1, $I2",
3443 class BinaryRIE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3446 mnemonic#"\t$R1, $R3, $I2",
3449 multiclass BinaryRIAndK<string mnemonic, bits<12> opcode1, bits<16> opcode2,
3452 let NumOpsKey = mnemonic in {
3454 def K : BinaryRIE<mnemonic#"k", opcode2, operator, cls, imm>,
3457 def "" : BinaryRI<mnemonic, opcode1, operator, cls, imm>;
3461 class CondBinaryRIE<string mnemonic, bits<16> opcode, RegisterOperand cls,
3465 mnemonic#"$M3\t$R1, $I2",
3474 // mask is the third operand rather than being part of the mnemonic.
3475 class AsmCondBinaryRIE<string mnemonic, bits<16> opcode, RegisterOperand cls,
3479 mnemonic#"\t$R1, $I2, $M3", []> {
3485 class FixedCondBinaryRIE<CondVariant V, string mnemonic, bits<16> opcode,
3488 mnemonic#V.suffix#"\t$R1, $I2", []> {
3496 multiclass CondBinaryRIEPair<string mnemonic, bits<16> opcode,
3499 def "" : CondBinaryRIE<mnemonic, opcode, cls, imm>;
3500 def Asm : AsmCondBinaryRIE<mnemonic, opcode, cls, imm>;
3503 class BinaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
3506 mnemonic#"\t$R1, $I2",
3512 class BinaryRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
3515 mnemonic#"\t$R1, $BD2",
3522 class BinaryRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3525 mnemonic#"\t$R1, $R3, $BD2",
3528 multiclass BinaryRSAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
3530 let NumOpsKey = mnemonic in {
3532 def K : BinaryRSY<mnemonic#"k", opcode2, operator, cls>,
3535 def "" : BinaryRS<mnemonic, opcode1, operator, cls>;
3539 class BinaryRSL<string mnemonic, bits<16> opcode, RegisterOperand cls>
3542 mnemonic#"\t$R1, $BDL2, $M3", []> {
3546 class BinaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
3550 mnemonic#"\t$R1, $XBD2",
3552 let OpKey = mnemonic#"r"#cls;
3560 class BinaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3563 mnemonic#"\t$R1, $XBD2",
3566 let OpKey = mnemonic#"r"#cls;
3575 class BinaryRXF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3579 mnemonic#"\t$R1, $R3, $XBD2",
3581 let OpKey = mnemonic#"r"#cls;
3587 class BinaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3591 mnemonic#"\t$R1, $XBD2",
3593 let OpKey = mnemonic#"r"#cls;
3601 multiclass BinaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
3604 let DispKey = mnemonic # cls in {
3606 def "" : BinaryRX<mnemonic, rxOpcode, operator, cls, load, bytes,
3609 def Y : BinaryRXY<mnemonic#"y", rxyOpcode, operator, cls, load, bytes,
3614 class BinarySI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
3617 mnemonic#"\t$BD1, $I2",
3623 class BinarySIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3626 mnemonic#"\t$BD1, $I2",
3632 multiclass BinarySIPair<string mnemonic, bits<8> siOpcode,
3635 let DispKey = mnemonic # cls in {
3637 def "" : BinarySI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
3639 def Y : BinarySIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
3643 class BinarySSF<string mnemonic, bits<12> opcode, RegisterOperand cls>
3645 mnemonic#"\t$R3, $BD1, $BD2", []> {
3649 class BinaryVRIb<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3652 mnemonic#"\t$V1, $I2, $I3",
3657 class BinaryVRIbGeneric<string mnemonic, bits<16> opcode>
3660 mnemonic#"\t$V1, $I2, $I3, $M4", []>;
3662 class BinaryVRIc<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3665 mnemonic#"\t$V1, $V3, $I2",
3671 class BinaryVRIcGeneric<string mnemonic, bits<16> opcode>
3674 mnemonic#"\t$V1, $V3, $I2, $M4", []>;
3676 class BinaryVRIe<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3679 mnemonic#"\t$V1, $V2, $I3",
3686 class BinaryVRIeFloatGeneric<string mnemonic, bits<16> opcode>
3689 mnemonic#"\t$V1, $V2, $I3, $M4, $M5", []>;
3691 class BinaryVRIh<string mnemonic, bits<16> opcode>
3694 mnemonic#"\t$V1, $I2, $I3", []>;
3696 class BinaryVRRa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3699 mnemonic#"\t$V1, $V2, $M5",
3706 class BinaryVRRaFloatGeneric<string mnemonic, bits<16> opcode>
3709 mnemonic#"\t$V1, $V2, $M3, $M4, $M5", []>;
3711 class BinaryVRRb<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3715 mnemonic#"\t$V1, $V2, $V3",
3722 class BinaryExtraVRRb<string mnemonic, bits<16> opcode, bits<4> type = 0>
3724 mnemonic#"\t$V1, $V2, $V3, $M5", []> {
3728 class BinaryExtraVRRbGeneric<string mnemonic, bits<16> opcode>
3731 mnemonic#"\t$V1, $V2, $V3, $M4, $M5", []>;
3735 multiclass BinaryVRRbSPair<string mnemonic, bits<16> opcode,
3739 def "" : BinaryVRRb<mnemonic, opcode, operator, tr1, tr2, type,
3742 def S : BinaryVRRb<mnemonic#"s", opcode, operator_cc, tr1, tr2, type,
3746 class BinaryVRRbSPairGeneric<string mnemonic, bits<16> opcode>
3749 mnemonic#"\t$V1, $V2, $V3, $M4, $M5", []> {
3757 multiclass BinaryExtraVRRbSPair<string mnemonic, bits<16> opcode,
3764 mnemonic#"\t$V1, $V2, $V3, $M5", []>;
3767 def : InstAlias<mnemonic#"\t$V1, $V2, $V3",
3771 def S : BinaryVRRb<mnemonic#"s", opcode, operator_cc, tr1, tr2, type, 1>;
3774 multiclass BinaryExtraVRRbSPairGeneric<string mnemonic, bits<16> opcode> {
3778 mnemonic#"\t$V1, $V2, $V3, $M4, $M5", []>;
3779 def : InstAlias<mnemonic#"\t$V1, $V2, $V3, $M4",
3784 class BinaryVRRc<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3788 mnemonic#"\t$V1, $V2, $V3",
3798 class BinaryVRRcGeneric<string mnemonic, bits<16> opcode, bits<4> m5 = 0,
3802 mnemonic#"\t$V1, $V2, $V3, $M4", []> {
3807 class BinaryVRRcFloatGeneric<string mnemonic, bits<16> opcode, bits<4> m6 = 0>
3810 mnemonic#"\t$V1, $V2, $V3, $M4, $M5", []> {
3816 multiclass BinaryVRRcSPair<string mnemonic, bits<16> opcode,
3821 def "" : BinaryVRRc<mnemonic, opcode, operator, tr1, tr2, type,
3824 def S : BinaryVRRc<mnemonic#"s", opcode, operator_cc, tr1, tr2, type,
3828 class BinaryVRRcSPairFloatGeneric<string mnemonic, bits<16> opcode>
3832 mnemonic#"\t$V1, $V2, $V3, $M4, $M5, $M6", []>;
3834 class BinaryVRRf<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3837 mnemonic#"\t$V1, $R2, $R3",
3840 class BinaryVRRi<string mnemonic, bits<16> opcode, RegisterOperand cls>
3842 mnemonic#"\t$R1, $V2, $M3", []> {
3846 class BinaryVRRk<string mnemonic, bits<16> opcode>
3848 mnemonic#"\t$V1, $V2, $M3", []>;
3850 class BinaryVRSa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3853 mnemonic#"\t$V1, $V3, $BD2",
3859 class BinaryVRSaGeneric<string mnemonic, bits<16> opcode>
3862 mnemonic#"\t$V1, $V3, $BD2, $M4", []>;
3864 class BinaryVRSb<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3867 mnemonic#"\t$V1, $R3, $BD2",
3874 class BinaryVRSc<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3877 mnemonic#"\t$R1, $V3, $BD2",
3882 class BinaryVRScGeneric<string mnemonic, bits<16> opcode>
3885 mnemonic#"\t$R1, $V3, $BD2, $M4", []>;
3887 class BinaryVRSd<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3890 mnemonic#"\t$V1, $R3, $BD2",
3896 class BinaryVRX<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3899 mnemonic#"\t$V1, $XBD2, $M3",
3906 class StoreBinaryRS<string mnemonic, bits<8> opcode, RegisterOperand cls,
3909 mnemonic#"\t$R1, $M3, $BD2", []> {
3914 class StoreBinaryRSY<string mnemonic, bits<16> opcode, RegisterOperand cls,
3917 mnemonic#"\t$R1, $M3, $BD2", []> {
3922 multiclass StoreBinaryRSPair<string mnemonic, bits<8> rsOpcode,
3925 let DispKey = mnemonic # cls in {
3927 def "" : StoreBinaryRS<mnemonic, rsOpcode, cls, bytes, bdaddr12pair>;
3929 def Y : StoreBinaryRSY<mnemonic#"y", rsyOpcode, cls, bytes,
3934 class StoreBinaryRSL<string mnemonic, bits<16> opcode, RegisterOperand cls>
3937 mnemonic#"\t$R1, $BDL2, $M3", []> {
3941 class BinaryVSI<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3944 mnemonic#"\t$V1, $BD2, $I3",
3950 class StoreBinaryVRV<string mnemonic, bits<16> opcode, bits<5> bytes,
3953 mnemonic#"\t$V1, $VBD2, $M3", []> {
3958 class StoreBinaryVRX<string mnemonic, bits<16> opcode,
3962 mnemonic#"\t$V1, $XBD2, $M3",
3968 class MemoryBinarySSd<string mnemonic, bits<8> opcode,
3972 mnemonic#"\t$RBD1, $BD2, $R3", []>;
3974 class CompareRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
3977 mnemonic#"\t$R1, $R2",
3979 let OpKey = mnemonic#cls1;
3984 class CompareRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
3987 mnemonic#"\t$R1, $R2",
3989 let OpKey = mnemonic#cls1;
3994 class CompareRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
3997 mnemonic#"\t$R1, $I2",
4002 class CompareRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
4005 mnemonic#"\t$R1, $I2",
4010 class CompareRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
4013 mnemonic#"\t$R1, $RI2",
4023 class CompareRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
4027 mnemonic#"\t$R1, $XBD2",
4029 let OpKey = mnemonic#"r"#cls;
4036 class CompareRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4039 mnemonic#"\t$R1, $XBD2",
4041 let OpKey = mnemonic#"r"#cls;
4049 class CompareRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4053 mnemonic#"\t$R1, $XBD2",
4055 let OpKey = mnemonic#"r"#cls;
4062 multiclass CompareRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
4065 let DispKey = mnemonic # cls in {
4067 def "" : CompareRX<mnemonic, rxOpcode, operator, cls,
4070 def Y : CompareRXY<mnemonic#"y", rxyOpcode, operator, cls,
4075 class CompareRS<string mnemonic, bits<8> opcode, RegisterOperand cls,
4078 mnemonic#"\t$R1, $M3, $BD2", []> {
4083 class CompareRSY<string mnemonic, bits<16> opcode, RegisterOperand cls,
4086 mnemonic#"\t$R1, $M3, $BD2", []> {
4091 multiclass CompareRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
4093 let DispKey = mnemonic # cls in {
4095 def "" : CompareRS<mnemonic, rsOpcode, cls, bytes, bdaddr12pair>;
4097 def Y : CompareRSY<mnemonic#"y", rsyOpcode, cls, bytes, bdaddr20pair>;
4101 class CompareSSb<string mnemonic, bits<8> opcode>
4104 mnemonic#"\t$BDL1, $BDL2", []> {
4109 class CompareSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
4113 mnemonic#"\t$BD1, $I2",
4119 class CompareSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4122 mnemonic#"\t$BD1, $I2",
4128 class CompareSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4132 mnemonic#"\t$BD1, $I2",
4138 multiclass CompareSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
4141 let DispKey = mnemonic in {
4143 def "" : CompareSI<mnemonic, siOpcode, operator, load, imm, bdaddr12pair>;
4145 def Y : CompareSIY<mnemonic#"y", siyOpcode, operator, load, imm,
4150 class CompareVRRa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4153 mnemonic#"\t$V1, $V2",
4163 class CompareVRRaGeneric<string mnemonic, bits<16> opcode>
4165 mnemonic#"\t$V1, $V2, $M3", []> {
4171 class CompareVRRaFloatGeneric<string mnemonic, bits<16> opcode>
4174 mnemonic#"\t$V1, $V2, $M3, $M4", []> {
4179 class CompareVRRh<string mnemonic, bits<16> opcode>
4181 mnemonic#"\t$V1, $V2, $M3", []> {
4185 class TestInherentS<string mnemonic, bits<16> opcode,
4187 : InstS<opcode, (outs), (ins), mnemonic, [(set CC, (operator))]> {
4191 class TestRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4194 mnemonic#"\t$R1, $XBD2",
4199 class TestBinarySIL<string mnemonic, bits<16> opcode,
4202 mnemonic#"\t$BD1, $I2",
4205 class TestRSL<string mnemonic, bits<16> opcode>
4207 mnemonic#"\t$BDL1", []> {
4211 class TestVRRg<string mnemonic, bits<16> opcode>
4213 mnemonic#"\t$V1", []>;
4215 class SideEffectTernarySSc<string mnemonic, bits<8> opcode>
4218 mnemonic#"\t$BDL1, $BD2, $I3", []>;
4220 class SideEffectTernaryRRFa<string mnemonic, bits<16> opcode,
4224 mnemonic#"\t$R1, $R2, $R3", []> {
4228 class SideEffectTernaryMemMemRRFa<string mnemonic, bits<16> opcode,
4233 mnemonic#"\t$R1, $R2, $R3", []> {
4239 class SideEffectTernaryRRFb<string mnemonic, bits<16> opcode,
4243 mnemonic#"\t$R1, $R3, $R2", []> {
4247 class SideEffectTernaryMemMemMemRRFb<string mnemonic, bits<16> opcode,
4253 mnemonic#"\t$R1, $R3, $R2", []> {
4259 class SideEffectTernaryRRFc<string mnemonic, bits<16> opcode,
4263 mnemonic#"\t$R1, $R2, $M3", []>;
4265 multiclass SideEffectTernaryRRFcOpt<string mnemonic, bits<16> opcode,
4268 def "" : SideEffectTernaryRRFc<mnemonic, opcode, cls1, cls2, imm32zx4>;
4269 def Opt : SideEffectBinaryRRFc<mnemonic, opcode, cls1, cls2>;
4272 class SideEffectTernaryMemMemRRFc<string mnemonic, bits<16> opcode,
4277 mnemonic#"\t$R1, $R2, $M3", []> {
4282 multiclass SideEffectTernaryMemMemRRFcOpt<string mnemonic, bits<16> opcode,
4285 def "" : SideEffectTernaryMemMemRRFc<mnemonic, opcode, cls1, cls2, imm32zx4>;
4286 def Opt : SideEffectBinaryMemMemRRFc<mnemonic, opcode, cls1, cls2>;
4289 class SideEffectTernarySSF<string mnemonic, bits<12> opcode,
4293 mnemonic#"\t$BD1, $BD2, $R3", []>;
4295 class TernaryRRFa<string mnemonic, bits<16> opcode,
4299 mnemonic#"\t$R1, $R2, $R3, $M4", []>;
4301 class TernaryRRFb<string mnemonic, bits<16> opcode,
4306 mnemonic#"\t$R1, $R3, $R2, $M4", []> {
4311 class TernaryRRFe<string mnemonic, bits<16> opcode, RegisterOperand cls1,
4315 mnemonic#"\t$R1, $M3, $R2, $M4", []>;
4317 class TernaryRRD<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4320 mnemonic#"\t$R1, $R3, $R2",
4322 let OpKey = mnemonic#cls;
4328 class TernaryRS<string mnemonic, bits<8> opcode, RegisterOperand cls,
4332 mnemonic#"\t$R1, $M3, $BD2", []> {
4340 class TernaryRSY<string mnemonic, bits<16> opcode, RegisterOperand cls,
4344 mnemonic#"\t$R1, $M3, $BD2", []> {
4352 multiclass TernaryRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
4354 let DispKey = mnemonic # cls in {
4356 def "" : TernaryRS<mnemonic, rsOpcode, cls, bytes, bdaddr12pair>;
4358 def Y : TernaryRSY<mnemonic#"y", rsyOpcode, cls, bytes, bdaddr20pair>;
4362 class SideEffectTernaryRS<string mnemonic, bits<8> opcode,
4366 mnemonic#"\t$R1, $R3, $BD2", []>;
4368 class SideEffectTernaryRSY<string mnemonic, bits<16> opcode,
4372 mnemonic#"\t$R1, $R3, $BD2", []>;
4374 class SideEffectTernaryMemMemRS<string mnemonic, bits<8> opcode,
4378 mnemonic#"\t$R1, $R3, $BD2", []> {
4383 class SideEffectTernaryMemMemRSY<string mnemonic, bits<16> opcode,
4387 mnemonic#"\t$R1, $R3, $BD2", []> {
4392 class TernaryRXF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4397 mnemonic#"\t$R1, $R3, $XBD2",
4400 let OpKey = mnemonic#"r"#cls;
4408 class TernaryVRIa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4411 mnemonic#"\t$V1, $I2, $M3",
4418 class TernaryVRId<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4422 mnemonic#"\t$V1, $V2, $V3, $I4",
4429 class TernaryVRIi<string mnemonic, bits<16> opcode, RegisterOperand cls>
4432 mnemonic#"\t$V1, $R2, $I3, $M4", []>;
4434 class TernaryVRRa<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4438 mnemonic#"\t$V1, $V2, $M4, $M5",
4446 class TernaryVRRaFloatGeneric<string mnemonic, bits<16> opcode>
4449 mnemonic#"\t$V1, $V2, $M3, $M4, $M5", []>;
4451 class TernaryVRRb<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4456 mnemonic#"\t$V1, $V2, $V3, $M5",
4467 multiclass TernaryOptVRRbSPair<string mnemonic, bits<16> opcode,
4472 def "" : TernaryVRRb<mnemonic, opcode, operator, tr1, tr2, type,
4474 def : InstAlias<mnemonic#"\t$V1, $V2, $V3",
4478 def S : TernaryVRRb<mnemonic#"s", opcode, operator_cc, tr1, tr2, type,
4480 def : InstAlias<mnemonic#"s\t$V1, $V2, $V3",
4485 multiclass TernaryOptVRRbSPairGeneric<string mnemonic, bits<16> opcode> {
4489 mnemonic#"\t$V1, $V2, $V3, $M4, $M5", []>;
4490 def : InstAlias<mnemonic#"\t$V1, $V2, $V3, $M4",
4495 class TernaryVRRc<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4499 mnemonic#"\t$V1, $V2, $V3, $M4",
4507 class TernaryVRRcFloat<string mnemonic, bits<16> opcode,
4512 mnemonic#"\t$V1, $V2, $V3, $M6",
4520 class TernaryVRRcFloatGeneric<string mnemonic, bits<16> opcode>
4524 mnemonic#"\t$V1, $V2, $V3, $M4, $M5, $M6", []>;
4526 class TernaryVRRd<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4530 mnemonic#"\t$V1, $V2, $V3, $V4",
4538 class TernaryVRRdGeneric<string mnemonic, bits<16> opcode>
4541 mnemonic#"\t$V1, $V2, $V3, $V4, $M5", []> {
4545 // Ternary operation where the assembler mnemonic has an extra operand to
4547 multiclass TernaryExtraVRRd<string mnemonic, bits<16> opcode,
4553 mnemonic#"\t$V1, $V2, $V3, $V4, $M6", []>;
4557 def : InstAlias<mnemonic#"\t$V1, $V2, $V3, $V4",
4562 multiclass TernaryExtraVRRdGeneric<string mnemonic, bits<16> opcode> {
4567 mnemonic#"\t$V1, $V2, $V3, $V4, $M5, $M6", []>;
4568 def : InstAlias<mnemonic#"\t$V1, $V2, $V3, $V4, $M5",
4573 class TernaryVRRe<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4578 mnemonic#"\t$V1, $V2, $V3, $V4",
4588 class TernaryVRReFloatGeneric<string mnemonic, bits<16> opcode>
4591 mnemonic#"\t$V1, $V2, $V3, $V4, $M5, $M6", []>;
4593 class TernaryVRSb<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4597 mnemonic#"\t$V1, $R3, $BD2",
4606 class TernaryVRRi<string mnemonic, bits<16> opcode, RegisterOperand cls>
4609 mnemonic#"\t$R1, $V2, $M3, $M4", []>;
4611 class TernaryVRRj<string mnemonic, bits<16> opcode>
4614 mnemonic#"\t$V1, $V2, $V3, $M4", []>;
4616 class TernaryVRSbGeneric<string mnemonic, bits<16> opcode>
4619 mnemonic#"\t$V1, $R3, $BD2, $M4", []> {
4624 class TernaryVRV<string mnemonic, bits<16> opcode, bits<5> bytes,
4628 mnemonic#"\t$V1, $VBD2, $M3", []> {
4635 class TernaryVRX<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4639 mnemonic#"\t$V1, $XBD2, $M3",
4649 class QuaternaryVRId<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4653 mnemonic#"\t$V1, $V2, $V3, $I4",
4663 class QuaternaryVRIdGeneric<string mnemonic, bits<16> opcode>
4667 mnemonic#"\t$V1, $V2, $V3, $I4, $M5", []> {
4672 class QuaternaryVRIf<string mnemonic, bits<16> opcode>
4676 mnemonic#"\t$V1, $V2, $V3, $I4, $M5", []>;
4678 class QuaternaryVRIg<string mnemonic, bits<16> opcode>
4682 mnemonic#"\t$V1, $V2, $I3, $I4, $M5", []>;
4684 class QuaternaryVRRd<string mnemonic, bits<16> opcode,
4690 mnemonic#"\t$V1, $V2, $V3, $V4, $M6",
4699 class QuaternaryVRRdGeneric<string mnemonic, bits<16> opcode>
4702 mnemonic#"\t$V1, $V2, $V3, $V4, $M5, $M6", []>;
4707 multiclass QuaternaryOptVRRdSPair<string mnemonic, bits<16> opcode,
4712 def "" : QuaternaryVRRd<mnemonic, opcode, operator,
4715 def : InstAlias<mnemonic#"\t$V1, $V2, $V3, $V4",
4719 def S : QuaternaryVRRd<mnemonic#"s", opcode, operator_cc,
4722 def : InstAlias<mnemonic#"s\t$V1, $V2, $V3, $V4",
4727 multiclass QuaternaryOptVRRdSPairGeneric<string mnemonic, bits<16> opcode> {
4729 def "" : QuaternaryVRRdGeneric<mnemonic, opcode>;
4730 def : InstAlias<mnemonic#"\t$V1, $V2, $V3, $V4, $M5",
4735 class SideEffectQuaternaryRRFa<string mnemonic, bits<16> opcode,
4739 mnemonic#"\t$R1, $R2, $R3, $M4", []>;
4741 multiclass SideEffectQuaternaryRRFaOptOpt<string mnemonic, bits<16> opcode,
4745 def "" : SideEffectQuaternaryRRFa<mnemonic, opcode, cls1, cls2, cls3>;
4746 def Opt : SideEffectTernaryRRFa<mnemonic, opcode, cls1, cls2, cls3>;
4747 def OptOpt : SideEffectBinaryRRFa<mnemonic, opcode, cls1, cls2>;
4750 class SideEffectQuaternaryRRFb<string mnemonic, bits<16> opcode,
4754 mnemonic#"\t$R1, $R3, $R2, $M4", []>;
4756 multiclass SideEffectQuaternaryRRFbOpt<string mnemonic, bits<16> opcode,
4760 def "" : SideEffectQuaternaryRRFb<mnemonic, opcode, cls1, cls2, cls3>;
4761 def Opt : SideEffectTernaryRRFb<mnemonic, opcode, cls1, cls2, cls3>;
4764 class SideEffectQuaternarySSe<string mnemonic, bits<8> opcode,
4768 mnemonic#"\t$R1, $BD2, $R3, $BD4", []>;
4770 class LoadAndOpRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4773 mnemonic#"\t$R1, $R3, $BD2",
4779 class CmpSwapRRE<string mnemonic, bits<16> opcode,
4782 mnemonic#"\t$R1, $R2", []> {
4789 class CmpSwapRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
4792 mnemonic#"\t$R1, $R3, $BD2",
4800 class CmpSwapRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
4803 mnemonic#"\t$R1, $R3, $BD2",
4811 multiclass CmpSwapRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
4813 let DispKey = mnemonic # cls in {
4815 def "" : CmpSwapRS<mnemonic, rsOpcode, operator, cls, bdaddr12pair>;
4817 def Y : CmpSwapRSY<mnemonic#"y", rsyOpcode, operator, cls, bdaddr20pair>;
4821 class RotateSelectRIEf<string mnemonic, bits<16> opcode, RegisterOperand cls1,
4826 mnemonic#"\t$R1, $R2, $I3, $I4, $I5", []> {
4831 class PrefetchRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator>
4833 mnemonic#"\t$M1, $XBD2",
4836 class PrefetchRILPC<string mnemonic, bits<12> opcode,
4839 mnemonic#"\t$M1, $RI2",
4847 class BranchPreloadSMI<string mnemonic, bits<8> opcode>
4850 mnemonic#"\t$M1, $RI2, $BD3", []>;
4852 class BranchPreloadMII<string mnemonic, bits<8> opcode>
4855 mnemonic#"\t$M1, $RI2, $RI3", []>;
4862 multiclass LoadAndTestRRE<string mnemonic, bits<16> opcode,
4864 def "" : UnaryRRE<mnemonic, opcode, null_frag, cls, cls>;
4866 def Compare : CompareRRE<mnemonic, opcode, null_frag, cls, cls>;
4945 class MemFoldPseudo<string mnemonic, RegisterOperand cls, bits<5> bytes,
4950 mnemonic#"rk"#cls));
4952 let MemKey = mnemonic#cls;
4961 class MemFoldPseudo_FP<string mnemonic, RegisterOperand cls, bits<5> bytes,
4963 : MemFoldPseudo<mnemonic, cls, bytes, mode> {
4964 let OpKey = mnemonic#"r"#"MemFold"#cls;
4967 class MemFoldPseudo_FPTern<string mnemonic, RegisterOperand cls, bits<5> bytes,
4970 let OpKey = mnemonic#"r"#"MemFold"#cls;
4972 let MemKey = mnemonic#cls;
4981 class MemFoldPseudo_CondMove<string mnemonic, RegisterOperand cls, bits<5> bytes,
4985 let OpKey = !subst("loc", "sel", mnemonic)#"r"#cls;
4987 let MemKey = mnemonic#cls;
5021 class CondBinaryRRFPseudo<string mnemonic, RegisterOperand cls1,
5030 let NumOpsKey = !subst("loc", "sel", mnemonic);
5032 let OpKey = mnemonic#cls1;
5038 class CondBinaryRRFaPseudo<string mnemonic, RegisterOperand cls1,
5045 let NumOpsKey = mnemonic;
5047 let OpKey = mnemonic#cls1;
5065 class CondUnaryRSYPseudo<string mnemonic, SDPatternOperator operator,
5078 let OpKey = mnemonic#"r"#cls;
5080 let MemKey = mnemonic#cls;
5273 multiclass BinaryRXYAndPseudo<string mnemonic, bits<16> opcode,
5277 def "" : BinaryRXY<mnemonic, opcode, operator, cls, load, bytes, mode> {
5278 let MemKey = mnemonic#cls;
5282 def _MemFoldPseudo : MemFoldPseudo<mnemonic, cls, bytes, mode>;
5285 multiclass BinaryRXPairAndPseudo<string mnemonic, bits<8> rxOpcode,
5289 let DispKey = mnemonic # cls in {
5290 def "" : BinaryRX<mnemonic, rxOpcode, operator, cls, load, bytes,
5293 let MemKey = mnemonic#cls;
5297 def Y : BinaryRXY<mnemonic#"y", rxyOpcode, operator, cls, load,
5300 def _MemFoldPseudo : MemFoldPseudo<mnemonic, cls, bytes, bdxaddr12pair>;
5303 multiclass BinaryRXEAndPseudo<string mnemonic, bits<16> opcode,
5306 def "" : BinaryRXE<mnemonic, opcode, operator, cls, load, bytes> {
5307 let MemKey = mnemonic#cls;
5310 def _MemFoldPseudo : MemFoldPseudo_FP<mnemonic, cls, bytes, bdxaddr12pair>;
5313 multiclass TernaryRXFAndPseudo<string mnemonic, bits<16> opcode,
5317 def "" : TernaryRXF<mnemonic, opcode, operator, cls1, cls2, load, bytes> {
5318 let MemKey = mnemonic#cls1;
5321 def _MemFoldPseudo : MemFoldPseudo_FPTern<mnemonic, cls1, bytes, bdxaddr12pair>;
5324 multiclass CondUnaryRSYPairAndMemFold<string mnemonic, bits<16> opcode,
5328 defm "" : CondUnaryRSYPair<mnemonic, opcode, operator, cls, bytes, mode>;
5329 def _MemFoldPseudo : MemFoldPseudo_CondMove<mnemonic, cls, bytes, mode>;
5332 multiclass CondUnaryRSYPseudoAndMemFold<string mnemonic,
5336 def "" : CondUnaryRSYPseudo<mnemonic, operator, cls, bytes, mode>;
5337 def _MemFoldPseudo : MemFoldPseudo_CondMove<mnemonic, cls, bytes, mode>;
5346 multiclass MemorySS<string mnemonic, bits<8> opcode, SDPatternOperator memop> {
5347 def "" : SideEffectBinarySSa<mnemonic, opcode>;
5361 multiclass CompareMemorySS<string mnemonic, bits<8> opcode,
5363 def "" : SideEffectBinarySSa<mnemonic, opcode>;
5381 multiclass StringRRE<string mnemonic, bits<16> opcode,
5384 def "" : SideEffectBinaryMemMemRRE<mnemonic, opcode, GR64, GR64>;