LLVM API Documentation
00001 //===-- ARMISelDAGToDAG.cpp - A dag to dag inst selector for ARM ----------===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file defines an instruction selector for the ARM target. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #include "ARM.h" 00015 #include "ARMAddressingModes.h" 00016 #include "ARMConstantPoolValue.h" 00017 #include "ARMISelLowering.h" 00018 #include "ARMTargetMachine.h" 00019 #include "llvm/CallingConv.h" 00020 #include "llvm/Constants.h" 00021 #include "llvm/DerivedTypes.h" 00022 #include "llvm/Function.h" 00023 #include "llvm/Intrinsics.h" 00024 #include "llvm/LLVMContext.h" 00025 #include "llvm/CodeGen/MachineFrameInfo.h" 00026 #include "llvm/CodeGen/MachineFunction.h" 00027 #include "llvm/CodeGen/MachineInstrBuilder.h" 00028 #include "llvm/CodeGen/SelectionDAG.h" 00029 #include "llvm/CodeGen/SelectionDAGISel.h" 00030 #include "llvm/Target/TargetLowering.h" 00031 #include "llvm/Target/TargetOptions.h" 00032 #include "llvm/Support/Compiler.h" 00033 #include "llvm/Support/Debug.h" 00034 #include "llvm/Support/ErrorHandling.h" 00035 #include "llvm/Support/raw_ostream.h" 00036 00037 using namespace llvm; 00038 00039 //===--------------------------------------------------------------------===// 00040 /// ARMDAGToDAGISel - ARM specific code to select ARM machine 00041 /// instructions for SelectionDAG operations. 00042 /// 00043 namespace { 00044 class ARMDAGToDAGISel : public SelectionDAGISel { 00045 ARMBaseTargetMachine &TM; 00046 00047 /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can 00048 /// make the right decision when generating code for different targets. 00049 const ARMSubtarget *Subtarget; 00050 00051 public: 00052 explicit ARMDAGToDAGISel(ARMBaseTargetMachine &tm) 00053 : SelectionDAGISel(tm), TM(tm), 00054 Subtarget(&TM.getSubtarget<ARMSubtarget>()) { 00055 } 00056 00057 virtual const char *getPassName() const { 00058 return "ARM Instruction Selection"; 00059 } 00060 00061 /// getI32Imm - Return a target constant with the specified value, of type i32. 00062 inline SDValue getI32Imm(unsigned Imm) { 00063 return CurDAG->getTargetConstant(Imm, MVT::i32); 00064 } 00065 00066 SDNode *Select(SDValue Op); 00067 virtual void InstructionSelect(); 00068 bool SelectShifterOperandReg(SDValue Op, SDValue N, SDValue &A, 00069 SDValue &B, SDValue &C); 00070 bool SelectAddrMode2(SDValue Op, SDValue N, SDValue &Base, 00071 SDValue &Offset, SDValue &Opc); 00072 bool SelectAddrMode2Offset(SDValue Op, SDValue N, 00073 SDValue &Offset, SDValue &Opc); 00074 bool SelectAddrMode3(SDValue Op, SDValue N, SDValue &Base, 00075 SDValue &Offset, SDValue &Opc); 00076 bool SelectAddrMode3Offset(SDValue Op, SDValue N, 00077 SDValue &Offset, SDValue &Opc); 00078 bool SelectAddrMode4(SDValue Op, SDValue N, SDValue &Addr, 00079 SDValue &Mode); 00080 bool SelectAddrMode5(SDValue Op, SDValue N, SDValue &Base, 00081 SDValue &Offset); 00082 bool SelectAddrMode6(SDValue Op, SDValue N, SDValue &Addr, SDValue &Update, 00083 SDValue &Opc); 00084 00085 bool SelectAddrModePC(SDValue Op, SDValue N, SDValue &Offset, 00086 SDValue &Label); 00087 00088 bool SelectThumbAddrModeRR(SDValue Op, SDValue N, SDValue &Base, 00089 SDValue &Offset); 00090 bool SelectThumbAddrModeRI5(SDValue Op, SDValue N, unsigned Scale, 00091 SDValue &Base, SDValue &OffImm, 00092 SDValue &Offset); 00093 bool SelectThumbAddrModeS1(SDValue Op, SDValue N, SDValue &Base, 00094 SDValue &OffImm, SDValue &Offset); 00095 bool SelectThumbAddrModeS2(SDValue Op, SDValue N, SDValue &Base, 00096 SDValue &OffImm, SDValue &Offset); 00097 bool SelectThumbAddrModeS4(SDValue Op, SDValue N, SDValue &Base, 00098 SDValue &OffImm, SDValue &Offset); 00099 bool SelectThumbAddrModeSP(SDValue Op, SDValue N, SDValue &Base, 00100 SDValue &OffImm); 00101 00102 bool SelectT2ShifterOperandReg(SDValue Op, SDValue N, 00103 SDValue &BaseReg, SDValue &Opc); 00104 bool SelectT2AddrModeImm12(SDValue Op, SDValue N, SDValue &Base, 00105 SDValue &OffImm); 00106 bool SelectT2AddrModeImm8(SDValue Op, SDValue N, SDValue &Base, 00107 SDValue &OffImm); 00108 bool SelectT2AddrModeImm8Offset(SDValue Op, SDValue N, 00109 SDValue &OffImm); 00110 bool SelectT2AddrModeImm8s4(SDValue Op, SDValue N, SDValue &Base, 00111 SDValue &OffImm); 00112 bool SelectT2AddrModeSoReg(SDValue Op, SDValue N, SDValue &Base, 00113 SDValue &OffReg, SDValue &ShImm); 00114 00115 // Include the pieces autogenerated from the target description. 00116 #include "ARMGenDAGISel.inc" 00117 00118 private: 00119 /// SelectARMIndexedLoad - Indexed (pre/post inc/dec) load matching code for 00120 /// ARM. 00121 SDNode *SelectARMIndexedLoad(SDValue Op); 00122 SDNode *SelectT2IndexedLoad(SDValue Op); 00123 00124 /// SelectDYN_ALLOC - Select dynamic alloc for Thumb. 00125 SDNode *SelectDYN_ALLOC(SDValue Op); 00126 00127 /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for 00128 /// inline asm expressions. 00129 virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op, 00130 char ConstraintCode, 00131 std::vector<SDValue> &OutOps); 00132 }; 00133 } 00134 00135 void ARMDAGToDAGISel::InstructionSelect() { 00136 DEBUG(BB->dump()); 00137 00138 SelectRoot(*CurDAG); 00139 CurDAG->RemoveDeadNodes(); 00140 } 00141 00142 bool ARMDAGToDAGISel::SelectShifterOperandReg(SDValue Op, 00143 SDValue N, 00144 SDValue &BaseReg, 00145 SDValue &ShReg, 00146 SDValue &Opc) { 00147 ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N); 00148 00149 // Don't match base register only case. That is matched to a separate 00150 // lower complexity pattern with explicit register operand. 00151 if (ShOpcVal == ARM_AM::no_shift) return false; 00152 00153 BaseReg = N.getOperand(0); 00154 unsigned ShImmVal = 0; 00155 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00156 ShReg = CurDAG->getRegister(0, MVT::i32); 00157 ShImmVal = RHS->getZExtValue() & 31; 00158 } else { 00159 ShReg = N.getOperand(1); 00160 } 00161 Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal), 00162 MVT::i32); 00163 return true; 00164 } 00165 00166 bool ARMDAGToDAGISel::SelectAddrMode2(SDValue Op, SDValue N, 00167 SDValue &Base, SDValue &Offset, 00168 SDValue &Opc) { 00169 if (N.getOpcode() == ISD::MUL) { 00170 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00171 // X * [3,5,9] -> X + X * [2,4,8] etc. 00172 int RHSC = (int)RHS->getZExtValue(); 00173 if (RHSC & 1) { 00174 RHSC = RHSC & ~1; 00175 ARM_AM::AddrOpc AddSub = ARM_AM::add; 00176 if (RHSC < 0) { 00177 AddSub = ARM_AM::sub; 00178 RHSC = - RHSC; 00179 } 00180 if (isPowerOf2_32(RHSC)) { 00181 unsigned ShAmt = Log2_32(RHSC); 00182 Base = Offset = N.getOperand(0); 00183 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, 00184 ARM_AM::lsl), 00185 MVT::i32); 00186 return true; 00187 } 00188 } 00189 } 00190 } 00191 00192 if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) { 00193 Base = N; 00194 if (N.getOpcode() == ISD::FrameIndex) { 00195 int FI = cast<FrameIndexSDNode>(N)->getIndex(); 00196 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00197 } else if (N.getOpcode() == ARMISD::Wrapper) { 00198 Base = N.getOperand(0); 00199 } 00200 Offset = CurDAG->getRegister(0, MVT::i32); 00201 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::add, 0, 00202 ARM_AM::no_shift), 00203 MVT::i32); 00204 return true; 00205 } 00206 00207 // Match simple R +/- imm12 operands. 00208 if (N.getOpcode() == ISD::ADD) 00209 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00210 int RHSC = (int)RHS->getZExtValue(); 00211 if ((RHSC >= 0 && RHSC < 0x1000) || 00212 (RHSC < 0 && RHSC > -0x1000)) { // 12 bits. 00213 Base = N.getOperand(0); 00214 if (Base.getOpcode() == ISD::FrameIndex) { 00215 int FI = cast<FrameIndexSDNode>(Base)->getIndex(); 00216 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00217 } 00218 Offset = CurDAG->getRegister(0, MVT::i32); 00219 00220 ARM_AM::AddrOpc AddSub = ARM_AM::add; 00221 if (RHSC < 0) { 00222 AddSub = ARM_AM::sub; 00223 RHSC = - RHSC; 00224 } 00225 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, RHSC, 00226 ARM_AM::no_shift), 00227 MVT::i32); 00228 return true; 00229 } 00230 } 00231 00232 // Otherwise this is R +/- [possibly shifted] R 00233 ARM_AM::AddrOpc AddSub = N.getOpcode() == ISD::ADD ? ARM_AM::add:ARM_AM::sub; 00234 ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(1)); 00235 unsigned ShAmt = 0; 00236 00237 Base = N.getOperand(0); 00238 Offset = N.getOperand(1); 00239 00240 if (ShOpcVal != ARM_AM::no_shift) { 00241 // Check to see if the RHS of the shift is a constant, if not, we can't fold 00242 // it. 00243 if (ConstantSDNode *Sh = 00244 dyn_cast<ConstantSDNode>(N.getOperand(1).getOperand(1))) { 00245 ShAmt = Sh->getZExtValue(); 00246 Offset = N.getOperand(1).getOperand(0); 00247 } else { 00248 ShOpcVal = ARM_AM::no_shift; 00249 } 00250 } 00251 00252 // Try matching (R shl C) + (R). 00253 if (N.getOpcode() == ISD::ADD && ShOpcVal == ARM_AM::no_shift) { 00254 ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(0)); 00255 if (ShOpcVal != ARM_AM::no_shift) { 00256 // Check to see if the RHS of the shift is a constant, if not, we can't 00257 // fold it. 00258 if (ConstantSDNode *Sh = 00259 dyn_cast<ConstantSDNode>(N.getOperand(0).getOperand(1))) { 00260 ShAmt = Sh->getZExtValue(); 00261 Offset = N.getOperand(0).getOperand(0); 00262 Base = N.getOperand(1); 00263 } else { 00264 ShOpcVal = ARM_AM::no_shift; 00265 } 00266 } 00267 } 00268 00269 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal), 00270 MVT::i32); 00271 return true; 00272 } 00273 00274 bool ARMDAGToDAGISel::SelectAddrMode2Offset(SDValue Op, SDValue N, 00275 SDValue &Offset, SDValue &Opc) { 00276 unsigned Opcode = Op.getOpcode(); 00277 ISD::MemIndexedMode AM = (Opcode == ISD::LOAD) 00278 ? cast<LoadSDNode>(Op)->getAddressingMode() 00279 : cast<StoreSDNode>(Op)->getAddressingMode(); 00280 ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC) 00281 ? ARM_AM::add : ARM_AM::sub; 00282 if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) { 00283 int Val = (int)C->getZExtValue(); 00284 if (Val >= 0 && Val < 0x1000) { // 12 bits. 00285 Offset = CurDAG->getRegister(0, MVT::i32); 00286 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val, 00287 ARM_AM::no_shift), 00288 MVT::i32); 00289 return true; 00290 } 00291 } 00292 00293 Offset = N; 00294 ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N); 00295 unsigned ShAmt = 0; 00296 if (ShOpcVal != ARM_AM::no_shift) { 00297 // Check to see if the RHS of the shift is a constant, if not, we can't fold 00298 // it. 00299 if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00300 ShAmt = Sh->getZExtValue(); 00301 Offset = N.getOperand(0); 00302 } else { 00303 ShOpcVal = ARM_AM::no_shift; 00304 } 00305 } 00306 00307 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal), 00308 MVT::i32); 00309 return true; 00310 } 00311 00312 00313 bool ARMDAGToDAGISel::SelectAddrMode3(SDValue Op, SDValue N, 00314 SDValue &Base, SDValue &Offset, 00315 SDValue &Opc) { 00316 if (N.getOpcode() == ISD::SUB) { 00317 // X - C is canonicalize to X + -C, no need to handle it here. 00318 Base = N.getOperand(0); 00319 Offset = N.getOperand(1); 00320 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0),MVT::i32); 00321 return true; 00322 } 00323 00324 if (N.getOpcode() != ISD::ADD) { 00325 Base = N; 00326 if (N.getOpcode() == ISD::FrameIndex) { 00327 int FI = cast<FrameIndexSDNode>(N)->getIndex(); 00328 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00329 } 00330 Offset = CurDAG->getRegister(0, MVT::i32); 00331 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0),MVT::i32); 00332 return true; 00333 } 00334 00335 // If the RHS is +/- imm8, fold into addr mode. 00336 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00337 int RHSC = (int)RHS->getZExtValue(); 00338 if ((RHSC >= 0 && RHSC < 256) || 00339 (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed. 00340 Base = N.getOperand(0); 00341 if (Base.getOpcode() == ISD::FrameIndex) { 00342 int FI = cast<FrameIndexSDNode>(Base)->getIndex(); 00343 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00344 } 00345 Offset = CurDAG->getRegister(0, MVT::i32); 00346 00347 ARM_AM::AddrOpc AddSub = ARM_AM::add; 00348 if (RHSC < 0) { 00349 AddSub = ARM_AM::sub; 00350 RHSC = - RHSC; 00351 } 00352 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC),MVT::i32); 00353 return true; 00354 } 00355 } 00356 00357 Base = N.getOperand(0); 00358 Offset = N.getOperand(1); 00359 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), MVT::i32); 00360 return true; 00361 } 00362 00363 bool ARMDAGToDAGISel::SelectAddrMode3Offset(SDValue Op, SDValue N, 00364 SDValue &Offset, SDValue &Opc) { 00365 unsigned Opcode = Op.getOpcode(); 00366 ISD::MemIndexedMode AM = (Opcode == ISD::LOAD) 00367 ? cast<LoadSDNode>(Op)->getAddressingMode() 00368 : cast<StoreSDNode>(Op)->getAddressingMode(); 00369 ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC) 00370 ? ARM_AM::add : ARM_AM::sub; 00371 if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) { 00372 int Val = (int)C->getZExtValue(); 00373 if (Val >= 0 && Val < 256) { 00374 Offset = CurDAG->getRegister(0, MVT::i32); 00375 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), MVT::i32); 00376 return true; 00377 } 00378 } 00379 00380 Offset = N; 00381 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), MVT::i32); 00382 return true; 00383 } 00384 00385 bool ARMDAGToDAGISel::SelectAddrMode4(SDValue Op, SDValue N, 00386 SDValue &Addr, SDValue &Mode) { 00387 Addr = N; 00388 Mode = CurDAG->getTargetConstant(0, MVT::i32); 00389 return true; 00390 } 00391 00392 bool ARMDAGToDAGISel::SelectAddrMode5(SDValue Op, SDValue N, 00393 SDValue &Base, SDValue &Offset) { 00394 if (N.getOpcode() != ISD::ADD) { 00395 Base = N; 00396 if (N.getOpcode() == ISD::FrameIndex) { 00397 int FI = cast<FrameIndexSDNode>(N)->getIndex(); 00398 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00399 } else if (N.getOpcode() == ARMISD::Wrapper) { 00400 Base = N.getOperand(0); 00401 } 00402 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0), 00403 MVT::i32); 00404 return true; 00405 } 00406 00407 // If the RHS is +/- imm8, fold into addr mode. 00408 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00409 int RHSC = (int)RHS->getZExtValue(); 00410 if ((RHSC & 3) == 0) { // The constant is implicitly multiplied by 4. 00411 RHSC >>= 2; 00412 if ((RHSC >= 0 && RHSC < 256) || 00413 (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed. 00414 Base = N.getOperand(0); 00415 if (Base.getOpcode() == ISD::FrameIndex) { 00416 int FI = cast<FrameIndexSDNode>(Base)->getIndex(); 00417 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00418 } 00419 00420 ARM_AM::AddrOpc AddSub = ARM_AM::add; 00421 if (RHSC < 0) { 00422 AddSub = ARM_AM::sub; 00423 RHSC = - RHSC; 00424 } 00425 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC), 00426 MVT::i32); 00427 return true; 00428 } 00429 } 00430 } 00431 00432 Base = N; 00433 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0), 00434 MVT::i32); 00435 return true; 00436 } 00437 00438 bool ARMDAGToDAGISel::SelectAddrMode6(SDValue Op, SDValue N, 00439 SDValue &Addr, SDValue &Update, 00440 SDValue &Opc) { 00441 Addr = N; 00442 // The optional writeback is handled in ARMLoadStoreOpt. 00443 Update = CurDAG->getRegister(0, MVT::i32); 00444 Opc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(false), MVT::i32); 00445 return true; 00446 } 00447 00448 bool ARMDAGToDAGISel::SelectAddrModePC(SDValue Op, SDValue N, 00449 SDValue &Offset, SDValue &Label) { 00450 if (N.getOpcode() == ARMISD::PIC_ADD && N.hasOneUse()) { 00451 Offset = N.getOperand(0); 00452 SDValue N1 = N.getOperand(1); 00453 Label = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(), 00454 MVT::i32); 00455 return true; 00456 } 00457 return false; 00458 } 00459 00460 bool ARMDAGToDAGISel::SelectThumbAddrModeRR(SDValue Op, SDValue N, 00461 SDValue &Base, SDValue &Offset){ 00462 // FIXME dl should come from the parent load or store, not the address 00463 DebugLoc dl = Op.getDebugLoc(); 00464 if (N.getOpcode() != ISD::ADD) { 00465 ConstantSDNode *NC = dyn_cast<ConstantSDNode>(N); 00466 if (!NC || NC->getZExtValue() != 0) 00467 return false; 00468 00469 Base = Offset = N; 00470 return true; 00471 } 00472 00473 Base = N.getOperand(0); 00474 Offset = N.getOperand(1); 00475 return true; 00476 } 00477 00478 bool 00479 ARMDAGToDAGISel::SelectThumbAddrModeRI5(SDValue Op, SDValue N, 00480 unsigned Scale, SDValue &Base, 00481 SDValue &OffImm, SDValue &Offset) { 00482 if (Scale == 4) { 00483 SDValue TmpBase, TmpOffImm; 00484 if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm)) 00485 return false; // We want to select tLDRspi / tSTRspi instead. 00486 if (N.getOpcode() == ARMISD::Wrapper && 00487 N.getOperand(0).getOpcode() == ISD::TargetConstantPool) 00488 return false; // We want to select tLDRpci instead. 00489 } 00490 00491 if (N.getOpcode() != ISD::ADD) { 00492 Base = (N.getOpcode() == ARMISD::Wrapper) ? N.getOperand(0) : N; 00493 Offset = CurDAG->getRegister(0, MVT::i32); 00494 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00495 return true; 00496 } 00497 00498 // Thumb does not have [sp, r] address mode. 00499 RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0)); 00500 RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(N.getOperand(1)); 00501 if ((LHSR && LHSR->getReg() == ARM::SP) || 00502 (RHSR && RHSR->getReg() == ARM::SP)) { 00503 Base = N; 00504 Offset = CurDAG->getRegister(0, MVT::i32); 00505 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00506 return true; 00507 } 00508 00509 // If the RHS is + imm5 * scale, fold into addr mode. 00510 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00511 int RHSC = (int)RHS->getZExtValue(); 00512 if ((RHSC & (Scale-1)) == 0) { // The constant is implicitly multiplied. 00513 RHSC /= Scale; 00514 if (RHSC >= 0 && RHSC < 32) { 00515 Base = N.getOperand(0); 00516 Offset = CurDAG->getRegister(0, MVT::i32); 00517 OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32); 00518 return true; 00519 } 00520 } 00521 } 00522 00523 Base = N.getOperand(0); 00524 Offset = N.getOperand(1); 00525 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00526 return true; 00527 } 00528 00529 bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDValue Op, SDValue N, 00530 SDValue &Base, SDValue &OffImm, 00531 SDValue &Offset) { 00532 return SelectThumbAddrModeRI5(Op, N, 1, Base, OffImm, Offset); 00533 } 00534 00535 bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDValue Op, SDValue N, 00536 SDValue &Base, SDValue &OffImm, 00537 SDValue &Offset) { 00538 return SelectThumbAddrModeRI5(Op, N, 2, Base, OffImm, Offset); 00539 } 00540 00541 bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDValue Op, SDValue N, 00542 SDValue &Base, SDValue &OffImm, 00543 SDValue &Offset) { 00544 return SelectThumbAddrModeRI5(Op, N, 4, Base, OffImm, Offset); 00545 } 00546 00547 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDValue Op, SDValue N, 00548 SDValue &Base, SDValue &OffImm) { 00549 if (N.getOpcode() == ISD::FrameIndex) { 00550 int FI = cast<FrameIndexSDNode>(N)->getIndex(); 00551 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00552 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00553 return true; 00554 } 00555 00556 if (N.getOpcode() != ISD::ADD) 00557 return false; 00558 00559 RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0)); 00560 if (N.getOperand(0).getOpcode() == ISD::FrameIndex || 00561 (LHSR && LHSR->getReg() == ARM::SP)) { 00562 // If the RHS is + imm8 * scale, fold into addr mode. 00563 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00564 int RHSC = (int)RHS->getZExtValue(); 00565 if ((RHSC & 3) == 0) { // The constant is implicitly multiplied. 00566 RHSC >>= 2; 00567 if (RHSC >= 0 && RHSC < 256) { 00568 Base = N.getOperand(0); 00569 if (Base.getOpcode() == ISD::FrameIndex) { 00570 int FI = cast<FrameIndexSDNode>(Base)->getIndex(); 00571 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00572 } 00573 OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32); 00574 return true; 00575 } 00576 } 00577 } 00578 } 00579 00580 return false; 00581 } 00582 00583 bool ARMDAGToDAGISel::SelectT2ShifterOperandReg(SDValue Op, SDValue N, 00584 SDValue &BaseReg, 00585 SDValue &Opc) { 00586 ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N); 00587 00588 // Don't match base register only case. That is matched to a separate 00589 // lower complexity pattern with explicit register operand. 00590 if (ShOpcVal == ARM_AM::no_shift) return false; 00591 00592 BaseReg = N.getOperand(0); 00593 unsigned ShImmVal = 0; 00594 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00595 ShImmVal = RHS->getZExtValue() & 31; 00596 Opc = getI32Imm(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal)); 00597 return true; 00598 } 00599 00600 return false; 00601 } 00602 00603 bool ARMDAGToDAGISel::SelectT2AddrModeImm12(SDValue Op, SDValue N, 00604 SDValue &Base, SDValue &OffImm) { 00605 // Match simple R + imm12 operands. 00606 00607 // Base only. 00608 if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) { 00609 if (N.getOpcode() == ISD::FrameIndex) { 00610 // Match frame index... 00611 int FI = cast<FrameIndexSDNode>(N)->getIndex(); 00612 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00613 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00614 return true; 00615 } else if (N.getOpcode() == ARMISD::Wrapper) { 00616 Base = N.getOperand(0); 00617 if (Base.getOpcode() == ISD::TargetConstantPool) 00618 return false; // We want to select t2LDRpci instead. 00619 } else 00620 Base = N; 00621 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00622 return true; 00623 } 00624 00625 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00626 if (SelectT2AddrModeImm8(Op, N, Base, OffImm)) 00627 // Let t2LDRi8 handle (R - imm8). 00628 return false; 00629 00630 int RHSC = (int)RHS->getZExtValue(); 00631 if (N.getOpcode() == ISD::SUB) 00632 RHSC = -RHSC; 00633 00634 if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits (unsigned) 00635 Base = N.getOperand(0); 00636 if (Base.getOpcode() == ISD::FrameIndex) { 00637 int FI = cast<FrameIndexSDNode>(Base)->getIndex(); 00638 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00639 } 00640 OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32); 00641 return true; 00642 } 00643 } 00644 00645 // Base only. 00646 Base = N; 00647 OffImm = CurDAG->getTargetConstant(0, MVT::i32); 00648 return true; 00649 } 00650 00651 bool ARMDAGToDAGISel::SelectT2AddrModeImm8(SDValue Op, SDValue N, 00652 SDValue &Base, SDValue &OffImm) { 00653 // Match simple R - imm8 operands. 00654 if (N.getOpcode() == ISD::ADD || N.getOpcode() == ISD::SUB) { 00655 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00656 int RHSC = (int)RHS->getSExtValue(); 00657 if (N.getOpcode() == ISD::SUB) 00658 RHSC = -RHSC; 00659 00660 if ((RHSC >= -255) && (RHSC < 0)) { // 8 bits (always negative) 00661 Base = N.getOperand(0); 00662 if (Base.getOpcode() == ISD::FrameIndex) { 00663 int FI = cast<FrameIndexSDNode>(Base)->getIndex(); 00664 Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00665 } 00666 OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32); 00667 return true; 00668 } 00669 } 00670 } 00671 00672 return false; 00673 } 00674 00675 bool ARMDAGToDAGISel::SelectT2AddrModeImm8Offset(SDValue Op, SDValue N, 00676 SDValue &OffImm){ 00677 unsigned Opcode = Op.getOpcode(); 00678 ISD::MemIndexedMode AM = (Opcode == ISD::LOAD) 00679 ? cast<LoadSDNode>(Op)->getAddressingMode() 00680 : cast<StoreSDNode>(Op)->getAddressingMode(); 00681 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N)) { 00682 int RHSC = (int)RHS->getZExtValue(); 00683 if (RHSC >= 0 && RHSC < 0x100) { // 8 bits. 00684 OffImm = ((AM == ISD::PRE_INC) || (AM == ISD::POST_INC)) 00685 ? CurDAG->getTargetConstant(RHSC, MVT::i32) 00686 : CurDAG->getTargetConstant(-RHSC, MVT::i32); 00687 return true; 00688 } 00689 } 00690 00691 return false; 00692 } 00693 00694 bool ARMDAGToDAGISel::SelectT2AddrModeImm8s4(SDValue Op, SDValue N, 00695 SDValue &Base, SDValue &OffImm) { 00696 if (N.getOpcode() == ISD::ADD) { 00697 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00698 int RHSC = (int)RHS->getZExtValue(); 00699 if (((RHSC & 0x3) == 0) && 00700 ((RHSC >= 0 && RHSC < 0x400) || (RHSC < 0 && RHSC > -0x400))) { // 8 bits. 00701 Base = N.getOperand(0); 00702 OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32); 00703 return true; 00704 } 00705 } 00706 } else if (N.getOpcode() == ISD::SUB) { 00707 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00708 int RHSC = (int)RHS->getZExtValue(); 00709 if (((RHSC & 0x3) == 0) && (RHSC >= 0 && RHSC < 0x400)) { // 8 bits. 00710 Base = N.getOperand(0); 00711 OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32); 00712 return true; 00713 } 00714 } 00715 } 00716 00717 return false; 00718 } 00719 00720 bool ARMDAGToDAGISel::SelectT2AddrModeSoReg(SDValue Op, SDValue N, 00721 SDValue &Base, 00722 SDValue &OffReg, SDValue &ShImm) { 00723 // (R - imm8) should be handled by t2LDRi8. The rest are handled by t2LDRi12. 00724 if (N.getOpcode() != ISD::ADD) 00725 return false; 00726 00727 // Leave (R + imm12) for t2LDRi12, (R - imm8) for t2LDRi8. 00728 if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) { 00729 int RHSC = (int)RHS->getZExtValue(); 00730 if (RHSC >= 0 && RHSC < 0x1000) // 12 bits (unsigned) 00731 return false; 00732 else if (RHSC < 0 && RHSC >= -255) // 8 bits 00733 return false; 00734 } 00735 00736 // Look for (R + R) or (R + (R << [1,2,3])). 00737 unsigned ShAmt = 0; 00738 Base = N.getOperand(0); 00739 OffReg = N.getOperand(1); 00740 00741 // Swap if it is ((R << c) + R). 00742 ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg); 00743 if (ShOpcVal != ARM_AM::lsl) { 00744 ShOpcVal = ARM_AM::getShiftOpcForNode(Base); 00745 if (ShOpcVal == ARM_AM::lsl) 00746 std::swap(Base, OffReg); 00747 } 00748 00749 if (ShOpcVal == ARM_AM::lsl) { 00750 // Check to see if the RHS of the shift is a constant, if not, we can't fold 00751 // it. 00752 if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) { 00753 ShAmt = Sh->getZExtValue(); 00754 if (ShAmt >= 4) { 00755 ShAmt = 0; 00756 ShOpcVal = ARM_AM::no_shift; 00757 } else 00758 OffReg = OffReg.getOperand(0); 00759 } else { 00760 ShOpcVal = ARM_AM::no_shift; 00761 } 00762 } 00763 00764 ShImm = CurDAG->getTargetConstant(ShAmt, MVT::i32); 00765 00766 return true; 00767 } 00768 00769 //===--------------------------------------------------------------------===// 00770 00771 /// getAL - Returns a ARMCC::AL immediate node. 00772 static inline SDValue getAL(SelectionDAG *CurDAG) { 00773 return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, MVT::i32); 00774 } 00775 00776 SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDValue Op) { 00777 LoadSDNode *LD = cast<LoadSDNode>(Op); 00778 ISD::MemIndexedMode AM = LD->getAddressingMode(); 00779 if (AM == ISD::UNINDEXED) 00780 return NULL; 00781 00782 EVT LoadedVT = LD->getMemoryVT(); 00783 SDValue Offset, AMOpc; 00784 bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC); 00785 unsigned Opcode = 0; 00786 bool Match = false; 00787 if (LoadedVT == MVT::i32 && 00788 SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) { 00789 Opcode = isPre ? ARM::LDR_PRE : ARM::LDR_POST; 00790 Match = true; 00791 } else if (LoadedVT == MVT::i16 && 00792 SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) { 00793 Match = true; 00794 Opcode = (LD->getExtensionType() == ISD::SEXTLOAD) 00795 ? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST) 00796 : (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST); 00797 } else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) { 00798 if (LD->getExtensionType() == ISD::SEXTLOAD) { 00799 if (SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) { 00800 Match = true; 00801 Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST; 00802 } 00803 } else { 00804 if (SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) { 00805 Match = true; 00806 Opcode = isPre ? ARM::LDRB_PRE : ARM::LDRB_POST; 00807 } 00808 } 00809 } 00810 00811 if (Match) { 00812 SDValue Chain = LD->getChain(); 00813 SDValue Base = LD->getBasePtr(); 00814 SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG), 00815 CurDAG->getRegister(0, MVT::i32), Chain }; 00816 return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32, 00817 MVT::Other, Ops, 6); 00818 } 00819 00820 return NULL; 00821 } 00822 00823 SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDValue Op) { 00824 LoadSDNode *LD = cast<LoadSDNode>(Op); 00825 ISD::MemIndexedMode AM = LD->getAddressingMode(); 00826 if (AM == ISD::UNINDEXED) 00827 return NULL; 00828 00829 EVT LoadedVT = LD->getMemoryVT(); 00830 bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD; 00831 SDValue Offset; 00832 bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC); 00833 unsigned Opcode = 0; 00834 bool Match = false; 00835 if (SelectT2AddrModeImm8Offset(Op, LD->getOffset(), Offset)) { 00836 switch (LoadedVT.getSimpleVT().SimpleTy) { 00837 case MVT::i32: 00838 Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST; 00839 break; 00840 case MVT::i16: 00841 if (isSExtLd) 00842 Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST; 00843 else 00844 Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST; 00845 break; 00846 case MVT::i8: 00847 case MVT::i1: 00848 if (isSExtLd) 00849 Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST; 00850 else 00851 Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST; 00852 break; 00853 default: 00854 return NULL; 00855 } 00856 Match = true; 00857 } 00858 00859 if (Match) { 00860 SDValue Chain = LD->getChain(); 00861 SDValue Base = LD->getBasePtr(); 00862 SDValue Ops[]= { Base, Offset, getAL(CurDAG), 00863 CurDAG->getRegister(0, MVT::i32), Chain }; 00864 return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32, 00865 MVT::Other, Ops, 5); 00866 } 00867 00868 return NULL; 00869 } 00870 00871 SDNode *ARMDAGToDAGISel::SelectDYN_ALLOC(SDValue Op) { 00872 SDNode *N = Op.getNode(); 00873 DebugLoc dl = N->getDebugLoc(); 00874 EVT VT = Op.getValueType(); 00875 SDValue Chain = Op.getOperand(0); 00876 SDValue Size = Op.getOperand(1); 00877 SDValue Align = Op.getOperand(2); 00878 SDValue SP = CurDAG->getRegister(ARM::SP, MVT::i32); 00879 int32_t AlignVal = cast<ConstantSDNode>(Align)->getSExtValue(); 00880 if (AlignVal < 0) 00881 // We need to align the stack. Use Thumb1 tAND which is the only thumb 00882 // instruction that can read and write SP. This matches to a pseudo 00883 // instruction that has a chain to ensure the result is written back to 00884 // the stack pointer. 00885 SP = SDValue(CurDAG->getTargetNode(ARM::tANDsp, dl, VT, SP, Align), 0); 00886 00887 bool isC = isa<ConstantSDNode>(Size); 00888 uint32_t C = isC ? cast<ConstantSDNode>(Size)->getZExtValue() : ~0UL; 00889 // Handle the most common case for both Thumb1 and Thumb2: 00890 // tSUBspi - immediate is between 0 ... 508 inclusive. 00891 if (C <= 508 && ((C & 3) == 0)) 00892 // FIXME: tSUBspi encode scale 4 implicitly. 00893 return CurDAG->SelectNodeTo(N, ARM::tSUBspi_, VT, MVT::Other, SP, 00894 CurDAG->getTargetConstant(C/4, MVT::i32), 00895 Chain); 00896 00897 if (Subtarget->isThumb1Only()) { 00898 // Use tADDspr since Thumb1 does not have a sub r, sp, r. ARMISelLowering 00899 // should have negated the size operand already. FIXME: We can't insert 00900 // new target independent node at this stage so we are forced to negate 00901 // it earlier. Is there a better solution? 00902 return CurDAG->SelectNodeTo(N, ARM::tADDspr_, VT, MVT::Other, SP, Size, 00903 Chain); 00904 } else if (Subtarget->isThumb2()) { 00905 if (isC && Predicate_t2_so_imm(Size.getNode())) { 00906 // t2SUBrSPi 00907 SDValue Ops[] = { SP, CurDAG->getTargetConstant(C, MVT::i32), Chain }; 00908 return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPi_, VT, MVT::Other, Ops, 3); 00909 } else if (isC && Predicate_imm0_4095(Size.getNode())) { 00910 // t2SUBrSPi12 00911 SDValue Ops[] = { SP, CurDAG->getTargetConstant(C, MVT::i32), Chain }; 00912 return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPi12_, VT, MVT::Other, Ops, 3); 00913 } else { 00914 // t2SUBrSPs 00915 SDValue Ops[] = { SP, Size, 00916 getI32Imm(ARM_AM::getSORegOpc(ARM_AM::lsl,0)), Chain }; 00917 return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPs_, VT, MVT::Other, Ops, 4); 00918 } 00919 } 00920 00921 // FIXME: Add ADD / SUB sp instructions for ARM. 00922 return 0; 00923 } 00924 00925 SDNode *ARMDAGToDAGISel::Select(SDValue Op) { 00926 SDNode *N = Op.getNode(); 00927 DebugLoc dl = N->getDebugLoc(); 00928 00929 if (N->isMachineOpcode()) 00930 return NULL; // Already selected. 00931 00932 switch (N->getOpcode()) { 00933 default: break; 00934 case ISD::Constant: { 00935 unsigned Val = cast<ConstantSDNode>(N)->getZExtValue(); 00936 bool UseCP = true; 00937 if (Subtarget->isThumb()) { 00938 if (Subtarget->hasThumb2()) 00939 // Thumb2 has the MOVT instruction, so all immediates can 00940 // be done with MOV + MOVT, at worst. 00941 UseCP = 0; 00942 else 00943 UseCP = (Val > 255 && // MOV 00944 ~Val > 255 && // MOV + MVN 00945 !ARM_AM::isThumbImmShiftedVal(Val)); // MOV + LSL 00946 } else 00947 UseCP = (ARM_AM::getSOImmVal(Val) == -1 && // MOV 00948 ARM_AM::getSOImmVal(~Val) == -1 && // MVN 00949 !ARM_AM::isSOImmTwoPartVal(Val)); // two instrs. 00950 if (UseCP) { 00951 SDValue CPIdx = 00952 CurDAG->getTargetConstantPool(ConstantInt::get( 00953 Type::getInt32Ty(*CurDAG->getContext()), Val), 00954 TLI.getPointerTy()); 00955 00956 SDNode *ResNode; 00957 if (Subtarget->isThumb1Only()) { 00958 SDValue Pred = CurDAG->getTargetConstant(0xEULL, MVT::i32); 00959 SDValue PredReg = CurDAG->getRegister(0, MVT::i32); 00960 SDValue Ops[] = { CPIdx, Pred, PredReg, CurDAG->getEntryNode() }; 00961 ResNode = CurDAG->getTargetNode(ARM::tLDRcp, dl, MVT::i32, MVT::Other, 00962 Ops, 4); 00963 } else { 00964 SDValue Ops[] = { 00965 CPIdx, 00966 CurDAG->getRegister(0, MVT::i32), 00967 CurDAG->getTargetConstant(0, MVT::i32), 00968 getAL(CurDAG), 00969 CurDAG->getRegister(0, MVT::i32), 00970 CurDAG->getEntryNode() 00971 }; 00972 ResNode=CurDAG->getTargetNode(ARM::LDRcp, dl, MVT::i32, MVT::Other, 00973 Ops, 6); 00974 } 00975 ReplaceUses(Op, SDValue(ResNode, 0)); 00976 return NULL; 00977 } 00978 00979 // Other cases are autogenerated. 00980 break; 00981 } 00982 case ISD::FrameIndex: { 00983 // Selects to ADDri FI, 0 which in turn will become ADDri SP, imm. 00984 int FI = cast<FrameIndexSDNode>(N)->getIndex(); 00985 SDValue TFI = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy()); 00986 if (Subtarget->isThumb1Only()) { 00987 return CurDAG->SelectNodeTo(N, ARM::tADDrSPi, MVT::i32, TFI, 00988 CurDAG->getTargetConstant(0, MVT::i32)); 00989 } else { 00990 unsigned Opc = ((Subtarget->isThumb() && Subtarget->hasThumb2()) ? 00991 ARM::t2ADDri : ARM::ADDri); 00992 SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, MVT::i32), 00993 getAL(CurDAG), CurDAG->getRegister(0, MVT::i32), 00994 CurDAG->getRegister(0, MVT::i32) }; 00995 return CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops, 5); 00996 } 00997 } 00998 case ARMISD::DYN_ALLOC: 00999 return SelectDYN_ALLOC(Op); 01000 case ISD::MUL: 01001 if (Subtarget->isThumb1Only()) 01002 break; 01003 if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) { 01004 unsigned RHSV = C->getZExtValue(); 01005 if (!RHSV) break; 01006 if (isPowerOf2_32(RHSV-1)) { // 2^n+1? 01007 unsigned ShImm = Log2_32(RHSV-1); 01008 if (ShImm >= 32) 01009 break; 01010 SDValue V = Op.getOperand(0); 01011 ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm); 01012 SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32); 01013 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32); 01014 if (Subtarget->isThumb()) { 01015 SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0, Reg0 }; 01016 return CurDAG->SelectNodeTo(N, ARM::t2ADDrs, MVT::i32, Ops, 6); 01017 } else { 01018 SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 }; 01019 return CurDAG->SelectNodeTo(N, ARM::ADDrs, MVT::i32, Ops, 7); 01020 } 01021 } 01022 if (isPowerOf2_32(RHSV+1)) { // 2^n-1? 01023 unsigned ShImm = Log2_32(RHSV+1); 01024 if (ShImm >= 32) 01025 break; 01026 SDValue V = Op.getOperand(0); 01027 ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm); 01028 SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32); 01029 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32); 01030 if (Subtarget->isThumb()) { 01031 SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0 }; 01032 return CurDAG->SelectNodeTo(N, ARM::t2RSBrs, MVT::i32, Ops, 5); 01033 } else { 01034 SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 }; 01035 return CurDAG->SelectNodeTo(N, ARM::RSBrs, MVT::i32, Ops, 7); 01036 } 01037 } 01038 } 01039 break; 01040 case ARMISD::FMRRD: 01041 return CurDAG->getTargetNode(ARM::FMRRD, dl, MVT::i32, MVT::i32, 01042 Op.getOperand(0), getAL(CurDAG), 01043 CurDAG->getRegister(0, MVT::i32)); 01044 case ISD::UMUL_LOHI: { 01045 if (Subtarget->isThumb1Only()) 01046 break; 01047 if (Subtarget->isThumb()) { 01048 SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1), 01049 getAL(CurDAG), CurDAG->getRegister(0, MVT::i32), 01050 CurDAG->getRegister(0, MVT::i32) }; 01051 return CurDAG->getTargetNode(ARM::t2UMULL, dl, MVT::i32, MVT::i32, Ops,4); 01052 } else { 01053 SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1), 01054 getAL(CurDAG), CurDAG->getRegister(0, MVT::i32), 01055 CurDAG->getRegister(0, MVT::i32) }; 01056 return CurDAG->getTargetNode(ARM::UMULL, dl, MVT::i32, MVT::i32, Ops, 5); 01057 } 01058 } 01059 case ISD::SMUL_LOHI: { 01060 if (Subtarget->isThumb1Only()) 01061 break; 01062 if (Subtarget->isThumb()) { 01063 SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1), 01064 getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) }; 01065 return CurDAG->getTargetNode(ARM::t2SMULL, dl, MVT::i32, MVT::i32, Ops,4); 01066 } else { 01067 SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1), 01068 getAL(CurDAG), CurDAG->getRegister(0, MVT::i32), 01069 CurDAG->getRegister(0, MVT::i32) }; 01070 return CurDAG->getTargetNode(ARM::SMULL, dl, MVT::i32, MVT::i32, Ops, 5); 01071 } 01072 } 01073 case ISD::LOAD: { 01074 SDNode *ResNode = 0; 01075 if (Subtarget->isThumb() && Subtarget->hasThumb2()) 01076 ResNode = SelectT2IndexedLoad(Op); 01077 else 01078 ResNode = SelectARMIndexedLoad(Op); 01079 if (ResNode) 01080 return ResNode; 01081 // Other cases are autogenerated. 01082 break; 01083 } 01084 case ARMISD::BRCOND: { 01085 // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc) 01086 // Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc) 01087 // Pattern complexity = 6 cost = 1 size = 0 01088 01089 // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc) 01090 // Emits: (tBcc:void (bb:Other):$dst, (imm:i32):$cc) 01091 // Pattern complexity = 6 cost = 1 size = 0 01092 01093 // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc) 01094 // Emits: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc) 01095 // Pattern complexity = 6 cost = 1 size = 0 01096 01097 unsigned Opc = Subtarget->isThumb() ? 01098 ((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc; 01099 SDValue Chain = Op.getOperand(0); 01100 SDValue N1 = Op.getOperand(1); 01101 SDValue N2 = Op.getOperand(2); 01102 SDValue N3 = Op.getOperand(3); 01103 SDValue InFlag = Op.getOperand(4); 01104 assert(N1.getOpcode() == ISD::BasicBlock); 01105 assert(N2.getOpcode() == ISD::Constant); 01106 assert(N3.getOpcode() == ISD::Register); 01107 01108 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01109 cast<ConstantSDNode>(N2)->getZExtValue()), 01110 MVT::i32); 01111 SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag }; 01112 SDNode *ResNode = CurDAG->getTargetNode(Opc, dl, MVT::Other, 01113 MVT::Flag, Ops, 5); 01114 Chain = SDValue(ResNode, 0); 01115 if (Op.getNode()->getNumValues() == 2) { 01116 InFlag = SDValue(ResNode, 1); 01117 ReplaceUses(SDValue(Op.getNode(), 1), InFlag); 01118 } 01119 ReplaceUses(SDValue(Op.getNode(), 0), SDValue(Chain.getNode(), Chain.getResNo())); 01120 return NULL; 01121 } 01122 case ARMISD::CMOV: { 01123 EVT VT = Op.getValueType(); 01124 SDValue N0 = Op.getOperand(0); 01125 SDValue N1 = Op.getOperand(1); 01126 SDValue N2 = Op.getOperand(2); 01127 SDValue N3 = Op.getOperand(3); 01128 SDValue InFlag = Op.getOperand(4); 01129 assert(N2.getOpcode() == ISD::Constant); 01130 assert(N3.getOpcode() == ISD::Register); 01131 01132 if (!Subtarget->isThumb1Only() && VT == MVT::i32) { 01133 // Pattern: (ARMcmov:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc) 01134 // Emits: (MOVCCs:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc) 01135 // Pattern complexity = 18 cost = 1 size = 0 01136 SDValue CPTmp0; 01137 SDValue CPTmp1; 01138 SDValue CPTmp2; 01139 if (Subtarget->isThumb()) { 01140 if (SelectT2ShifterOperandReg(Op, N1, CPTmp0, CPTmp1)) { 01141 unsigned SOVal = cast<ConstantSDNode>(CPTmp1)->getZExtValue(); 01142 unsigned SOShOp = ARM_AM::getSORegShOp(SOVal); 01143 unsigned Opc = 0; 01144 switch (SOShOp) { 01145 case ARM_AM::lsl: Opc = ARM::t2MOVCClsl; break; 01146 case ARM_AM::lsr: Opc = ARM::t2MOVCClsr; break; 01147 case ARM_AM::asr: Opc = ARM::t2MOVCCasr; break; 01148 case ARM_AM::ror: Opc = ARM::t2MOVCCror; break; 01149 default: 01150 llvm_unreachable("Unknown so_reg opcode!"); 01151 break; 01152 } 01153 SDValue SOShImm = 01154 CurDAG->getTargetConstant(ARM_AM::getSORegOffset(SOVal), MVT::i32); 01155 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01156 cast<ConstantSDNode>(N2)->getZExtValue()), 01157 MVT::i32); 01158 SDValue Ops[] = { N0, CPTmp0, SOShImm, Tmp2, N3, InFlag }; 01159 return CurDAG->SelectNodeTo(Op.getNode(), Opc, MVT::i32,Ops, 6); 01160 } 01161 } else { 01162 if (SelectShifterOperandReg(Op, N1, CPTmp0, CPTmp1, CPTmp2)) { 01163 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01164 cast<ConstantSDNode>(N2)->getZExtValue()), 01165 MVT::i32); 01166 SDValue Ops[] = { N0, CPTmp0, CPTmp1, CPTmp2, Tmp2, N3, InFlag }; 01167 return CurDAG->SelectNodeTo(Op.getNode(), 01168 ARM::MOVCCs, MVT::i32, Ops, 7); 01169 } 01170 } 01171 01172 // Pattern: (ARMcmov:i32 GPR:i32:$false, 01173 // (imm:i32)<<P:Predicate_so_imm>>:$true, 01174 // (imm:i32):$cc) 01175 // Emits: (MOVCCi:i32 GPR:i32:$false, 01176 // (so_imm:i32 (imm:i32):$true), (imm:i32):$cc) 01177 // Pattern complexity = 10 cost = 1 size = 0 01178 if (N3.getOpcode() == ISD::Constant) { 01179 if (Subtarget->isThumb()) { 01180 if (Predicate_t2_so_imm(N3.getNode())) { 01181 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) 01182 cast<ConstantSDNode>(N1)->getZExtValue()), 01183 MVT::i32); 01184 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01185 cast<ConstantSDNode>(N2)->getZExtValue()), 01186 MVT::i32); 01187 SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag }; 01188 return CurDAG->SelectNodeTo(Op.getNode(), 01189 ARM::t2MOVCCi, MVT::i32, Ops, 5); 01190 } 01191 } else { 01192 if (Predicate_so_imm(N3.getNode())) { 01193 SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned) 01194 cast<ConstantSDNode>(N1)->getZExtValue()), 01195 MVT::i32); 01196 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01197 cast<ConstantSDNode>(N2)->getZExtValue()), 01198 MVT::i32); 01199 SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag }; 01200 return CurDAG->SelectNodeTo(Op.getNode(), 01201 ARM::MOVCCi, MVT::i32, Ops, 5); 01202 } 01203 } 01204 } 01205 } 01206 01207 // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc) 01208 // Emits: (MOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc) 01209 // Pattern complexity = 6 cost = 1 size = 0 01210 // 01211 // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc) 01212 // Emits: (tMOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc) 01213 // Pattern complexity = 6 cost = 11 size = 0 01214 // 01215 // Also FCPYScc and FCPYDcc. 01216 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01217 cast<ConstantSDNode>(N2)->getZExtValue()), 01218 MVT::i32); 01219 SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag }; 01220 unsigned Opc = 0; 01221 switch (VT.getSimpleVT().SimpleTy) { 01222 default: assert(false && "Illegal conditional move type!"); 01223 break; 01224 case MVT::i32: 01225 Opc = Subtarget->isThumb() 01226 ? (Subtarget->hasThumb2() ? ARM::t2MOVCCr : ARM::tMOVCCr_pseudo) 01227 : ARM::MOVCCr; 01228 break; 01229 case MVT::f32: 01230 Opc = ARM::FCPYScc; 01231 break; 01232 case MVT::f64: 01233 Opc = ARM::FCPYDcc; 01234 break; 01235 } 01236 return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5); 01237 } 01238 case ARMISD::CNEG: { 01239 EVT VT = Op.getValueType(); 01240 SDValue N0 = Op.getOperand(0); 01241 SDValue N1 = Op.getOperand(1); 01242 SDValue N2 = Op.getOperand(2); 01243 SDValue N3 = Op.getOperand(3); 01244 SDValue InFlag = Op.getOperand(4); 01245 assert(N2.getOpcode() == ISD::Constant); 01246 assert(N3.getOpcode() == ISD::Register); 01247 01248 SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned) 01249 cast<ConstantSDNode>(N2)->getZExtValue()), 01250 MVT::i32); 01251 SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag }; 01252 unsigned Opc = 0; 01253 switch (VT.getSimpleVT().SimpleTy) { 01254 default: assert(false && "Illegal conditional move type!"); 01255 break; 01256 case MVT::f32: 01257 Opc = ARM::FNEGScc; 01258 break; 01259 case MVT::f64: 01260 Opc = ARM::FNEGDcc; 01261 break; 01262 } 01263 return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5); 01264 } 01265 01266 case ISD::DECLARE: { 01267 SDValue Chain = Op.getOperand(0); 01268 SDValue N1 = Op.getOperand(1); 01269 SDValue N2 = Op.getOperand(2); 01270 FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(N1); 01271 // FIXME: handle VLAs. 01272 if (!FINode) { 01273 ReplaceUses(Op.getValue(0), Chain); 01274 return NULL; 01275 } 01276 if (N2.getOpcode() == ARMISD::PIC_ADD && isa<LoadSDNode>(N2.getOperand(0))) 01277 N2 = N2.getOperand(0); 01278 LoadSDNode *Ld = dyn_cast<LoadSDNode>(N2); 01279 if (!Ld) { 01280 ReplaceUses(Op.getValue(0), Chain); 01281 return NULL; 01282 } 01283 SDValue BasePtr = Ld->getBasePtr(); 01284 assert(BasePtr.getOpcode() == ARMISD::Wrapper && 01285 isa<ConstantPoolSDNode>(BasePtr.getOperand(0)) && 01286 "llvm.dbg.variable should be a constantpool node"); 01287 ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(BasePtr.getOperand(0)); 01288 GlobalValue *GV = 0; 01289 if (CP->isMachineConstantPoolEntry()) { 01290 ARMConstantPoolValue *ACPV = (ARMConstantPoolValue*)CP->getMachineCPVal(); 01291 GV = ACPV->getGV(); 01292 } else 01293 GV = dyn_cast<GlobalValue>(CP->getConstVal()); 01294 if (!GV) { 01295 ReplaceUses(Op.getValue(0), Chain); 01296 return NULL; 01297 } 01298 01299 SDValue Tmp1 = CurDAG->getTargetFrameIndex(FINode->getIndex(), 01300 TLI.getPointerTy()); 01301 SDValue Tmp2 = CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy()); 01302 SDValue Ops[] = { Tmp1, Tmp2, Chain }; 01303 return CurDAG->getTargetNode(TargetInstrInfo::DECLARE, dl, 01304 MVT::Other, Ops, 3); 01305 } 01306 01307 case ARMISD::VLD2D: { 01308 SDValue MemAddr, MemUpdate, MemOpc; 01309 if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc)) 01310 return NULL; 01311 unsigned Opc = 0; 01312 EVT VT = Op.getValueType(); 01313 switch (VT.getSimpleVT().SimpleTy) { 01314 default: llvm_unreachable("unhandled VLD2D type"); 01315 case MVT::v8i8: Opc = ARM::VLD2d8; break; 01316 case MVT::v4i16: Opc = ARM::VLD2d16; break; 01317 case MVT::v2f32: 01318 case MVT::v2i32: Opc = ARM::VLD2d32; break; 01319 } 01320 SDValue Chain = N->getOperand(0); 01321 const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain }; 01322 return CurDAG->getTargetNode(Opc, dl, VT, VT, MVT::Other, Ops, 4); 01323 } 01324 01325 case ARMISD::VLD3D: { 01326 SDValue MemAddr, MemUpdate, MemOpc; 01327 if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc)) 01328 return NULL; 01329 unsigned Opc = 0; 01330 EVT VT = Op.getValueType(); 01331 switch (VT.getSimpleVT().SimpleTy) { 01332 default: llvm_unreachable("unhandled VLD3D type"); 01333 case MVT::v8i8: Opc = ARM::VLD3d8; break; 01334 case MVT::v4i16: Opc = ARM::VLD3d16; break; 01335 case MVT::v2f32: 01336 case MVT::v2i32: Opc = ARM::VLD3d32; break; 01337 } 01338 SDValue Chain = N->getOperand(0); 01339 const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain }; 01340 return CurDAG->getTargetNode(Opc, dl, VT, VT, VT, MVT::Other, Ops, 4); 01341 } 01342 01343 case ARMISD::VLD4D: { 01344 SDValue MemAddr, MemUpdate, MemOpc; 01345 if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc)) 01346 return NULL; 01347 unsigned Opc = 0; 01348 EVT VT = Op.getValueType(); 01349 switch (VT.getSimpleVT().SimpleTy) { 01350 default: llvm_unreachable("unhandled VLD4D type"); 01351 case MVT::v8i8: Opc = ARM::VLD4d8; break; 01352 case MVT::v4i16: Opc = ARM::VLD4d16; break; 01353 case MVT::v2f32: 01354 case MVT::v2i32: Opc = ARM::VLD4d32; break; 01355 } 01356 SDValue Chain = N->getOperand(0); 01357 const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain }; 01358 std::vector<EVT> ResTys(4, VT); 01359 ResTys.push_back(MVT::Other); 01360 return CurDAG->getTargetNode(Opc, dl, ResTys, Ops, 4); 01361 } 01362 01363 case ARMISD::VST2D: { 01364 SDValue MemAddr, MemUpdate, MemOpc; 01365 if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc)) 01366 return NULL; 01367 unsigned Opc = 0; 01368 switch (N->getOperand(2).getValueType().getSimpleVT().SimpleTy) { 01369 default: llvm_unreachable("unhandled VST2D type"); 01370 case MVT::v8i8: Opc = ARM::VST2d8; break; 01371 case MVT::v4i16: Opc = ARM::VST2d16; break; 01372 case MVT::v2f32: 01373 case MVT::v2i32: Opc = ARM::VST2d32; break; 01374 } 01375 SDValue Chain = N->getOperand(0); 01376 const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, 01377 N->getOperand(2), N->getOperand(3), Chain }; 01378 return CurDAG->getTargetNode(Opc, dl, MVT::Other, Ops, 6); 01379 } 01380 01381 case ARMISD::VST3D: { 01382 SDValue MemAddr, MemUpdate, MemOpc; 01383 if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc)) 01384 return NULL; 01385 unsigned Opc = 0; 01386 switch (N->getOperand(2).getValueType().getSimpleVT().SimpleTy) { 01387 default: llvm_unreachable("unhandled VST3D type"); 01388 case MVT::v8i8: Opc = ARM::VST3d8; break; 01389 case MVT::v4i16: Opc = ARM::VST3d16; break; 01390 case MVT::v2f32: 01391 case MVT::v2i32: Opc = ARM::VST3d32; break; 01392 } 01393 SDValue Chain = N->getOperand(0); 01394 const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, 01395 N->getOperand(2), N->getOperand(3), 01396 N->getOperand(4), Chain }; 01397 return CurDAG->getTargetNode(Opc, dl, MVT::Other, Ops, 7); 01398 } 01399 01400 case ARMISD::VST4D: { 01401 SDValue MemAddr, MemUpdate, MemOpc; 01402 if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc)) 01403 return NULL; 01404 unsigned Opc = 0; 01405 switch (N->getOperand(2).getValueType().getSimpleVT().SimpleTy) { 01406 default: llvm_unreachable("unhandled VST4D type"); 01407 case MVT::v8i8: Opc = ARM::VST4d8; break; 01408 case MVT::v4i16: Opc = ARM::VST4d16; break; 01409 case MVT::v2f32: 01410 case MVT::v2i32: Opc = ARM::VST4d32; break; 01411 } 01412 SDValue Chain = N->getOperand(0); 01413 const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, 01414 N->getOperand(2), N->getOperand(3), 01415 N->getOperand(4), N->getOperand(5), Chain }; 01416 return CurDAG->getTargetNode(Opc, dl, MVT::Other, Ops, 8); 01417 } 01418 case ARMISD::VZIP: { 01419 unsigned Opc = 0; 01420 EVT VT = N->getValueType(0); 01421 switch (VT.getSimpleVT().SimpleTy) { 01422 default: return NULL; 01423 case MVT::v8i8: Opc = ARM::VZIPd8; break; 01424 case MVT::v4i16: Opc = ARM::VZIPd16; break; 01425 case MVT::v2f32: 01426 case MVT::v2i32: Opc = ARM::VZIPd32; break; 01427 case MVT::v16i8: Opc = ARM::VZIPq8; break; 01428 case MVT::v8i16: Opc = ARM::VZIPq16; break; 01429 case MVT::v4f32: 01430 case MVT::v4i32: Opc = ARM::VZIPq32; break; 01431 } 01432 return CurDAG->getTargetNode(Opc, dl, VT, VT, 01433 N->getOperand(0), N->getOperand(1)); 01434 } 01435 case ARMISD::VUZP: { 01436 unsigned Opc = 0; 01437 EVT VT = N->getValueType(0); 01438 switch (VT.getSimpleVT().SimpleTy) { 01439 default: return NULL; 01440 case MVT::v8i8: Opc = ARM::VUZPd8; break; 01441 case MVT::v4i16: Opc = ARM::VUZPd16; break; 01442 case MVT::v2f32: 01443 case MVT::v2i32: Opc = ARM::VUZPd32; break; 01444 case MVT::v16i8: Opc = ARM::VUZPq8; break; 01445 case MVT::v8i16: Opc = ARM::VUZPq16; break; 01446 case MVT::v4f32: 01447 case MVT::v4i32: Opc = ARM::VUZPq32; break; 01448 } 01449 return CurDAG->getTargetNode(Opc, dl, VT, VT, 01450 N->getOperand(0), N->getOperand(1)); 01451 } 01452 case ARMISD::VTRN: { 01453 unsigned Opc = 0; 01454 EVT VT = N->getValueType(0); 01455 switch (VT.getSimpleVT().SimpleTy) { 01456 default: return NULL; 01457 case MVT::v8i8: Opc = ARM::VTRNd8; break; 01458 case MVT::v4i16: Opc = ARM::VTRNd16; break; 01459 case MVT::v2f32: 01460 case MVT::v2i32: Opc = ARM::VTRNd32; break; 01461 case MVT::v16i8: Opc = ARM::VTRNq8; break; 01462 case MVT::v8i16: Opc = ARM::VTRNq16; break; 01463 case MVT::v4f32: 01464 case MVT::v4i32: Opc = ARM::VTRNq32; break; 01465 } 01466 return CurDAG->getTargetNode(Opc, dl, VT, VT, 01467 N->getOperand(0), N->getOperand(1)); 01468 } 01469 } 01470 01471 return SelectCode(Op); 01472 } 01473 01474 bool ARMDAGToDAGISel:: 01475 SelectInlineAsmMemoryOperand(const SDValue &Op, char ConstraintCode, 01476 std::vector<SDValue> &OutOps) { 01477 assert(ConstraintCode == 'm' && "unexpected asm memory constraint"); 01478 01479 SDValue Base, Offset, Opc; 01480 if (!SelectAddrMode2(Op, Op, Base, Offset, Opc)) 01481 return true; 01482 01483 OutOps.push_back(Base); 01484 OutOps.push_back(Offset); 01485 OutOps.push_back(Opc); 01486 return false; 01487 } 01488 01489 /// createARMISelDag - This pass converts a legalized DAG into a 01490 /// ARM-specific DAG, ready for instruction scheduling. 01491 /// 01492 FunctionPass *llvm::createARMISelDag(ARMBaseTargetMachine &TM) { 01493 return new ARMDAGToDAGISel(TM); 01494 }