SparcInstrInfo.td revision 9413678f91f4789902b69c4dc18b7205e95b0224
1//===- SparcInstrInfo.td - Target Description for Sparc Target ------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file describes the Sparc instructions in TableGen format. 11// 12//===----------------------------------------------------------------------===// 13 14//===----------------------------------------------------------------------===// 15// Instruction format superclass 16//===----------------------------------------------------------------------===// 17 18include "SparcInstrFormats.td" 19 20//===----------------------------------------------------------------------===// 21// Feature predicates. 22//===----------------------------------------------------------------------===// 23 24// HasV9 - This predicate is true when the target processor supports V9 25// instructions. Note that the machine may be running in 32-bit mode. 26def HasV9 : Predicate<"Subtarget.isV9()">; 27 28// HasNoV9 - This predicate is true when the target doesn't have V9 29// instructions. Use of this is just a hack for the isel not having proper 30// costs for V8 instructions that are more expensive than their V9 ones. 31def HasNoV9 : Predicate<"!Subtarget.isV9()">; 32 33// HasVIS - This is true when the target processor has VIS extensions. 34def HasVIS : Predicate<"Subtarget.isVIS()">; 35 36// UseDeprecatedInsts - This predicate is true when the target processor is a 37// V8, or when it is V9 but the V8 deprecated instructions are efficient enough 38// to use when appropriate. In either of these cases, the instruction selector 39// will pick deprecated instructions. 40def UseDeprecatedInsts : Predicate<"Subtarget.useDeprecatedV8Instructions()">; 41 42//===----------------------------------------------------------------------===// 43// Instruction Pattern Stuff 44//===----------------------------------------------------------------------===// 45 46def simm11 : PatLeaf<(imm), [{ 47 // simm11 predicate - True if the imm fits in a 11-bit sign extended field. 48 return (((int)N->getValue() << (32-11)) >> (32-11)) == (int)N->getValue(); 49}]>; 50 51def simm13 : PatLeaf<(imm), [{ 52 // simm13 predicate - True if the imm fits in a 13-bit sign extended field. 53 return (((int)N->getValue() << (32-13)) >> (32-13)) == (int)N->getValue(); 54}]>; 55 56def LO10 : SDNodeXForm<imm, [{ 57 return CurDAG->getTargetConstant((unsigned)N->getValue() & 1023, MVT::i32); 58}]>; 59 60def HI22 : SDNodeXForm<imm, [{ 61 // Transformation function: shift the immediate value down into the low bits. 62 return CurDAG->getTargetConstant((unsigned)N->getValue() >> 10, MVT::i32); 63}]>; 64 65def SETHIimm : PatLeaf<(imm), [{ 66 return (((unsigned)N->getValue() >> 10) << 10) == (unsigned)N->getValue(); 67}], HI22>; 68 69// Addressing modes. 70def ADDRrr : ComplexPattern<i32, 2, "SelectADDRrr", []>; 71def ADDRri : ComplexPattern<i32, 2, "SelectADDRri", []>; 72 73// Address operands 74def MEMrr : Operand<i32> { 75 let PrintMethod = "printMemOperand"; 76 let NumMIOperands = 2; 77 let MIOperandInfo = (ops IntRegs, IntRegs); 78} 79def MEMri : Operand<i32> { 80 let PrintMethod = "printMemOperand"; 81 let NumMIOperands = 2; 82 let MIOperandInfo = (ops IntRegs, i32imm); 83} 84 85// Branch targets have OtherVT type. 86def brtarget : Operand<OtherVT>; 87def calltarget : Operand<i32>; 88 89// Operand for printing out a condition code. 90let PrintMethod = "printCCOperand" in 91 def CCOp : Operand<i32>; 92 93def SDTSPcmpfcc : 94SDTypeProfile<1, 2, [SDTCisVT<0, FlagVT>, SDTCisFP<1>, SDTCisSameAs<1, 2>]>; 95def SDTSPbrcc : 96SDTypeProfile<0, 3, [SDTCisVT<0, OtherVT>, SDTCisVT<1, i32>, 97 SDTCisVT<2, FlagVT>]>; 98def SDTSPselectcc : 99SDTypeProfile<1, 4, [SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>, 100 SDTCisVT<3, i32>, SDTCisVT<4, FlagVT>]>; 101def SDTSPFTOI : 102SDTypeProfile<1, 1, [SDTCisVT<0, f32>, SDTCisFP<1>]>; 103def SDTSPITOF : 104SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisVT<1, f32>]>; 105 106def SPcmpicc : SDNode<"SPISD::CMPICC", SDTIntBinOp, [SDNPOutFlag]>; 107def SPcmpfcc : SDNode<"SPISD::CMPFCC", SDTSPcmpfcc, [SDNPOutFlag]>; 108def SPbricc : SDNode<"SPISD::BRICC", SDTSPbrcc, [SDNPHasChain]>; 109def SPbrfcc : SDNode<"SPISD::BRFCC", SDTSPbrcc, [SDNPHasChain]>; 110 111def SPhi : SDNode<"SPISD::Hi", SDTIntUnaryOp>; 112def SPlo : SDNode<"SPISD::Lo", SDTIntUnaryOp>; 113 114def SPftoi : SDNode<"SPISD::FTOI", SDTSPFTOI>; 115def SPitof : SDNode<"SPISD::ITOF", SDTSPITOF>; 116 117def SPselecticc : SDNode<"SPISD::SELECT_ICC", SDTSPselectcc>; 118def SPselectfcc : SDNode<"SPISD::SELECT_FCC", SDTSPselectcc>; 119 120// These are target-independent nodes, but have target-specific formats. 121def SDT_SPCallSeq : SDTypeProfile<0, 1, [ SDTCisVT<0, i32> ]>; 122def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_SPCallSeq, [SDNPHasChain]>; 123def callseq_end : SDNode<"ISD::CALLSEQ_END", SDT_SPCallSeq, [SDNPHasChain]>; 124 125def SDT_SPCall : SDTypeProfile<0, 1, [SDTCisVT<0, i32>]>; 126def call : SDNode<"SPISD::CALL", SDT_SPCall, 127 [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>; 128 129def SDT_SPRetFlag : SDTypeProfile<0, 0, []>; 130def retflag : SDNode<"SPISD::RET_FLAG", SDT_SPRetFlag, 131 [SDNPHasChain, SDNPOptInFlag]>; 132 133//===----------------------------------------------------------------------===// 134// SPARC Flag Conditions 135//===----------------------------------------------------------------------===// 136 137// Note that these values must be kept in sync with the CCOp::CondCode enum 138// values. 139class ICC_VAL<int N> : PatLeaf<(i32 N)>; 140def ICC_NE : ICC_VAL< 9>; // Not Equal 141def ICC_E : ICC_VAL< 1>; // Equal 142def ICC_G : ICC_VAL<10>; // Greater 143def ICC_LE : ICC_VAL< 2>; // Less or Equal 144def ICC_GE : ICC_VAL<11>; // Greater or Equal 145def ICC_L : ICC_VAL< 3>; // Less 146def ICC_GU : ICC_VAL<12>; // Greater Unsigned 147def ICC_LEU : ICC_VAL< 4>; // Less or Equal Unsigned 148def ICC_CC : ICC_VAL<13>; // Carry Clear/Great or Equal Unsigned 149def ICC_CS : ICC_VAL< 5>; // Carry Set/Less Unsigned 150def ICC_POS : ICC_VAL<14>; // Positive 151def ICC_NEG : ICC_VAL< 6>; // Negative 152def ICC_VC : ICC_VAL<15>; // Overflow Clear 153def ICC_VS : ICC_VAL< 7>; // Overflow Set 154 155class FCC_VAL<int N> : PatLeaf<(i32 N)>; 156def FCC_U : FCC_VAL<23>; // Unordered 157def FCC_G : FCC_VAL<22>; // Greater 158def FCC_UG : FCC_VAL<21>; // Unordered or Greater 159def FCC_L : FCC_VAL<20>; // Less 160def FCC_UL : FCC_VAL<19>; // Unordered or Less 161def FCC_LG : FCC_VAL<18>; // Less or Greater 162def FCC_NE : FCC_VAL<17>; // Not Equal 163def FCC_E : FCC_VAL<25>; // Equal 164def FCC_UE : FCC_VAL<24>; // Unordered or Equal 165def FCC_GE : FCC_VAL<25>; // Greater or Equal 166def FCC_UGE : FCC_VAL<26>; // Unordered or Greater or Equal 167def FCC_LE : FCC_VAL<27>; // Less or Equal 168def FCC_ULE : FCC_VAL<28>; // Unordered or Less or Equal 169def FCC_O : FCC_VAL<29>; // Ordered 170 171 172//===----------------------------------------------------------------------===// 173// Instructions 174//===----------------------------------------------------------------------===// 175 176// Pseudo instructions. 177class Pseudo<dag ops, string asmstr, list<dag> pattern> 178 : InstSP<ops, asmstr, pattern>; 179 180def ADJCALLSTACKDOWN : Pseudo<(ops i32imm:$amt), 181 "!ADJCALLSTACKDOWN $amt", 182 [(callseq_start imm:$amt)]>; 183def ADJCALLSTACKUP : Pseudo<(ops i32imm:$amt), 184 "!ADJCALLSTACKUP $amt", 185 [(callseq_end imm:$amt)]>; 186def IMPLICIT_DEF_Int : Pseudo<(ops IntRegs:$dst), 187 "!IMPLICIT_DEF $dst", 188 [(set IntRegs:$dst, (undef))]>; 189def IMPLICIT_DEF_FP : Pseudo<(ops FPRegs:$dst), "!IMPLICIT_DEF $dst", 190 [(set FPRegs:$dst, (undef))]>; 191def IMPLICIT_DEF_DFP : Pseudo<(ops DFPRegs:$dst), "!IMPLICIT_DEF $dst", 192 [(set DFPRegs:$dst, (undef))]>; 193 194// FpMOVD/FpNEGD/FpABSD - These are lowered to single-precision ops by the 195// fpmover pass. 196let Predicates = [HasNoV9] in { // Only emit these in SP mode. 197 def FpMOVD : Pseudo<(ops DFPRegs:$dst, DFPRegs:$src), 198 "!FpMOVD $src, $dst", []>; 199 def FpNEGD : Pseudo<(ops DFPRegs:$dst, DFPRegs:$src), 200 "!FpNEGD $src, $dst", 201 [(set DFPRegs:$dst, (fneg DFPRegs:$src))]>; 202 def FpABSD : Pseudo<(ops DFPRegs:$dst, DFPRegs:$src), 203 "!FpABSD $src, $dst", 204 [(set DFPRegs:$dst, (fabs DFPRegs:$src))]>; 205} 206 207// SELECT_CC_* - Used to implement the SELECT_CC DAG operation. Expanded by the 208// scheduler into a branch sequence. This has to handle all permutations of 209// selection between i32/f32/f64 on ICC and FCC. 210let usesCustomDAGSchedInserter = 1, // Expanded by the scheduler. 211 Predicates = [HasNoV9] in { // V9 has conditional moves 212 def SELECT_CC_Int_ICC 213 : Pseudo<(ops IntRegs:$dst, IntRegs:$T, IntRegs:$F, i32imm:$Cond), 214 "; SELECT_CC_Int_ICC PSEUDO!", 215 [(set IntRegs:$dst, (SPselecticc IntRegs:$T, IntRegs:$F, 216 imm:$Cond, ICC))]>; 217 def SELECT_CC_Int_FCC 218 : Pseudo<(ops IntRegs:$dst, IntRegs:$T, IntRegs:$F, i32imm:$Cond), 219 "; SELECT_CC_Int_FCC PSEUDO!", 220 [(set IntRegs:$dst, (SPselectfcc IntRegs:$T, IntRegs:$F, 221 imm:$Cond, FCC))]>; 222 def SELECT_CC_FP_ICC 223 : Pseudo<(ops FPRegs:$dst, FPRegs:$T, FPRegs:$F, i32imm:$Cond), 224 "; SELECT_CC_FP_ICC PSEUDO!", 225 [(set FPRegs:$dst, (SPselecticc FPRegs:$T, FPRegs:$F, 226 imm:$Cond, ICC))]>; 227 def SELECT_CC_FP_FCC 228 : Pseudo<(ops FPRegs:$dst, FPRegs:$T, FPRegs:$F, i32imm:$Cond), 229 "; SELECT_CC_FP_FCC PSEUDO!", 230 [(set FPRegs:$dst, (SPselectfcc FPRegs:$T, FPRegs:$F, 231 imm:$Cond, FCC))]>; 232 def SELECT_CC_DFP_ICC 233 : Pseudo<(ops DFPRegs:$dst, DFPRegs:$T, DFPRegs:$F, i32imm:$Cond), 234 "; SELECT_CC_DFP_ICC PSEUDO!", 235 [(set DFPRegs:$dst, (SPselecticc DFPRegs:$T, DFPRegs:$F, 236 imm:$Cond, ICC))]>; 237 def SELECT_CC_DFP_FCC 238 : Pseudo<(ops DFPRegs:$dst, DFPRegs:$T, DFPRegs:$F, i32imm:$Cond), 239 "; SELECT_CC_DFP_FCC PSEUDO!", 240 [(set DFPRegs:$dst, (SPselectfcc DFPRegs:$T, DFPRegs:$F, 241 imm:$Cond, FCC))]>; 242} 243 244 245// Section A.3 - Synthetic Instructions, p. 85 246// special cases of JMPL: 247let isReturn = 1, isTerminator = 1, hasDelaySlot = 1, noResults = 1 in { 248 let rd = O7.Num, rs1 = G0.Num, simm13 = 8 in 249 def RETL: F3_2<2, 0b111000, (ops), "retl", [(retflag)]>; 250} 251 252// Section B.1 - Load Integer Instructions, p. 90 253def LDSBrr : F3_1<3, 0b001001, 254 (ops IntRegs:$dst, MEMrr:$addr), 255 "ldsb [$addr], $dst", 256 [(set IntRegs:$dst, (sextload ADDRrr:$addr, i8))]>; 257def LDSBri : F3_2<3, 0b001001, 258 (ops IntRegs:$dst, MEMri:$addr), 259 "ldsb [$addr], $dst", 260 [(set IntRegs:$dst, (sextload ADDRri:$addr, i8))]>; 261def LDSHrr : F3_1<3, 0b001010, 262 (ops IntRegs:$dst, MEMrr:$addr), 263 "ldsh [$addr], $dst", 264 [(set IntRegs:$dst, (sextload ADDRrr:$addr, i16))]>; 265def LDSHri : F3_2<3, 0b001010, 266 (ops IntRegs:$dst, MEMri:$addr), 267 "ldsh [$addr], $dst", 268 [(set IntRegs:$dst, (sextload ADDRri:$addr, i16))]>; 269def LDUBrr : F3_1<3, 0b000001, 270 (ops IntRegs:$dst, MEMrr:$addr), 271 "ldub [$addr], $dst", 272 [(set IntRegs:$dst, (zextload ADDRrr:$addr, i8))]>; 273def LDUBri : F3_2<3, 0b000001, 274 (ops IntRegs:$dst, MEMri:$addr), 275 "ldub [$addr], $dst", 276 [(set IntRegs:$dst, (zextload ADDRri:$addr, i8))]>; 277def LDUHrr : F3_1<3, 0b000010, 278 (ops IntRegs:$dst, MEMrr:$addr), 279 "lduh [$addr], $dst", 280 [(set IntRegs:$dst, (zextload ADDRrr:$addr, i16))]>; 281def LDUHri : F3_2<3, 0b000010, 282 (ops IntRegs:$dst, MEMri:$addr), 283 "lduh [$addr], $dst", 284 [(set IntRegs:$dst, (zextload ADDRri:$addr, i16))]>; 285def LDrr : F3_1<3, 0b000000, 286 (ops IntRegs:$dst, MEMrr:$addr), 287 "ld [$addr], $dst", 288 [(set IntRegs:$dst, (load ADDRrr:$addr))]>; 289def LDri : F3_2<3, 0b000000, 290 (ops IntRegs:$dst, MEMri:$addr), 291 "ld [$addr], $dst", 292 [(set IntRegs:$dst, (load ADDRri:$addr))]>; 293 294// Section B.2 - Load Floating-point Instructions, p. 92 295def LDFrr : F3_1<3, 0b100000, 296 (ops FPRegs:$dst, MEMrr:$addr), 297 "ld [$addr], $dst", 298 [(set FPRegs:$dst, (load ADDRrr:$addr))]>; 299def LDFri : F3_2<3, 0b100000, 300 (ops FPRegs:$dst, MEMri:$addr), 301 "ld [$addr], $dst", 302 [(set FPRegs:$dst, (load ADDRri:$addr))]>; 303def LDDFrr : F3_1<3, 0b100011, 304 (ops DFPRegs:$dst, MEMrr:$addr), 305 "ldd [$addr], $dst", 306 [(set DFPRegs:$dst, (load ADDRrr:$addr))]>; 307def LDDFri : F3_2<3, 0b100011, 308 (ops DFPRegs:$dst, MEMri:$addr), 309 "ldd [$addr], $dst", 310 [(set DFPRegs:$dst, (load ADDRri:$addr))]>; 311 312// Section B.4 - Store Integer Instructions, p. 95 313def STBrr : F3_1<3, 0b000101, 314 (ops MEMrr:$addr, IntRegs:$src), 315 "stb $src, [$addr]", 316 [(truncstore IntRegs:$src, ADDRrr:$addr, i8)]>; 317def STBri : F3_2<3, 0b000101, 318 (ops MEMri:$addr, IntRegs:$src), 319 "stb $src, [$addr]", 320 [(truncstore IntRegs:$src, ADDRri:$addr, i8)]>; 321def STHrr : F3_1<3, 0b000110, 322 (ops MEMrr:$addr, IntRegs:$src), 323 "sth $src, [$addr]", 324 [(truncstore IntRegs:$src, ADDRrr:$addr, i16)]>; 325def STHri : F3_2<3, 0b000110, 326 (ops MEMri:$addr, IntRegs:$src), 327 "sth $src, [$addr]", 328 [(truncstore IntRegs:$src, ADDRri:$addr, i16)]>; 329def STrr : F3_1<3, 0b000100, 330 (ops MEMrr:$addr, IntRegs:$src), 331 "st $src, [$addr]", 332 [(store IntRegs:$src, ADDRrr:$addr)]>; 333def STri : F3_2<3, 0b000100, 334 (ops MEMri:$addr, IntRegs:$src), 335 "st $src, [$addr]", 336 [(store IntRegs:$src, ADDRri:$addr)]>; 337 338// Section B.5 - Store Floating-point Instructions, p. 97 339def STFrr : F3_1<3, 0b100100, 340 (ops MEMrr:$addr, FPRegs:$src), 341 "st $src, [$addr]", 342 [(store FPRegs:$src, ADDRrr:$addr)]>; 343def STFri : F3_2<3, 0b100100, 344 (ops MEMri:$addr, FPRegs:$src), 345 "st $src, [$addr]", 346 [(store FPRegs:$src, ADDRri:$addr)]>; 347def STDFrr : F3_1<3, 0b100111, 348 (ops MEMrr:$addr, DFPRegs:$src), 349 "std $src, [$addr]", 350 [(store DFPRegs:$src, ADDRrr:$addr)]>; 351def STDFri : F3_2<3, 0b100111, 352 (ops MEMri:$addr, DFPRegs:$src), 353 "std $src, [$addr]", 354 [(store DFPRegs:$src, ADDRri:$addr)]>; 355 356// Section B.9 - SETHI Instruction, p. 104 357def SETHIi: F2_1<0b100, 358 (ops IntRegs:$dst, i32imm:$src), 359 "sethi $src, $dst", 360 [(set IntRegs:$dst, SETHIimm:$src)]>; 361 362// Section B.10 - NOP Instruction, p. 105 363// (It's a special case of SETHI) 364let rd = 0, imm22 = 0 in 365 def NOP : F2_1<0b100, (ops), "nop", []>; 366 367// Section B.11 - Logical Instructions, p. 106 368def ANDrr : F3_1<2, 0b000001, 369 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 370 "and $b, $c, $dst", 371 [(set IntRegs:$dst, (and IntRegs:$b, IntRegs:$c))]>; 372def ANDri : F3_2<2, 0b000001, 373 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 374 "and $b, $c, $dst", 375 [(set IntRegs:$dst, (and IntRegs:$b, simm13:$c))]>; 376def ANDNrr : F3_1<2, 0b000101, 377 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 378 "andn $b, $c, $dst", 379 [(set IntRegs:$dst, (and IntRegs:$b, (not IntRegs:$c)))]>; 380def ANDNri : F3_2<2, 0b000101, 381 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 382 "andn $b, $c, $dst", []>; 383def ORrr : F3_1<2, 0b000010, 384 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 385 "or $b, $c, $dst", 386 [(set IntRegs:$dst, (or IntRegs:$b, IntRegs:$c))]>; 387def ORri : F3_2<2, 0b000010, 388 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 389 "or $b, $c, $dst", 390 [(set IntRegs:$dst, (or IntRegs:$b, simm13:$c))]>; 391def ORNrr : F3_1<2, 0b000110, 392 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 393 "orn $b, $c, $dst", 394 [(set IntRegs:$dst, (or IntRegs:$b, (not IntRegs:$c)))]>; 395def ORNri : F3_2<2, 0b000110, 396 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 397 "orn $b, $c, $dst", []>; 398def XORrr : F3_1<2, 0b000011, 399 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 400 "xor $b, $c, $dst", 401 [(set IntRegs:$dst, (xor IntRegs:$b, IntRegs:$c))]>; 402def XORri : F3_2<2, 0b000011, 403 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 404 "xor $b, $c, $dst", 405 [(set IntRegs:$dst, (xor IntRegs:$b, simm13:$c))]>; 406def XNORrr : F3_1<2, 0b000111, 407 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 408 "xnor $b, $c, $dst", 409 [(set IntRegs:$dst, (not (xor IntRegs:$b, IntRegs:$c)))]>; 410def XNORri : F3_2<2, 0b000111, 411 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 412 "xnor $b, $c, $dst", []>; 413 414// Section B.12 - Shift Instructions, p. 107 415def SLLrr : F3_1<2, 0b100101, 416 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 417 "sll $b, $c, $dst", 418 [(set IntRegs:$dst, (shl IntRegs:$b, IntRegs:$c))]>; 419def SLLri : F3_2<2, 0b100101, 420 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 421 "sll $b, $c, $dst", 422 [(set IntRegs:$dst, (shl IntRegs:$b, simm13:$c))]>; 423def SRLrr : F3_1<2, 0b100110, 424 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 425 "srl $b, $c, $dst", 426 [(set IntRegs:$dst, (srl IntRegs:$b, IntRegs:$c))]>; 427def SRLri : F3_2<2, 0b100110, 428 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 429 "srl $b, $c, $dst", 430 [(set IntRegs:$dst, (srl IntRegs:$b, simm13:$c))]>; 431def SRArr : F3_1<2, 0b100111, 432 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 433 "sra $b, $c, $dst", 434 [(set IntRegs:$dst, (sra IntRegs:$b, IntRegs:$c))]>; 435def SRAri : F3_2<2, 0b100111, 436 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 437 "sra $b, $c, $dst", 438 [(set IntRegs:$dst, (sra IntRegs:$b, simm13:$c))]>; 439 440// Section B.13 - Add Instructions, p. 108 441def ADDrr : F3_1<2, 0b000000, 442 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 443 "add $b, $c, $dst", 444 [(set IntRegs:$dst, (add IntRegs:$b, IntRegs:$c))]>; 445def ADDri : F3_2<2, 0b000000, 446 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 447 "add $b, $c, $dst", 448 [(set IntRegs:$dst, (add IntRegs:$b, simm13:$c))]>; 449def ADDCCrr : F3_1<2, 0b010000, 450 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 451 "addcc $b, $c, $dst", []>; 452def ADDCCri : F3_2<2, 0b010000, 453 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 454 "addcc $b, $c, $dst", []>; 455def ADDXrr : F3_1<2, 0b001000, 456 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 457 "addx $b, $c, $dst", []>; 458def ADDXri : F3_2<2, 0b001000, 459 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 460 "addx $b, $c, $dst", []>; 461 462// Section B.15 - Subtract Instructions, p. 110 463def SUBrr : F3_1<2, 0b000100, 464 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 465 "sub $b, $c, $dst", 466 [(set IntRegs:$dst, (sub IntRegs:$b, IntRegs:$c))]>; 467def SUBri : F3_2<2, 0b000100, 468 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 469 "sub $b, $c, $dst", 470 [(set IntRegs:$dst, (sub IntRegs:$b, simm13:$c))]>; 471def SUBXrr : F3_1<2, 0b001100, 472 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 473 "subx $b, $c, $dst", []>; 474def SUBXri : F3_2<2, 0b001100, 475 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 476 "subx $b, $c, $dst", []>; 477def SUBCCrr : F3_1<2, 0b010100, 478 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 479 "subcc $b, $c, $dst", 480 [(set IntRegs:$dst, (SPcmpicc IntRegs:$b, IntRegs:$c))]>; 481def SUBCCri : F3_2<2, 0b010100, 482 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 483 "subcc $b, $c, $dst", 484 [(set IntRegs:$dst, (SPcmpicc IntRegs:$b, simm13:$c))]>; 485def SUBXCCrr: F3_1<2, 0b011100, 486 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 487 "subxcc $b, $c, $dst", []>; 488 489// Section B.18 - Multiply Instructions, p. 113 490def UMULrr : F3_1<2, 0b001010, 491 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 492 "umul $b, $c, $dst", []>; 493def UMULri : F3_2<2, 0b001010, 494 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 495 "umul $b, $c, $dst", []>; 496 497def SMULrr : F3_1<2, 0b001011, 498 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 499 "smul $b, $c, $dst", 500 [(set IntRegs:$dst, (mul IntRegs:$b, IntRegs:$c))]>; 501def SMULri : F3_2<2, 0b001011, 502 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 503 "smul $b, $c, $dst", 504 [(set IntRegs:$dst, (mul IntRegs:$b, simm13:$c))]>; 505 506/* 507//===------------------------- 508// Sparc Example 509defm intinst<id OPC1, id OPC2, bits Opc, string asmstr, SDNode code> { 510 def OPC1 : F3_1<2, Opc, asmstr, (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 511 [(set IntRegs:$dst, (code IntRegs:$b, IntRegs:$c))]>; 512 def OPC2 : F3_2<2, Opc, asmstr, (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 513 [(set IntRegs:$dst, (code IntRegs:$b, simm13:$c))]>; 514} 515defm intinst_np<id OPC1, id OPC2, bits Opc, string asmstr> { 516 def OPC1 : F3_1<2, Opc, asmstr, (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 517 []>; 518 def OPC2 : F3_2<2, Opc, asmstr, (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 519 []>; 520} 521 522def intinstnp< ADDXrr, ADDXri, 0b001000, "addx $b, $c, $dst">; 523def intinst < SUBrr, SUBri, 0b000100, "sub $b, $c, $dst", sub>; 524def intinstnp< SUBXrr, SUBXri, 0b001100, "subx $b, $c, $dst">; 525def intinst <SUBCCrr, SUBCCri, 0b010100, "subcc $b, $c, $dst", SPcmpicc>; 526def intinst < SMULrr, SMULri, 0b001011, "smul $b, $c, $dst", mul>; 527 528//===------------------------- 529// X86 Example 530defm cmov32<id OPC1, id OPC2, int opc, string asmstr, PatLeaf cond> { 531 def OPC1 : I<opc, MRMSrcReg, (ops R32:$dst, R32:$src1, R32:$src2), 532 asmstr+" {$src2, $dst|$dst, $src2}", 533 [(set R32:$dst, (X86cmov R32:$src1, R32:$src2, cond))]>, TB; 534 def OPC2 : I<opc, MRMSrcMem, (ops R32:$dst, R32:$src1, i32mem:$src2), 535 asmstr+" {$src2, $dst|$dst, $src2}", 536 [(set R32:$dst, (X86cmov R32:$src1, 537 (loadi32 addr:$src2), cond))]>, TB; 538} 539 540def cmov<CMOVL32rr, CMOVL32rm, 0x4C, "cmovl", X86_COND_L>; 541def cmov<CMOVB32rr, CMOVB32rm, 0x4C, "cmovb", X86_COND_B>; 542 543//===------------------------- 544// PPC Example 545 546def fpunop<id OPC1, id OPC2, id FORM, int op1, int op2, int op3, string asmstr, 547 SDNode code> { 548 def OPC1 : FORM<op1, op3, (ops F4RC:$frD, F4RC:$frB), 549 asmstr+" $frD, $frB", FPGeneral, 550 [(set F4RC:$frD, (code F4RC:$frB))]>; 551 def OPC2 : FORM<op2, op3, (ops F8RC:$frD, F8RC:$frB), 552 asmstr+" $frD, $frB", FPGeneral, 553 [(set F8RC:$frD, (code F8RC:$frB))]>; 554} 555 556def fpunop< FABSS, FABSD, XForm_26, 63, 63, 264, "fabs", fabs>; 557def fpunop<FNABSS, FNABSD, XForm_26, 63, 63, 136, "fnabs", fnabs>; 558def fpunop< FNEGS, FNEGD, XForm_26, 63, 63, 40, "fneg", fneg>; 559*/ 560 561// Section B.19 - Divide Instructions, p. 115 562def UDIVrr : F3_1<2, 0b001110, 563 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 564 "udiv $b, $c, $dst", []>; 565def UDIVri : F3_2<2, 0b001110, 566 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 567 "udiv $b, $c, $dst", []>; 568def SDIVrr : F3_1<2, 0b001111, 569 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 570 "sdiv $b, $c, $dst", []>; 571def SDIVri : F3_2<2, 0b001111, 572 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 573 "sdiv $b, $c, $dst", []>; 574 575// Section B.20 - SAVE and RESTORE, p. 117 576def SAVErr : F3_1<2, 0b111100, 577 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 578 "save $b, $c, $dst", []>; 579def SAVEri : F3_2<2, 0b111100, 580 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 581 "save $b, $c, $dst", []>; 582def RESTORErr : F3_1<2, 0b111101, 583 (ops IntRegs:$dst, IntRegs:$b, IntRegs:$c), 584 "restore $b, $c, $dst", []>; 585def RESTOREri : F3_2<2, 0b111101, 586 (ops IntRegs:$dst, IntRegs:$b, i32imm:$c), 587 "restore $b, $c, $dst", []>; 588 589// Section B.21 - Branch on Integer Condition Codes Instructions, p. 119 590 591// conditional branch class: 592class BranchSP<bits<4> cc, dag ops, string asmstr, list<dag> pattern> 593 : F2_2<cc, 0b010, ops, asmstr, pattern> { 594 let isBranch = 1; 595 let isTerminator = 1; 596 let hasDelaySlot = 1; 597 let noResults = 1; 598} 599 600let isBarrier = 1 in 601 def BA : BranchSP<0b1000, (ops brtarget:$dst), 602 "ba $dst", 603 [(br bb:$dst)]>; 604 605// FIXME: the encoding for the JIT should look at the condition field. 606def BCOND : BranchSP<0, (ops brtarget:$dst, CCOp:$cc), 607 "b$cc $dst", 608 [(SPbricc bb:$dst, imm:$cc, ICC)]>; 609 610 611// Section B.22 - Branch on Floating-point Condition Codes Instructions, p. 121 612 613// floating-point conditional branch class: 614class FPBranchSP<bits<4> cc, dag ops, string asmstr, list<dag> pattern> 615 : F2_2<cc, 0b110, ops, asmstr, pattern> { 616 let isBranch = 1; 617 let isTerminator = 1; 618 let hasDelaySlot = 1; 619 let noResults = 1; 620} 621 622// FIXME: the encoding for the JIT should look at the condition field. 623def FBCOND : FPBranchSP<0, (ops brtarget:$dst, CCOp:$cc), 624 "fb$cc $dst", 625 [(SPbrfcc bb:$dst, imm:$cc, FCC)]>; 626 627 628// Section B.24 - Call and Link Instruction, p. 125 629// This is the only Format 1 instruction 630let Uses = [O0, O1, O2, O3, O4, O5], 631 hasDelaySlot = 1, isCall = 1, noResults = 1, 632 Defs = [O0, O1, O2, O3, O4, O5, O7, G1, G2, G3, G4, G5, G6, G7, 633 D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15] in { 634 def CALL : InstSP<(ops calltarget:$dst), 635 "call $dst", []> { 636 bits<30> disp; 637 let op = 1; 638 let Inst{29-0} = disp; 639 } 640 641 // indirect calls 642 def JMPLrr : F3_1<2, 0b111000, 643 (ops MEMrr:$ptr), 644 "call $ptr", 645 [(call ADDRrr:$ptr)]>; 646 def JMPLri : F3_2<2, 0b111000, 647 (ops MEMri:$ptr), 648 "call $ptr", 649 [(call ADDRri:$ptr)]>; 650} 651 652// Section B.28 - Read State Register Instructions 653def RDY : F3_1<2, 0b101000, 654 (ops IntRegs:$dst), 655 "rd %y, $dst", []>; 656 657// Section B.29 - Write State Register Instructions 658def WRYrr : F3_1<2, 0b110000, 659 (ops IntRegs:$b, IntRegs:$c), 660 "wr $b, $c, %y", []>; 661def WRYri : F3_2<2, 0b110000, 662 (ops IntRegs:$b, i32imm:$c), 663 "wr $b, $c, %y", []>; 664 665// Convert Integer to Floating-point Instructions, p. 141 666def FITOS : F3_3<2, 0b110100, 0b011000100, 667 (ops FPRegs:$dst, FPRegs:$src), 668 "fitos $src, $dst", 669 [(set FPRegs:$dst, (SPitof FPRegs:$src))]>; 670def FITOD : F3_3<2, 0b110100, 0b011001000, 671 (ops DFPRegs:$dst, FPRegs:$src), 672 "fitod $src, $dst", 673 [(set DFPRegs:$dst, (SPitof FPRegs:$src))]>; 674 675// Convert Floating-point to Integer Instructions, p. 142 676def FSTOI : F3_3<2, 0b110100, 0b011010001, 677 (ops FPRegs:$dst, FPRegs:$src), 678 "fstoi $src, $dst", 679 [(set FPRegs:$dst, (SPftoi FPRegs:$src))]>; 680def FDTOI : F3_3<2, 0b110100, 0b011010010, 681 (ops FPRegs:$dst, DFPRegs:$src), 682 "fdtoi $src, $dst", 683 [(set FPRegs:$dst, (SPftoi DFPRegs:$src))]>; 684 685// Convert between Floating-point Formats Instructions, p. 143 686def FSTOD : F3_3<2, 0b110100, 0b011001001, 687 (ops DFPRegs:$dst, FPRegs:$src), 688 "fstod $src, $dst", 689 [(set DFPRegs:$dst, (fextend FPRegs:$src))]>; 690def FDTOS : F3_3<2, 0b110100, 0b011000110, 691 (ops FPRegs:$dst, DFPRegs:$src), 692 "fdtos $src, $dst", 693 [(set FPRegs:$dst, (fround DFPRegs:$src))]>; 694 695// Floating-point Move Instructions, p. 144 696def FMOVS : F3_3<2, 0b110100, 0b000000001, 697 (ops FPRegs:$dst, FPRegs:$src), 698 "fmovs $src, $dst", []>; 699def FNEGS : F3_3<2, 0b110100, 0b000000101, 700 (ops FPRegs:$dst, FPRegs:$src), 701 "fnegs $src, $dst", 702 [(set FPRegs:$dst, (fneg FPRegs:$src))]>; 703def FABSS : F3_3<2, 0b110100, 0b000001001, 704 (ops FPRegs:$dst, FPRegs:$src), 705 "fabss $src, $dst", 706 [(set FPRegs:$dst, (fabs FPRegs:$src))]>; 707 708 709// Floating-point Square Root Instructions, p.145 710def FSQRTS : F3_3<2, 0b110100, 0b000101001, 711 (ops FPRegs:$dst, FPRegs:$src), 712 "fsqrts $src, $dst", 713 [(set FPRegs:$dst, (fsqrt FPRegs:$src))]>; 714def FSQRTD : F3_3<2, 0b110100, 0b000101010, 715 (ops DFPRegs:$dst, DFPRegs:$src), 716 "fsqrtd $src, $dst", 717 [(set DFPRegs:$dst, (fsqrt DFPRegs:$src))]>; 718 719 720 721// Floating-point Add and Subtract Instructions, p. 146 722def FADDS : F3_3<2, 0b110100, 0b001000001, 723 (ops FPRegs:$dst, FPRegs:$src1, FPRegs:$src2), 724 "fadds $src1, $src2, $dst", 725 [(set FPRegs:$dst, (fadd FPRegs:$src1, FPRegs:$src2))]>; 726def FADDD : F3_3<2, 0b110100, 0b001000010, 727 (ops DFPRegs:$dst, DFPRegs:$src1, DFPRegs:$src2), 728 "faddd $src1, $src2, $dst", 729 [(set DFPRegs:$dst, (fadd DFPRegs:$src1, DFPRegs:$src2))]>; 730def FSUBS : F3_3<2, 0b110100, 0b001000101, 731 (ops FPRegs:$dst, FPRegs:$src1, FPRegs:$src2), 732 "fsubs $src1, $src2, $dst", 733 [(set FPRegs:$dst, (fsub FPRegs:$src1, FPRegs:$src2))]>; 734def FSUBD : F3_3<2, 0b110100, 0b001000110, 735 (ops DFPRegs:$dst, DFPRegs:$src1, DFPRegs:$src2), 736 "fsubd $src1, $src2, $dst", 737 [(set DFPRegs:$dst, (fsub DFPRegs:$src1, DFPRegs:$src2))]>; 738 739// Floating-point Multiply and Divide Instructions, p. 147 740def FMULS : F3_3<2, 0b110100, 0b001001001, 741 (ops FPRegs:$dst, FPRegs:$src1, FPRegs:$src2), 742 "fmuls $src1, $src2, $dst", 743 [(set FPRegs:$dst, (fmul FPRegs:$src1, FPRegs:$src2))]>; 744def FMULD : F3_3<2, 0b110100, 0b001001010, 745 (ops DFPRegs:$dst, DFPRegs:$src1, DFPRegs:$src2), 746 "fmuld $src1, $src2, $dst", 747 [(set DFPRegs:$dst, (fmul DFPRegs:$src1, DFPRegs:$src2))]>; 748def FSMULD : F3_3<2, 0b110100, 0b001101001, 749 (ops DFPRegs:$dst, FPRegs:$src1, FPRegs:$src2), 750 "fsmuld $src1, $src2, $dst", 751 [(set DFPRegs:$dst, (fmul (fextend FPRegs:$src1), 752 (fextend FPRegs:$src2)))]>; 753def FDIVS : F3_3<2, 0b110100, 0b001001101, 754 (ops FPRegs:$dst, FPRegs:$src1, FPRegs:$src2), 755 "fdivs $src1, $src2, $dst", 756 [(set FPRegs:$dst, (fdiv FPRegs:$src1, FPRegs:$src2))]>; 757def FDIVD : F3_3<2, 0b110100, 0b001001110, 758 (ops DFPRegs:$dst, DFPRegs:$src1, DFPRegs:$src2), 759 "fdivd $src1, $src2, $dst", 760 [(set DFPRegs:$dst, (fdiv DFPRegs:$src1, DFPRegs:$src2))]>; 761 762// Floating-point Compare Instructions, p. 148 763// Note: the 2nd template arg is different for these guys. 764// Note 2: the result of a FCMP is not available until the 2nd cycle 765// after the instr is retired, but there is no interlock. This behavior 766// is modelled with a forced noop after the instruction. 767def FCMPS : F3_3<2, 0b110101, 0b001010001, 768 (ops FPRegs:$src1, FPRegs:$src2), 769 "fcmps $src1, $src2\n\tnop", 770 [(set FCC, (SPcmpfcc FPRegs:$src1, FPRegs:$src2))]>; 771def FCMPD : F3_3<2, 0b110101, 0b001010010, 772 (ops DFPRegs:$src1, DFPRegs:$src2), 773 "fcmpd $src1, $src2\n\tnop", 774 [(set FCC, (SPcmpfcc DFPRegs:$src1, DFPRegs:$src2))]>; 775 776 777//===----------------------------------------------------------------------===// 778// V9 Instructions 779//===----------------------------------------------------------------------===// 780 781// V9 Conditional Moves. 782let Predicates = [HasV9], isTwoAddress = 1 in { 783 // Move Integer Register on Condition (MOVcc) p. 194 of the V9 manual. 784 // FIXME: Add instruction encodings for the JIT some day. 785 def MOVICCrr 786 : Pseudo<(ops IntRegs:$dst, IntRegs:$T, IntRegs:$F, CCOp:$cc), 787 "mov$cc %icc, $F, $dst", 788 [(set IntRegs:$dst, 789 (SPselecticc IntRegs:$F, IntRegs:$T, imm:$cc, ICC))]>; 790 def MOVICCri 791 : Pseudo<(ops IntRegs:$dst, IntRegs:$T, i32imm:$F, CCOp:$cc), 792 "mov$cc %icc, $F, $dst", 793 [(set IntRegs:$dst, 794 (SPselecticc simm11:$F, IntRegs:$T, imm:$cc, ICC))]>; 795 796 def MOVFCCrr 797 : Pseudo<(ops IntRegs:$dst, IntRegs:$T, IntRegs:$F, CCOp:$cc), 798 "mov$cc %fcc0, $F, $dst", 799 [(set IntRegs:$dst, 800 (SPselectfcc IntRegs:$F, IntRegs:$T, imm:$cc, FCC))]>; 801 def MOVFCCri 802 : Pseudo<(ops IntRegs:$dst, IntRegs:$T, i32imm:$F, CCOp:$cc), 803 "mov$cc %fcc0, $F, $dst", 804 [(set IntRegs:$dst, 805 (SPselectfcc simm11:$F, IntRegs:$T, imm:$cc, FCC))]>; 806 807 def FMOVS_ICC 808 : Pseudo<(ops FPRegs:$dst, FPRegs:$T, FPRegs:$F, CCOp:$cc), 809 "fmovs$cc %icc, $F, $dst", 810 [(set FPRegs:$dst, 811 (SPselecticc FPRegs:$F, FPRegs:$T, imm:$cc, ICC))]>; 812 def FMOVD_ICC 813 : Pseudo<(ops DFPRegs:$dst, DFPRegs:$T, DFPRegs:$F, CCOp:$cc), 814 "fmovd$cc %icc, $F, $dst", 815 [(set DFPRegs:$dst, 816 (SPselecticc DFPRegs:$F, DFPRegs:$T, imm:$cc, ICC))]>; 817 def FMOVS_FCC 818 : Pseudo<(ops FPRegs:$dst, FPRegs:$T, FPRegs:$F, CCOp:$cc), 819 "fmovs$cc %fcc0, $F, $dst", 820 [(set FPRegs:$dst, 821 (SPselectfcc FPRegs:$F, FPRegs:$T, imm:$cc, FCC))]>; 822 def FMOVD_FCC 823 : Pseudo<(ops DFPRegs:$dst, DFPRegs:$T, DFPRegs:$F, CCOp:$cc), 824 "fmovd$cc %fcc0, $F, $dst", 825 [(set DFPRegs:$dst, 826 (SPselectfcc DFPRegs:$F, DFPRegs:$T, imm:$cc, FCC))]>; 827 828} 829 830// Floating-Point Move Instructions, p. 164 of the V9 manual. 831let Predicates = [HasV9] in { 832 def FMOVD : F3_3<2, 0b110100, 0b000000010, 833 (ops DFPRegs:$dst, DFPRegs:$src), 834 "fmovd $src, $dst", []>; 835 def FNEGD : F3_3<2, 0b110100, 0b000000110, 836 (ops DFPRegs:$dst, DFPRegs:$src), 837 "fnegd $src, $dst", 838 [(set DFPRegs:$dst, (fneg DFPRegs:$src))]>; 839 def FABSD : F3_3<2, 0b110100, 0b000001010, 840 (ops DFPRegs:$dst, DFPRegs:$src), 841 "fabsd $src, $dst", 842 [(set DFPRegs:$dst, (fabs DFPRegs:$src))]>; 843} 844 845// POPCrr - This does a ctpop of a 64-bit register. As such, we have to clear 846// the top 32-bits before using it. To do this clearing, we use a SLLri X,0. 847def POPCrr : F3_1<2, 0b101110, 848 (ops IntRegs:$dst, IntRegs:$src), 849 "popc $src, $dst", []>, Requires<[HasV9]>; 850def : Pat<(ctpop IntRegs:$src), 851 (POPCrr (SLLri IntRegs:$src, 0))>; 852 853//===----------------------------------------------------------------------===// 854// Non-Instruction Patterns 855//===----------------------------------------------------------------------===// 856 857// Small immediates. 858def : Pat<(i32 simm13:$val), 859 (ORri G0, imm:$val)>; 860// Arbitrary immediates. 861def : Pat<(i32 imm:$val), 862 (ORri (SETHIi (HI22 imm:$val)), (LO10 imm:$val))>; 863 864// Global addresses, constant pool entries 865def : Pat<(SPhi tglobaladdr:$in), (SETHIi tglobaladdr:$in)>; 866def : Pat<(SPlo tglobaladdr:$in), (ORri G0, tglobaladdr:$in)>; 867def : Pat<(SPhi tconstpool:$in), (SETHIi tconstpool:$in)>; 868def : Pat<(SPlo tconstpool:$in), (ORri G0, tconstpool:$in)>; 869 870// Add reg, lo. This is used when taking the addr of a global/constpool entry. 871def : Pat<(add IntRegs:$r, (SPlo tglobaladdr:$in)), 872 (ADDri IntRegs:$r, tglobaladdr:$in)>; 873def : Pat<(add IntRegs:$r, (SPlo tconstpool:$in)), 874 (ADDri IntRegs:$r, tconstpool:$in)>; 875 876 877// Calls: 878def : Pat<(call tglobaladdr:$dst), 879 (CALL tglobaladdr:$dst)>; 880def : Pat<(call externalsym:$dst), 881 (CALL externalsym:$dst)>; 882 883def : Pat<(ret), (RETL)>; 884 885// Map integer extload's to zextloads. 886def : Pat<(i32 (extload ADDRrr:$src, i1)), (LDUBrr ADDRrr:$src)>; 887def : Pat<(i32 (extload ADDRri:$src, i1)), (LDUBri ADDRri:$src)>; 888def : Pat<(i32 (extload ADDRrr:$src, i8)), (LDUBrr ADDRrr:$src)>; 889def : Pat<(i32 (extload ADDRri:$src, i8)), (LDUBri ADDRri:$src)>; 890def : Pat<(i32 (extload ADDRrr:$src, i16)), (LDUHrr ADDRrr:$src)>; 891def : Pat<(i32 (extload ADDRri:$src, i16)), (LDUHri ADDRri:$src)>; 892 893// zextload bool -> zextload byte 894def : Pat<(i32 (zextload ADDRrr:$src, i1)), (LDUBrr ADDRrr:$src)>; 895def : Pat<(i32 (zextload ADDRri:$src, i1)), (LDUBri ADDRri:$src)>; 896 897// truncstore bool -> truncstore byte. 898def : Pat<(truncstore IntRegs:$src, ADDRrr:$addr, i1), 899 (STBrr ADDRrr:$addr, IntRegs:$src)>; 900def : Pat<(truncstore IntRegs:$src, ADDRri:$addr, i1), 901 (STBri ADDRri:$addr, IntRegs:$src)>; 902