FastISel.cpp revision 1d0be15f89cb5056e20e2d24faa8d6afb1573bca
1b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman///===-- FastISel.cpp - Implementation of the FastISel class --------------===// 2b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 3b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// The LLVM Compiler Infrastructure 4b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 5b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// This file is distributed under the University of Illinois Open Source 6b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// License. See LICENSE.TXT for details. 7b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 8b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman//===----------------------------------------------------------------------===// 9b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 10b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// This file contains the implementation of the FastISel class. 11b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 125ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// "Fast" instruction selection is designed to emit very poor code quickly. 135ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// Also, it is not designed to be able to do much lowering, so most illegal 1444d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// types (e.g. i64 on 32-bit targets) and operations are not supported. It is 1544d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// also not intended to be able to do much optimization, except in a few cases 1644d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// where doing optimizations reduces overall compile time. For example, folding 1744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// constants into immediate fields is often done, because it's cheap and it 1844d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// reduces the number of instructions later phases have to examine. 195ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 205ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// "Fast" instruction selection is able to fail gracefully and transfer 215ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// control to the SelectionDAG selector for operations that it doesn't 2244d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// support. In many cases, this allows us to avoid duplicating a lot of 235ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// the complicated lowering logic that SelectionDAG currently has. 245ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 255ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// The intended use for "fast" instruction selection is "-O0" mode 265ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// compilation, where the quality of the generated code is irrelevant when 2744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// weighed against the speed at which the code can be generated. Also, 285ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// at -O0, the LLVM optimizers are not running, and this makes the 295ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// compile time of codegen a much higher portion of the overall compile 3044d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// time. Despite its limitations, "fast" instruction selection is able to 315ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// handle enough code on its own to provide noticeable overall speedups 325ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// in -O0 compiles. 335ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 345ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// Basic operations are supported in a target-independent way, by reading 355ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// the same instruction descriptions that the SelectionDAG selector reads, 365ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// and identifying simple arithmetic operations that can be directly selected 3744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// from simple operators. More complicated operations currently require 385ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// target-specific code. 395ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 40b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman//===----------------------------------------------------------------------===// 41b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 4233134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/Function.h" 4333134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/GlobalVariable.h" 446f2766d59744bb3d48867f3151643eac7111e773Dan Gohman#include "llvm/Instructions.h" 4533134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/IntrinsicInst.h" 46b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/FastISel.h" 47b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineInstrBuilder.h" 4833134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/CodeGen/MachineModuleInfo.h" 49b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineRegisterInfo.h" 5083489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/CodeGen/DwarfWriter.h" 5183489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/Analysis/DebugInfo.h" 5283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetData.h" 53b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 5483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 55bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 56dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#include "SelectionDAGBuild.h" 57b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 58b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 593df24e667f04a7003342b534310919abc9c87418Dan Gohmanunsigned FastISel::getRegForValue(Value *V) { 60e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 614fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 624fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 634fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 64821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 65c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 66c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 67c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 68825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 69821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 70825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // Promote MVT::i1 to a legal type though, because it's common and easy. 71825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1) 7223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 73821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 74821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 75821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 76821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 77c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Look up the value to see if we already have a register for it. We 78c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // cache values defined by Instructions across blocks, and other values 79c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // only locally. This is because Instructions already have the SSA 80c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // def-dominatess-use requirement enforced. 81c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (ValueMap.count(V)) 82c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return ValueMap[V]; 83c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned Reg = LocalValueMap[V]; 84c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 85c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 86c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 87ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 882ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 892ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 900586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 912ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 92205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 931e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 941e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 951d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 961d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 97ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 98104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 99ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 100ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 101ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 102e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 103ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 104ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 105ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 10623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 10723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 10823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 10923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 1102ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman APInt IntVal(IntBitWidth, 2, x); 111ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 112e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 113eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 1142ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 1152ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, IntegerReg); 1162ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 117ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 11840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 11940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!SelectOperator(CE, CE->getOpcode())) return 0; 12040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman Reg = LocalValueMap[CE]; 121205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 122104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 1239bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, TII.get(TargetInstrInfo::IMPLICIT_DEF), Reg); 124ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 125d5d81a457b5ff758b3fcc527af38827490bc68a5Owen Anderson 126dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 127dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 1286e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 1292ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 1306e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson 1312ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 1322ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 133dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman if (Reg != 0) 134dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 135104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 136ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 137ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 13859fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Chengunsigned FastISel::lookUpRegForValue(Value *V) { 13959fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 14059fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 14159fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 14259fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // def-dominatess-use requirement enforced. 14359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng if (ValueMap.count(V)) 14459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return ValueMap[V]; 14559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return LocalValueMap[V]; 14659fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 14759fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 148cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 149cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 150cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 151cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 152cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 153cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 154c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattnerunsigned FastISel::UpdateValueMap(Value* I, unsigned Reg) { 15540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 15640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 157c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return Reg; 158c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 159c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner 160c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner unsigned &AssignedReg = ValueMap[I]; 161c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 162c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 16336e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 164c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner const TargetRegisterClass *RegClass = MRI.getRegClass(Reg); 165c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner TII.copyRegToReg(*MBB, MBB->end(), AssignedReg, 166c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner Reg, RegClass, RegClass); 16740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 168c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return AssignedReg; 169cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 170cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 171c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohmanunsigned FastISel::getRegForGEPIndex(Value *Idx) { 172c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 173c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 174c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 175c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return 0; 176c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 177c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 178766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 179e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 180c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxVT.bitsLT(PtrVT)) 181766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, IdxN); 182c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman else if (IdxVT.bitsGT(PtrVT)) 183766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, IdxN); 184c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return IdxN; 185c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 186c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 187bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 188bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 189bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 19040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectBinaryOp(User *I, ISD::NodeType ISDOpcode) { 191e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 192825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::Other || !VT.isSimple()) 193d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 194d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 195638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 196b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 197b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 198b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 199b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 200638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 201825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 202638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 203825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 2045dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 2055dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 20623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), VT); 207638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 208638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 209638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 210d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 2113df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 212d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op0 == 0) 213a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman // Unhandled operand. Halt "fast" selection and bail. 214a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 215a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 216d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 217d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 218ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_ri(VT.getSimpleVT(), VT.getSimpleVT(), 219ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISDOpcode, Op0, CI->getZExtValue()); 220ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 221ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 2223df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 223ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 224ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 225d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 226d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 22710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 22810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 229ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 230ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISDOpcode, Op0, CF); 231ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 232ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 2333df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 234ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 235ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 23610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 23710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 2383df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 239d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 240d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 241bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 242bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 243ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 2440f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 2450f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISDOpcode, Op0, Op1); 246bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 247bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 248bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 249bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 250bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 2518014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 2523df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 253bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 254bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 255bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 25640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectGetElementPtr(User *I) { 2573df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 25883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 25983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 26083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 26183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 26283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng const Type *Ty = I->getOperand(0)->getType(); 263825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 26483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng for (GetElementPtrInst::op_iterator OI = I->op_begin()+1, E = I->op_end(); 26583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng OI != E; ++OI) { 26683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Value *Idx = *OI; 26783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 26883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 26983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 27083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 27183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng uint64_t Offs = TD.getStructLayout(StTy)->getElementOffset(Field); 27283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // FIXME: This can be optimized by combining the add with a 27383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // subsequent one. 2747a0e6593d03bd2dd21c3ac7dcf189f1da86b16daDan Gohman N = FastEmit_ri_(VT, ISD::ADD, N, Offs, VT); 27583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 27683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 27783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 27883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 27983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 28083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 28183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 28283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 28383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 28483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 28583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (CI->getZExtValue() == 0) continue; 28683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng uint64_t Offs = 287777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 2887a0e6593d03bd2dd21c3ac7dcf189f1da86b16daDan Gohman N = FastEmit_ri_(VT, ISD::ADD, N, Offs, VT); 28983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 29083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 29183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 29283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng continue; 29383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 29483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 29583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 296777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 297c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForGEPIndex(Idx); 29883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 29983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 30083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 30183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 30280bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 303f93cf79505f07cb97597fbc5955462ad7670ca5cDan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, ElementSize, VT); 30480bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 30580bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 30680bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 30780bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 3080f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson N = FastEmit_rr(VT, VT, ISD::ADD, N, IdxN); 30983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 31083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 31183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 31283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 31383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 31483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 31583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 3163df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 31783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 318bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 319bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 32033134c4a75558288d663267c8991f6bd37a530afDan Gohmanbool FastISel::SelectCall(User *I) { 32133134c4a75558288d663267c8991f6bd37a530afDan Gohman Function *F = cast<CallInst>(I)->getCalledFunction(); 32233134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 32333134c4a75558288d663267c8991f6bd37a530afDan Gohman 32433134c4a75558288d663267c8991f6bd37a530afDan Gohman unsigned IID = F->getIntrinsicID(); 32533134c4a75558288d663267c8991f6bd37a530afDan Gohman switch (IID) { 32633134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 32733134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_stoppoint: { 32833134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgStopPointInst *SPI = cast<DbgStopPointInst>(I); 3297e1e31f467d87c834d8baf673929865907901313Devang Patel if (isValidDebugInfoIntrinsic(*SPI, CodeGenOpt::None)) 3307e1e31f467d87c834d8baf673929865907901313Devang Patel setCurDebugLoc(ExtractDebugLocation(*SPI, MF.getDebugLocInfo())); 33133134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 33233134c4a75558288d663267c8991f6bd37a530afDan Gohman } 33333134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_region_start: { 33433134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgRegionStartInst *RSI = cast<DbgRegionStartInst>(I); 3357e1e31f467d87c834d8baf673929865907901313Devang Patel if (isValidDebugInfoIntrinsic(*RSI, CodeGenOpt::None) && DW 3367e1e31f467d87c834d8baf673929865907901313Devang Patel && DW->ShouldEmitDwarfDebug()) { 337df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling unsigned ID = 338df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling DW->RecordRegionStart(cast<GlobalVariable>(RSI->getContext())); 33992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 34092c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling BuildMI(MBB, DL, II).addImm(ID); 34192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 34233134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 34333134c4a75558288d663267c8991f6bd37a530afDan Gohman } 34433134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_region_end: { 34533134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgRegionEndInst *REI = cast<DbgRegionEndInst>(I); 3467e1e31f467d87c834d8baf673929865907901313Devang Patel if (isValidDebugInfoIntrinsic(*REI, CodeGenOpt::None) && DW 3477e1e31f467d87c834d8baf673929865907901313Devang Patel && DW->ShouldEmitDwarfDebug()) { 3481be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel unsigned ID = 0; 349df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling DISubprogram Subprogram(cast<GlobalVariable>(REI->getContext())); 3507e1e31f467d87c834d8baf673929865907901313Devang Patel if (isInlinedFnEnd(*REI, MF.getFunction())) { 3511be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel // This is end of an inlined function. 3521be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 3531be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel ID = DW->RecordInlinedFnEnd(Subprogram); 3548818b8f4437a56fc8f75a134f015c3b807e61f10Devang Patel if (ID) 35502f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // Returned ID is 0 if this is unbalanced "end of inlined 35602f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // scope". This could happen if optimizer eats dbg intrinsics 35702f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // or "beginning of inlined scope" is not recoginized due to 35811a407f43fc0fb21df3156350175eaeeffaf7085Devang Patel // missing location info. In such cases, ignore this region.end. 3598818b8f4437a56fc8f75a134f015c3b807e61f10Devang Patel BuildMI(MBB, DL, II).addImm(ID); 3601be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel } else { 3611be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 3629a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman ID = DW->RecordRegionEnd(cast<GlobalVariable>(REI->getContext())); 3631be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel BuildMI(MBB, DL, II).addImm(ID); 3641be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel } 36592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 36633134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 36733134c4a75558288d663267c8991f6bd37a530afDan Gohman } 36833134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_func_start: { 36933134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgFuncStartInst *FSI = cast<DbgFuncStartInst>(I); 3707e1e31f467d87c834d8baf673929865907901313Devang Patel if (!isValidDebugInfoIntrinsic(*FSI, CodeGenOpt::None) || !DW 3717e1e31f467d87c834d8baf673929865907901313Devang Patel || !DW->ShouldEmitDwarfDebug()) 37277eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis return true; 3739bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling 3747e1e31f467d87c834d8baf673929865907901313Devang Patel if (isInlinedFnStart(*FSI, MF.getFunction())) { 37577eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // This is a beginning of an inlined function. 3767e1e31f467d87c834d8baf673929865907901313Devang Patel 37777eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // If llvm.dbg.func.start is seen in a new block before any 37877eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // llvm.dbg.stoppoint intrinsic then the location info is unknown. 37977eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // FIXME : Why DebugLoc is reset at the beginning of each block ? 3806d8f1263f40e6b8fc2cd5cce3dfd9ce99fe09226Devang Patel DebugLoc PrevLoc = DL; 38177eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (PrevLoc.isUnknown()) 38277eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis return true; 38377eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // Record the source line. 3847e1e31f467d87c834d8baf673929865907901313Devang Patel setCurDebugLoc(ExtractDebugLocation(*FSI, MF.getDebugLocInfo())); 3857e1e31f467d87c834d8baf673929865907901313Devang Patel 3867e1e31f467d87c834d8baf673929865907901313Devang Patel DebugLocTuple PrevLocTpl = MF.getDebugLocTuple(PrevLoc); 3877e1e31f467d87c834d8baf673929865907901313Devang Patel DISubprogram SP(cast<GlobalVariable>(FSI->getSubprogram())); 3887e1e31f467d87c834d8baf673929865907901313Devang Patel unsigned LabelID = DW->RecordInlinedFnStart(SP, 3897e1e31f467d87c834d8baf673929865907901313Devang Patel DICompileUnit(PrevLocTpl.CompileUnit), 3907e1e31f467d87c834d8baf673929865907901313Devang Patel PrevLocTpl.Line, 3917e1e31f467d87c834d8baf673929865907901313Devang Patel PrevLocTpl.Col); 3927e1e31f467d87c834d8baf673929865907901313Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 3937e1e31f467d87c834d8baf673929865907901313Devang Patel BuildMI(MBB, DL, II).addImm(LabelID); 3946d8f1263f40e6b8fc2cd5cce3dfd9ce99fe09226Devang Patel return true; 39533134c4a75558288d663267c8991f6bd37a530afDan Gohman } 3967e1e31f467d87c834d8baf673929865907901313Devang Patel 3976d8f1263f40e6b8fc2cd5cce3dfd9ce99fe09226Devang Patel // This is a beginning of a new function. 3987e1e31f467d87c834d8baf673929865907901313Devang Patel MF.setDefaultDebugLoc(ExtractDebugLocation(*FSI, MF.getDebugLocInfo())); 3996d8f1263f40e6b8fc2cd5cce3dfd9ce99fe09226Devang Patel 4007e1e31f467d87c834d8baf673929865907901313Devang Patel // llvm.dbg.func_start also defines beginning of function scope. 4017e1e31f467d87c834d8baf673929865907901313Devang Patel DW->RecordRegionStart(cast<GlobalVariable>(FSI->getSubprogram())); 40233134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 40333134c4a75558288d663267c8991f6bd37a530afDan Gohman } 40492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 40592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DbgDeclareInst *DI = cast<DbgDeclareInst>(I); 4067e1e31f467d87c834d8baf673929865907901313Devang Patel if (!isValidDebugInfoIntrinsic(*DI, CodeGenOpt::None) || !DW 4077e1e31f467d87c834d8baf673929865907901313Devang Patel || !DW->ShouldEmitDwarfDebug()) 4087e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 40992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 4107e1e31f467d87c834d8baf673929865907901313Devang Patel Value *Variable = DI->getVariable(); 4117e1e31f467d87c834d8baf673929865907901313Devang Patel Value *Address = DI->getAddress(); 4127e1e31f467d87c834d8baf673929865907901313Devang Patel if (BitCastInst *BCI = dyn_cast<BitCastInst>(Address)) 4137e1e31f467d87c834d8baf673929865907901313Devang Patel Address = BCI->getOperand(0); 4147e1e31f467d87c834d8baf673929865907901313Devang Patel AllocaInst *AI = dyn_cast<AllocaInst>(Address); 4157e1e31f467d87c834d8baf673929865907901313Devang Patel // Don't handle byval struct arguments or VLAs, for example. 4167e1e31f467d87c834d8baf673929865907901313Devang Patel if (!AI) break; 4177e1e31f467d87c834d8baf673929865907901313Devang Patel DenseMap<const AllocaInst*, int>::iterator SI = 4187e1e31f467d87c834d8baf673929865907901313Devang Patel StaticAllocaMap.find(AI); 4197e1e31f467d87c834d8baf673929865907901313Devang Patel if (SI == StaticAllocaMap.end()) break; // VLAs. 4207e1e31f467d87c834d8baf673929865907901313Devang Patel int FI = SI->second; 4217e1e31f467d87c834d8baf673929865907901313Devang Patel 4227e1e31f467d87c834d8baf673929865907901313Devang Patel // Determine the debug globalvariable. 4237e1e31f467d87c834d8baf673929865907901313Devang Patel GlobalValue *GV = cast<GlobalVariable>(Variable); 4247e1e31f467d87c834d8baf673929865907901313Devang Patel 4257e1e31f467d87c834d8baf673929865907901313Devang Patel // Build the DECLARE instruction. 4267e1e31f467d87c834d8baf673929865907901313Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DECLARE); 4277e1e31f467d87c834d8baf673929865907901313Devang Patel MachineInstr *DeclareMI 4287e1e31f467d87c834d8baf673929865907901313Devang Patel = BuildMI(MBB, DL, II).addFrameIndex(FI).addGlobalAddress(GV); 4297e1e31f467d87c834d8baf673929865907901313Devang Patel DIVariable DV(cast<GlobalVariable>(GV)); 4307e1e31f467d87c834d8baf673929865907901313Devang Patel DW->RecordVariableScope(DV, DeclareMI); 43133134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 43292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 433dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_exception: { 434e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = TLI.getValueType(I->getType()); 435dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EXCEPTIONADDR, VT)) { 436dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 437dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 438b0f1e1780c736c62fb99e5824825d2a60a53b53bDuncan Sands assert(MBB->isLandingPad() && "Call to eh.exception not in landing pad!"); 439dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionAddressRegister(); 440dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetRegisterClass *RC = TLI.getRegClassFor(VT); 441dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 442dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 443dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman Reg, RC, RC); 444dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman assert(InsertedCopy && "Can't copy address registers!"); 44524ac408ce891321d1a5d62beaf3487efce6f2b22Evan Cheng InsertedCopy = InsertedCopy; 446dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 447dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 448dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 449dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 450dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 451dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 452dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_selector_i32: 453dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_selector_i64: { 454e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = TLI.getValueType(I->getType()); 455dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EHSELECTION, VT)) { 456dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 457dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 458e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = (IID == Intrinsic::eh_selector_i32 ? 459825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::i32 : MVT::i64); 460dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 461dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MMI) { 462dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MBB->isLandingPad()) 463dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman AddCatchInfo(*cast<CallInst>(I), MMI, MBB); 464dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman else { 465dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 466dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman CatchInfoLost.insert(cast<CallInst>(I)); 467dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 468dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // FIXME: Mark exception selector register as live in. Hack for PR1508. 469dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 470dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (Reg) MBB->addLiveIn(Reg); 471dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 472dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 473dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 474dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetRegisterClass *RC = TLI.getRegClassFor(VT); 475dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 476dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 477dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman Reg, RC, RC); 478dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman assert(InsertedCopy && "Can't copy address registers!"); 47924ac408ce891321d1a5d62beaf3487efce6f2b22Evan Cheng InsertedCopy = InsertedCopy; 480dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 481dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } else { 482dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = 483a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson getRegForValue(Constant::getNullValue(I->getType())); 484dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 485dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 486dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 487dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 488dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 489dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 490dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 49133134c4a75558288d663267c8991f6bd37a530afDan Gohman } 49233134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 49333134c4a75558288d663267c8991f6bd37a530afDan Gohman} 49433134c4a75558288d663267c8991f6bd37a530afDan Gohman 49540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectCast(User *I, ISD::NodeType Opcode) { 496e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 497e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 498d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 499825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 500825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 501d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 502d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 503d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 504474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Check if the destination type is legal. Or as a special case, 505474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // it may be i1 if we're doing a truncate because that's 506474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 507474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 508825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DstVT != MVT::i1 || Opcode != ISD::TRUNCATE) 509474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Unhandled type. Halt "fast" selection and bail. 510474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman return false; 511474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 51291b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Check if the source operand is legal. Or as a special case, 51391b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // it may be i1 if we're doing zero-extension because that's 514474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 515474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 516825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT != MVT::i1 || Opcode != ISD::ZERO_EXTEND) 51791b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Unhandled type. Halt "fast" selection and bail. 51891b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman return false; 519474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 5203df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 521d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 522d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 523d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 52414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 52514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman // If the operand is i1, arrange for the high bits in the register to be zero. 526825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::i1) { 52723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson SrcVT = TLI.getTypeToTransformTo(I->getContext(), SrcVT); 52814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman InputReg = FastEmitZExtFromI1(SrcVT.getSimpleVT(), InputReg); 52914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman if (!InputReg) 53014ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return false; 53114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman } 532474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // If the result is i1, truncate to the target's type for i1 first. 533825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DstVT == MVT::i1) 53423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson DstVT = TLI.getTypeToTransformTo(I->getContext(), DstVT); 53514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 536d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 537d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 538d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 539d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson InputReg); 540d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 541d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 542d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5433df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 544d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 545d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 546d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 54740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectBitCast(User *I) { 548ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 549ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 5503df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 551a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 552a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 5533df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 554ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 555ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 556ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 557ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Bitcasts of other values become reg-reg copies or BIT_CONVERT operators. 558e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 559e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 560d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 561825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 562825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple() || 563d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 564d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 565d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 566d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5673df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 568ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 569ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 570d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 571d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 572ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 573ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 574ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) { 575ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 576ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 577ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = createResultReg(DstClass); 578ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 579ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 580ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman Op0, DstClass, SrcClass); 581ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!InsertedCopy) 582ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = 0; 583ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 584ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 585ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the reg-reg copy failed, select a BIT_CONVERT opcode. 586ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 587ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), 588ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISD::BIT_CONVERT, Op0); 589ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 590ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 591d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 592d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5933df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 594d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 595d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 596d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5973df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 5983df24e667f04a7003342b534310919abc9c87418Dan GohmanFastISel::SelectInstruction(Instruction *I) { 59940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman return SelectOperator(I, I->getOpcode()); 60040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 60140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 602d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 603d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 604d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 605d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 606d98d6203e429b2d7208b6687931e9079e85e95ecDan GohmanFastISel::FastEmitBranch(MachineBasicBlock *MSucc) { 607d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman MachineFunction::iterator NextMBB = 608d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman next(MachineFunction::iterator(MBB)); 609d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 610d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman if (MBB->isLayoutSuccessor(MSucc)) { 611d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional fall-through case, which needs no instructions. 612d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 613d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 614d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman TII.InsertBranch(*MBB, MSucc, NULL, SmallVector<MachineOperand, 0>()); 615d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 616d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman MBB->addSuccessor(MSucc); 617d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 618d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 61940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 62040b189e4e257924d90aaf63bf2e12bc7bbca961aDan GohmanFastISel::SelectOperator(User *I, unsigned Opcode) { 62140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 622ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 623ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 624ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 625ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 626ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 627ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 628ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 629ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 630ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 631ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 632ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 633ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 6343df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 6353df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 6363df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 6373df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 6383df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 6393df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 6403df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 6413df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 6423df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 6433df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 6443df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 6453df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 6463df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 6473df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 6483df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 6493df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 6503df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 6513df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 6523df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 6533df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 6543df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 6553df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 6563df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 6573df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 6583df24e667f04a7003342b534310919abc9c87418Dan Gohman 6593df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 6603df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 6613df24e667f04a7003342b534310919abc9c87418Dan Gohman 6623df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 6633df24e667f04a7003342b534310919abc9c87418Dan Gohman BranchInst *BI = cast<BranchInst>(I); 6643df24e667f04a7003342b534310919abc9c87418Dan Gohman 6653df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 6663df24e667f04a7003342b534310919abc9c87418Dan Gohman BasicBlock *LLVMSucc = BI->getSuccessor(0); 6673df24e667f04a7003342b534310919abc9c87418Dan Gohman MachineBasicBlock *MSucc = MBBMap[LLVMSucc]; 668d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman FastEmitBranch(MSucc); 6693df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 6709d5b41624003daf259b33fc953aa471049700353Owen Anderson } 6713df24e667f04a7003342b534310919abc9c87418Dan Gohman 6723df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 6733df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 6743df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 675b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 676b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 677087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 678087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 679087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 680087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 6813df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PHI: 6823df24e667f04a7003342b534310919abc9c87418Dan Gohman // PHI nodes are already emitted. 6833df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 6840586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 6850586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 6860586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 6870586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman if (StaticAllocaMap.count(cast<AllocaInst>(I))) 6880586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 6890586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 6900586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 6910586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 6923df24e667f04a7003342b534310919abc9c87418Dan Gohman 69333134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 69433134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 69533134c4a75558288d663267c8991f6bd37a530afDan Gohman 6963df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 6973df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 6983df24e667f04a7003342b534310919abc9c87418Dan Gohman 6993df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 7003df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 7013df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 7023df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 7033df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 7043df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 7053df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 7063df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 7073df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 7083df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 7093df24e667f04a7003342b534310919abc9c87418Dan Gohman 7103df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 7113df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 712e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 713e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 7143df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 7153df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 7163df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 7173df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 7183df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 7193df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 7203df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 7213df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 7223df24e667f04a7003342b534310919abc9c87418Dan Gohman } 723d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 7243df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 7253df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 7263df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 7273df24e667f04a7003342b534310919abc9c87418Dan Gohman } 728b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 729b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7303df24e667f04a7003342b534310919abc9c87418Dan GohmanFastISel::FastISel(MachineFunction &mf, 731d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MachineModuleInfo *mmi, 73283489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DwarfWriter *dw, 7333df24e667f04a7003342b534310919abc9c87418Dan Gohman DenseMap<const Value *, unsigned> &vm, 7340586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman DenseMap<const BasicBlock *, MachineBasicBlock *> &bm, 735dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman DenseMap<const AllocaInst *, int> &am 736dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 737dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman , SmallSet<Instruction*, 8> &cil 738dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 739dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman ) 7403df24e667f04a7003342b534310919abc9c87418Dan Gohman : MBB(0), 7413df24e667f04a7003342b534310919abc9c87418Dan Gohman ValueMap(vm), 7423df24e667f04a7003342b534310919abc9c87418Dan Gohman MBBMap(bm), 7430586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman StaticAllocaMap(am), 744dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 745dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman CatchInfoLost(cil), 746dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 7473df24e667f04a7003342b534310919abc9c87418Dan Gohman MF(mf), 748d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MMI(mmi), 74983489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DW(dw), 7503df24e667f04a7003342b534310919abc9c87418Dan Gohman MRI(MF.getRegInfo()), 7510586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman MFI(*MF.getFrameInfo()), 7520586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman MCP(*MF.getConstantPool()), 7533df24e667f04a7003342b534310919abc9c87418Dan Gohman TM(MF.getTarget()), 75422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TD(*TM.getTargetData()), 75522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 756e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson TLI(*TM.getTargetLowering()) { 757bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 758bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 759e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 760e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 761825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 76236fd941fc029c6ea50ed08d26a2bfe4932b9789cEvan Cheng ISD::NodeType) { 763b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 764b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 765b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 766825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 7670f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, unsigned /*Op0*/) { 768b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 769b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 770b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 771825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rr(MVT, MVT, 7720f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, unsigned /*Op0*/, 7730f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned /*Op0*/) { 774b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 775b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 776b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 777825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_i(MVT, MVT, ISD::NodeType, uint64_t /*Imm*/) { 77883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 77983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 78083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 781825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 78210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::NodeType, ConstantFP * /*FPImm*/) { 78310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 78410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 78510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 786825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 7870f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, unsigned /*Op0*/, 7880f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 789d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 790d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 791d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 792825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 79310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::NodeType, unsigned /*Op0*/, 79410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ConstantFP * /*FPImm*/) { 79510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 79610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 79710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 798825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 7990f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, 800d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned /*Op0*/, unsigned /*Op1*/, 801d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 80283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 80383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 80483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 80583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 80683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 80783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 80883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 809825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri_(MVT VT, ISD::NodeType Opcode, 810d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, uint64_t Imm, 811825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT ImmType) { 81283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 813151ed61a2f9c3482d35a54d502e7cd147f22a21bDan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Imm); 81483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 81583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 8160f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 817d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (MaterialReg == 0) 818d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 8190f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg); 820d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 821d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 82210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf_ - This method is a wrapper of FastEmit_ri. It first tries 82310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// to emit an instruction with a floating-point immediate operand using 82410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf. If that fails, it materializes the immediate into a register 82510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// and try FastEmit_rr instead. 826825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf_(MVT VT, ISD::NodeType Opcode, 82710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned Op0, ConstantFP *FPImm, 828825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT ImmType) { 82910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // First check if immediate type is legal. If not, we can't use the rf form. 830151ed61a2f9c3482d35a54d502e7cd147f22a21bDan Gohman unsigned ResultReg = FastEmit_rf(VT, VT, Opcode, Op0, FPImm); 83110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ResultReg != 0) 83210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 83310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 83410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Materialize the constant in a register. 83510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned MaterialReg = FastEmit_f(ImmType, ImmType, ISD::ConstantFP, FPImm); 83610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) { 83796a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // If the target doesn't have a way to directly enter a floating-point 83896a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // value into a register, use an alternate approach. 83996a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // TODO: The current approach only supports floating-point constants 84096a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // that can be constructed by conversion from integer values. This should 84196a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // be replaced by code that creates a load from a constant-pool entry, 84296a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // which will require some target-specific work. 84310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const APFloat &Flt = FPImm->getValueAPF(); 844e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 84510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 84610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint64_t x[2]; 84710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 84823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 84923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 85023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 85123a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (!isExact) 85210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 85310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman APInt IntVal(IntBitWidth, 2, x); 85410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 85510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned IntegerReg = FastEmit_i(IntVT.getSimpleVT(), IntVT.getSimpleVT(), 85610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::Constant, IntVal.getZExtValue()); 85710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (IntegerReg == 0) 85810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 85910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman MaterialReg = FastEmit_r(IntVT.getSimpleVT(), VT, 86010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::SINT_TO_FP, IntegerReg); 86110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) 86210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 86310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 86410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg); 86510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 86610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 867d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 868d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 86983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 87083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 871b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 87277ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 873d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 874bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 875b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 8769bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg); 877b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 878b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 879b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 880b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 881b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 882b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman unsigned Op0) { 883d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 884bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 885b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 8865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 8879bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0); 8885960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 8899bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0); 8905960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 8915960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 8925960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 8935960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 8945960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 8955960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 896b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 897b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 898b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 899b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 900b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 901b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman unsigned Op0, unsigned Op1) { 902d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 903bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 904b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 9055960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9069bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addReg(Op1); 9075960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9089bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addReg(Op1); 9095960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9105960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9115960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9125960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9135960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 914b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 915b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 916d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 917d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 918d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 919d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, uint64_t Imm) { 920d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 921d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 922d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 9235960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9249bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addImm(Imm); 9255960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9269bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addImm(Imm); 9275960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9285960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9295960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9305960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9315960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 932d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 933d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 934d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 93510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 93610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 93710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned Op0, ConstantFP *FPImm) { 93810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 93910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 94010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 9415960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9429bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addFPImm(FPImm); 9435960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9449bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addFPImm(FPImm); 9455960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9465960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9475960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9485960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9495960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 95010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 95110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 95210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 953d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 954d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 955d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, unsigned Op1, uint64_t Imm) { 956d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 957d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 958d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 9595960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9609bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addReg(Op1).addImm(Imm); 9615960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9629bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addReg(Op1).addImm(Imm); 9635960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9645960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9655960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9665960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9675960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 968d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 969d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 9706d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 9716d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 9726d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 9736d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 9746d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 9756d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetInstrDesc &II = TII.get(MachineInstOpcode); 9766d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 9775960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9789bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addImm(Imm); 9795960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9809bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addImm(Imm); 9815960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9825960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9835960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9845960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9855960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 9866d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 987b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 9888970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 989825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 990536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned Op0, uint32_t Idx) { 99140a468f24909792f000e3ccc1dda7a27b9c34b69Owen Anderson const TargetRegisterClass* RC = MRI.getRegClass(Op0); 9928970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 993536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 9948970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson const TargetInstrDesc &II = TII.get(TargetInstrInfo::EXTRACT_SUBREG); 9958970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 9965960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9979bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addImm(Idx); 9985960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9999bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addImm(Idx); 10005960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 10015960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 10025960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 10035960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 10045960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 10058970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 10068970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 100714ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 100814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 100914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 1010825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op) { 101114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op, 1); 101214ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1013