FastISel.cpp revision ae3a0be92e33bc716722aa600983fc1535acb122
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" 501be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel#include "llvm/CodeGen/DebugLoc.h" 5183489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/CodeGen/DwarfWriter.h" 5283489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/Analysis/DebugInfo.h" 5383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetData.h" 54b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 5583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 56bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 57dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#include "SelectionDAGBuild.h" 58b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 59b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 603df24e667f04a7003342b534310919abc9c87418Dan Gohmanunsigned FastISel::getRegForValue(Value *V) { 614fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman MVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 624fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 634fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 644fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 65821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 66c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 67c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 68c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 694fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman MVT::SimpleValueType VT = RealVT.getSimpleVT(); 70821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 71821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman // Promote MVT::i1 to a legal type though, because it's common and easy. 72821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (VT == MVT::i1) 73821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman VT = TLI.getTypeToTransformTo(VT).getSimpleVT(); 74821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 75821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 76821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 77821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 78c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Look up the value to see if we already have a register for it. We 79c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // cache values defined by Instructions across blocks, and other values 80c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // only locally. This is because Instructions already have the SSA 81c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // def-dominatess-use requirement enforced. 82c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (ValueMap.count(V)) 83c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return ValueMap[V]; 84c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned Reg = LocalValueMap[V]; 85c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 86c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 87c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 88ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 892ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 902ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 910586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 922ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 93205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 941e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 951e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 961e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman Reg = getRegForValue(Constant::getNullValue(TD.getIntPtrType())); 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(); 102ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman MVT 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 1121e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman unsigned IntegerReg = getRegForValue(ConstantInt::get(IntVal)); 1132ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 1142ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, IntegerReg); 1152ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 116ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 11740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 11840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!SelectOperator(CE, CE->getOpcode())) return 0; 11940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman Reg = LocalValueMap[CE]; 120205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 121104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 1229bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, TII.get(TargetInstrInfo::IMPLICIT_DEF), Reg); 123ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 124d5d81a457b5ff758b3fcc527af38827490bc68a5Owen Anderson 125dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 126dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 1276e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 1282ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 1296e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson 1302ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 1312ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 132dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman if (Reg != 0) 133dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 134104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 135ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 136ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 13759fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Chengunsigned FastISel::lookUpRegForValue(Value *V) { 13859fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 13959fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 14059fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 14159fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // def-dominatess-use requirement enforced. 14259fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng if (ValueMap.count(V)) 14359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return ValueMap[V]; 14459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return LocalValueMap[V]; 14559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 14659fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 147cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 148cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 149cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 150cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 151cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 152cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 153c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattnerunsigned FastISel::UpdateValueMap(Value* I, unsigned Reg) { 15440b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 15540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 156c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return Reg; 157c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 158c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner 159c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner unsigned &AssignedReg = ValueMap[I]; 160c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 161c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 16236e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 163c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner const TargetRegisterClass *RegClass = MRI.getRegClass(Reg); 164c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner TII.copyRegToReg(*MBB, MBB->end(), AssignedReg, 165c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner Reg, RegClass, RegClass); 16640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 167c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return AssignedReg; 168cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 169cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 170c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohmanunsigned FastISel::getRegForGEPIndex(Value *Idx) { 171c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 172c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 173c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 174c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return 0; 175c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 176c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 177c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman MVT PtrVT = TLI.getPointerTy(); 178c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman MVT IdxVT = MVT::getMVT(Idx->getType(), /*HandleUnknown=*/false); 179c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxVT.bitsLT(PtrVT)) 180c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT.getSimpleVT(), 181c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman ISD::SIGN_EXTEND, IdxN); 182c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman else if (IdxVT.bitsGT(PtrVT)) 183c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT.getSimpleVT(), 184c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman ISD::TRUNCATE, IdxN); 185c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return IdxN; 186c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 187c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 188bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 189bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 190bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 19140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectBinaryOp(User *I, ISD::NodeType ISDOpcode) { 192d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman MVT VT = MVT::getMVT(I->getType(), /*HandleUnknown=*/true); 193d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (VT == MVT::Other || !VT.isSimple()) 194d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 195d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 196638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 197b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 198b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 199b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 200b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 201638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 2025dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman // MVT::i1 is special. Allow AND, OR, or XOR because they 203638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 204638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (VT == MVT::i1 && 2055dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 2065dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 207638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman VT = TLI.getTypeToTransformTo(VT); 208638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 209638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 210638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 211d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 2123df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 213d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op0 == 0) 214a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman // Unhandled operand. Halt "fast" selection and bail. 215a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 216a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 217d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 218d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 219ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_ri(VT.getSimpleVT(), VT.getSimpleVT(), 220ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISDOpcode, Op0, CI->getZExtValue()); 221ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 222ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 2233df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 224ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 225ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 226d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 227d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 22810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 22910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 230ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 231ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISDOpcode, Op0, CF); 232ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 233ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 2343df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 235ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 236ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 23710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 23810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 2393df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 240d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 241d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 242bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 243bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 244ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 2450f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 2460f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISDOpcode, Op0, Op1); 247bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 248bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 249bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 250bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 251bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 2528014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 2533df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 254bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 255bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 256bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 25740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectGetElementPtr(User *I) { 2583df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 25983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 26083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 26183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 26283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 26383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng const Type *Ty = I->getOperand(0)->getType(); 2647a0e6593d03bd2dd21c3ac7dcf189f1da86b16daDan Gohman MVT::SimpleValueType VT = TLI.getPointerTy().getSimpleVT(); 26583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng for (GetElementPtrInst::op_iterator OI = I->op_begin()+1, E = I->op_end(); 26683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng OI != E; ++OI) { 26783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Value *Idx = *OI; 26883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 26983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 27083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 27183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 27283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng uint64_t Offs = TD.getStructLayout(StTy)->getElementOffset(Field); 27383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // FIXME: This can be optimized by combining the add with a 27483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // subsequent one. 2757a0e6593d03bd2dd21c3ac7dcf189f1da86b16daDan Gohman N = FastEmit_ri_(VT, ISD::ADD, N, Offs, VT); 27683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 27783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 27883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 27983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 28083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 28183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 28283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 28383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 28483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 28583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 28683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (CI->getZExtValue() == 0) continue; 28783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng uint64_t Offs = 288777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 2897a0e6593d03bd2dd21c3ac7dcf189f1da86b16daDan Gohman N = FastEmit_ri_(VT, ISD::ADD, N, Offs, VT); 29083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 29183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 29283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 29383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng continue; 29483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 29583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 29683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 297777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 298c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForGEPIndex(Idx); 29983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 30083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 30183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 30283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 30380bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 304f93cf79505f07cb97597fbc5955462ad7670ca5cDan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, ElementSize, VT); 30580bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 30680bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 30780bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 30880bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 3090f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson N = FastEmit_rr(VT, VT, ISD::ADD, N, IdxN); 31083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 31183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 31283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 31383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 31483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 31583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 31683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 3173df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 31883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 319bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 320bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 32133134c4a75558288d663267c8991f6bd37a530afDan Gohmanbool FastISel::SelectCall(User *I) { 32233134c4a75558288d663267c8991f6bd37a530afDan Gohman Function *F = cast<CallInst>(I)->getCalledFunction(); 32333134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 32433134c4a75558288d663267c8991f6bd37a530afDan Gohman 32533134c4a75558288d663267c8991f6bd37a530afDan Gohman unsigned IID = F->getIntrinsicID(); 32633134c4a75558288d663267c8991f6bd37a530afDan Gohman switch (IID) { 32733134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 32833134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_stoppoint: { 32933134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgStopPointInst *SPI = cast<DbgStopPointInst>(I); 33077eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (DIDescriptor::ValidDebugInfo(SPI->getContext(), CodeGenOpt::None)) { 33183489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DICompileUnit CU(cast<GlobalVariable>(SPI->getContext())); 33233134c4a75558288d663267c8991f6bd37a530afDan Gohman unsigned Line = SPI->getLine(); 33333134c4a75558288d663267c8991f6bd37a530afDan Gohman unsigned Col = SPI->getColumn(); 334df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling unsigned Idx = MF.getOrCreateDebugLocID(CU.getGV(), Line, Col); 3359bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling setCurDebugLoc(DebugLoc::get(Idx)); 33633134c4a75558288d663267c8991f6bd37a530afDan Gohman } 33733134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 33833134c4a75558288d663267c8991f6bd37a530afDan Gohman } 33933134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_region_start: { 34033134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgRegionStartInst *RSI = cast<DbgRegionStartInst>(I); 341df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling if (DIDescriptor::ValidDebugInfo(RSI->getContext(), CodeGenOpt::None) && 342df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling DW && DW->ShouldEmitDwarfDebug()) { 343df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling unsigned ID = 344df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling DW->RecordRegionStart(cast<GlobalVariable>(RSI->getContext())); 34592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 34692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling BuildMI(MBB, DL, II).addImm(ID); 34792c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 34833134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 34933134c4a75558288d663267c8991f6bd37a530afDan Gohman } 35033134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_region_end: { 35133134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgRegionEndInst *REI = cast<DbgRegionEndInst>(I); 352df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling if (DIDescriptor::ValidDebugInfo(REI->getContext(), CodeGenOpt::None) && 353df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling DW && DW->ShouldEmitDwarfDebug()) { 3541be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel unsigned ID = 0; 355df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling DISubprogram Subprogram(cast<GlobalVariable>(REI->getContext())); 3568818b8f4437a56fc8f75a134f015c3b807e61f10Devang Patel if (!Subprogram.isNull() && !Subprogram.describes(MF.getFunction())) { 3571be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel // This is end of an inlined function. 3581be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 3591be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel ID = DW->RecordInlinedFnEnd(Subprogram); 3608818b8f4437a56fc8f75a134f015c3b807e61f10Devang Patel if (ID) 36102f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // Returned ID is 0 if this is unbalanced "end of inlined 36202f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // scope". This could happen if optimizer eats dbg intrinsics 36302f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // or "beginning of inlined scope" is not recoginized due to 36402f8c410148ba3b6009ed67df41e2c97c1c07c3aDevang Patel // missing location info. In such cases, do ignore this region.end. 3658818b8f4437a56fc8f75a134f015c3b807e61f10Devang Patel BuildMI(MBB, DL, II).addImm(ID); 3661be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel } else { 3671be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 3689a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman ID = DW->RecordRegionEnd(cast<GlobalVariable>(REI->getContext())); 3691be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel BuildMI(MBB, DL, II).addImm(ID); 3701be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel } 37192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 37233134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 37333134c4a75558288d663267c8991f6bd37a530afDan Gohman } 37433134c4a75558288d663267c8991f6bd37a530afDan Gohman case Intrinsic::dbg_func_start: { 37533134c4a75558288d663267c8991f6bd37a530afDan Gohman DbgFuncStartInst *FSI = cast<DbgFuncStartInst>(I); 37633134c4a75558288d663267c8991f6bd37a530afDan Gohman Value *SP = FSI->getSubprogram(); 37777eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (!DIDescriptor::ValidDebugInfo(SP, CodeGenOpt::None)) 37877eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis return true; 3799bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling 38077eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // llvm.dbg.func.start implicitly defines a dbg_stoppoint which is what 38177eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // (most?) gdb expects. 38277eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis DebugLoc PrevLoc = DL; 38377eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis DISubprogram Subprogram(cast<GlobalVariable>(SP)); 38477eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis DICompileUnit CompileUnit = Subprogram.getCompileUnit(); 385682e0e6a72af42f31e6fcf329c7bb5cfaff7459dDevang Patel 38677eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (!Subprogram.describes(MF.getFunction())) { 38777eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // This is a beginning of an inlined function. 38877eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis 38977eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // If llvm.dbg.func.start is seen in a new block before any 39077eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // llvm.dbg.stoppoint intrinsic then the location info is unknown. 39177eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // FIXME : Why DebugLoc is reset at the beginning of each block ? 39277eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (PrevLoc.isUnknown()) 39377eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis return true; 39477eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // Record the source line. 39577eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis unsigned Line = Subprogram.getLineNumber(); 396df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling setCurDebugLoc(DebugLoc::get(MF.getOrCreateDebugLocID( 397df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling CompileUnit.getGV(), Line, 0))); 39877eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis 39977eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (DW && DW->ShouldEmitDwarfDebug()) { 400116b27444a206a2831d88fea5ce34ced8184cecaArgyrios Kyrtzidis DebugLocTuple PrevLocTpl = MF.getDebugLocTuple(PrevLoc); 401116b27444a206a2831d88fea5ce34ced8184cecaArgyrios Kyrtzidis unsigned LabelID = DW->RecordInlinedFnStart(Subprogram, 402116b27444a206a2831d88fea5ce34ced8184cecaArgyrios Kyrtzidis DICompileUnit(PrevLocTpl.CompileUnit), 403116b27444a206a2831d88fea5ce34ced8184cecaArgyrios Kyrtzidis PrevLocTpl.Line, 404116b27444a206a2831d88fea5ce34ced8184cecaArgyrios Kyrtzidis PrevLocTpl.Col); 4050f7fef3872a37d09c806f52f1d03d74ebc73c171Devang Patel const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL); 4060f7fef3872a37d09c806f52f1d03d74ebc73c171Devang Patel BuildMI(MBB, DL, II).addImm(LabelID); 40777eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis } 40877eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis } else { 40977eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis // Record the source line. 41077eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis unsigned Line = Subprogram.getLineNumber(); 411df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling MF.setDefaultDebugLoc(DebugLoc::get(MF.getOrCreateDebugLocID( 412df7d5d317096c342ee1c459139914965008fbcd7Bill Wendling CompileUnit.getGV(), Line, 0))); 4139a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (DW && DW->ShouldEmitDwarfDebug()) { 4140f7fef3872a37d09c806f52f1d03d74ebc73c171Devang Patel // llvm.dbg.func_start also defines beginning of function scope. 4150f7fef3872a37d09c806f52f1d03d74ebc73c171Devang Patel DW->RecordRegionStart(cast<GlobalVariable>(FSI->getSubprogram())); 4169a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 41733134c4a75558288d663267c8991f6bd37a530afDan Gohman } 4189bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling 41933134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 42033134c4a75558288d663267c8991f6bd37a530afDan Gohman } 42192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 42292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DbgDeclareInst *DI = cast<DbgDeclareInst>(I); 42392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling Value *Variable = DI->getVariable(); 42477eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis if (DIDescriptor::ValidDebugInfo(Variable, CodeGenOpt::None) && 42577eaa6880b8209acc05de733ebaba5d146c321a0Argyrios Kyrtzidis DW && DW->ShouldEmitDwarfDebug()) { 42692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling // Determine the address of the declared object. 42792c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling Value *Address = DI->getAddress(); 42892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling if (BitCastInst *BCI = dyn_cast<BitCastInst>(Address)) 42992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling Address = BCI->getOperand(0); 43092c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling AllocaInst *AI = dyn_cast<AllocaInst>(Address); 43192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling // Don't handle byval struct arguments or VLAs, for example. 43292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling if (!AI) break; 43392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DenseMap<const AllocaInst*, int>::iterator SI = 43492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling StaticAllocaMap.find(AI); 43592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling if (SI == StaticAllocaMap.end()) break; // VLAs. 43692c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling int FI = SI->second; 43792c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 43892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling // Determine the debug globalvariable. 43992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling GlobalValue *GV = cast<GlobalVariable>(Variable); 44092c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 44192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling // Build the DECLARE instruction. 44292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling const TargetInstrDesc &II = TII.get(TargetInstrInfo::DECLARE); 4431be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel MachineInstr *DeclareMI 4441be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel = BuildMI(MBB, DL, II).addFrameIndex(FI).addGlobalAddress(GV); 4451be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel DIVariable DV(cast<GlobalVariable>(GV)); 4461be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel if (!DV.isNull()) { 4471be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel // This is a local variable 4481be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel DW->RecordVariableScope(DV, DeclareMI); 4491be3eccecbd2fa50ed9008ffee01f6351df5d8f7Devang Patel } 45092c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 45133134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 45292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 453dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_exception: { 454dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman MVT VT = TLI.getValueType(I->getType()); 455dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EXCEPTIONADDR, VT)) { 456dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 457dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 458b0f1e1780c736c62fb99e5824825d2a60a53b53bDuncan Sands assert(MBB->isLandingPad() && "Call to eh.exception not in landing pad!"); 459dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionAddressRegister(); 460dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetRegisterClass *RC = TLI.getRegClassFor(VT); 461dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 462dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 463dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman Reg, RC, RC); 464dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman assert(InsertedCopy && "Can't copy address registers!"); 46524ac408ce891321d1a5d62beaf3487efce6f2b22Evan Cheng InsertedCopy = InsertedCopy; 466dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 467dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 468dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 469dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 470dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 471dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 472dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_selector_i32: 473dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_selector_i64: { 474dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman MVT VT = TLI.getValueType(I->getType()); 475dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EHSELECTION, VT)) { 476dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 477dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 478dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman MVT VT = (IID == Intrinsic::eh_selector_i32 ? 479dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman MVT::i32 : MVT::i64); 480dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 481dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MMI) { 482dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MBB->isLandingPad()) 483dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman AddCatchInfo(*cast<CallInst>(I), MMI, MBB); 484dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman else { 485dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 486dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman CatchInfoLost.insert(cast<CallInst>(I)); 487dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 488dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // FIXME: Mark exception selector register as live in. Hack for PR1508. 489dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 490dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (Reg) MBB->addLiveIn(Reg); 491dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 492dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 493dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 494dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetRegisterClass *RC = TLI.getRegClassFor(VT); 495dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 496dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 497dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman Reg, RC, RC); 498dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman assert(InsertedCopy && "Can't copy address registers!"); 49924ac408ce891321d1a5d62beaf3487efce6f2b22Evan Cheng InsertedCopy = InsertedCopy; 500dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 501dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } else { 502dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = 503dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman getRegForValue(Constant::getNullValue(I->getType())); 504dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 505dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 506dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 507dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 508dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 509dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 510dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 51133134c4a75558288d663267c8991f6bd37a530afDan Gohman } 51233134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 51333134c4a75558288d663267c8991f6bd37a530afDan Gohman} 51433134c4a75558288d663267c8991f6bd37a530afDan Gohman 51540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectCast(User *I, ISD::NodeType Opcode) { 5166336b70541204d1a8377ec1f33748a7260e0a31dOwen Anderson MVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 5176336b70541204d1a8377ec1f33748a7260e0a31dOwen Anderson MVT DstVT = TLI.getValueType(I->getType()); 518d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 519d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 520474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman DstVT == MVT::Other || !DstVT.isSimple()) 521d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 522d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 523d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 524474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Check if the destination type is legal. Or as a special case, 525474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // it may be i1 if we're doing a truncate because that's 526474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 527474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 528474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (DstVT != MVT::i1 || Opcode != ISD::TRUNCATE) 529474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Unhandled type. Halt "fast" selection and bail. 530474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman return false; 531474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 53291b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Check if the source operand is legal. Or as a special case, 53391b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // it may be i1 if we're doing zero-extension because that's 534474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 535474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 536474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (SrcVT != MVT::i1 || Opcode != ISD::ZERO_EXTEND) 53791b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Unhandled type. Halt "fast" selection and bail. 53891b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman return false; 539474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 5403df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 541d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 542d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 543d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 54414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 54514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman // If the operand is i1, arrange for the high bits in the register to be zero. 546474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (SrcVT == MVT::i1) { 547474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman SrcVT = TLI.getTypeToTransformTo(SrcVT); 54814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman InputReg = FastEmitZExtFromI1(SrcVT.getSimpleVT(), InputReg); 54914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman if (!InputReg) 55014ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return false; 55114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman } 552474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // If the result is i1, truncate to the target's type for i1 first. 553474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (DstVT == MVT::i1) 554474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman DstVT = TLI.getTypeToTransformTo(DstVT); 55514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 556d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 557d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 558d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 559d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson InputReg); 560d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 561d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 562d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5633df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 564d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 565d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 566d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 56740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectBitCast(User *I) { 568ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 569ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 5703df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 571a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 572a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 5733df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 574ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 575ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 576ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 577ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Bitcasts of other values become reg-reg copies or BIT_CONVERT operators. 5786336b70541204d1a8377ec1f33748a7260e0a31dOwen Anderson MVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 5796336b70541204d1a8377ec1f33748a7260e0a31dOwen Anderson MVT DstVT = TLI.getValueType(I->getType()); 580d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 581d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 582d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT == MVT::Other || !DstVT.isSimple() || 583d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 584d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 585d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 586d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5873df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 588ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 589ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 590d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 591d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 592ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 593ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 594ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) { 595ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 596ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 597ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = createResultReg(DstClass); 598ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 599ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 600ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman Op0, DstClass, SrcClass); 601ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!InsertedCopy) 602ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = 0; 603ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 604ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 605ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the reg-reg copy failed, select a BIT_CONVERT opcode. 606ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 607ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), 608ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISD::BIT_CONVERT, Op0); 609ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 610ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 611d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 612d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 6133df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 614d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 615d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 616d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 6173df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 6183df24e667f04a7003342b534310919abc9c87418Dan GohmanFastISel::SelectInstruction(Instruction *I) { 61940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman return SelectOperator(I, I->getOpcode()); 62040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 62140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 622d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 623d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 624d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 625d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 626d98d6203e429b2d7208b6687931e9079e85e95ecDan GohmanFastISel::FastEmitBranch(MachineBasicBlock *MSucc) { 627d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman MachineFunction::iterator NextMBB = 628d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman next(MachineFunction::iterator(MBB)); 629d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 630d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman if (MBB->isLayoutSuccessor(MSucc)) { 631d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional fall-through case, which needs no instructions. 632d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 633d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 634d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman TII.InsertBranch(*MBB, MSucc, NULL, SmallVector<MachineOperand, 0>()); 635d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 636d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman MBB->addSuccessor(MSucc); 637d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 638d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 63940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 64040b189e4e257924d90aaf63bf2e12bc7bbca961aDan GohmanFastISel::SelectOperator(User *I, unsigned Opcode) { 64140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 642ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 643ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 644ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 645ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 646ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 647ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 648ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 649ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 650ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 651ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 652ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 653ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 6543df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 6553df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 6563df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 6573df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 6583df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 6593df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 6603df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 6613df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 6623df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 6633df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 6643df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 6653df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 6663df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 6673df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 6683df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 6693df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 6703df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 6713df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 6723df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 6733df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 6743df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 6753df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 6763df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 6773df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 6783df24e667f04a7003342b534310919abc9c87418Dan Gohman 6793df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 6803df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 6813df24e667f04a7003342b534310919abc9c87418Dan Gohman 6823df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 6833df24e667f04a7003342b534310919abc9c87418Dan Gohman BranchInst *BI = cast<BranchInst>(I); 6843df24e667f04a7003342b534310919abc9c87418Dan Gohman 6853df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 6863df24e667f04a7003342b534310919abc9c87418Dan Gohman BasicBlock *LLVMSucc = BI->getSuccessor(0); 6873df24e667f04a7003342b534310919abc9c87418Dan Gohman MachineBasicBlock *MSucc = MBBMap[LLVMSucc]; 688d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman FastEmitBranch(MSucc); 6893df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 6909d5b41624003daf259b33fc953aa471049700353Owen Anderson } 6913df24e667f04a7003342b534310919abc9c87418Dan Gohman 6923df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 6933df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 6943df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 695b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 696b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 697087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 698087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 699087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 700087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 7013df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PHI: 7023df24e667f04a7003342b534310919abc9c87418Dan Gohman // PHI nodes are already emitted. 7033df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 7040586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 7050586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 7060586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 7070586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman if (StaticAllocaMap.count(cast<AllocaInst>(I))) 7080586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 7090586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 7100586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 7110586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 7123df24e667f04a7003342b534310919abc9c87418Dan Gohman 71333134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 71433134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 71533134c4a75558288d663267c8991f6bd37a530afDan Gohman 7163df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 7173df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 7183df24e667f04a7003342b534310919abc9c87418Dan Gohman 7193df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 7203df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 7213df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 7223df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 7233df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 7243df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 7253df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 7263df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 7273df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 7283df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 7293df24e667f04a7003342b534310919abc9c87418Dan Gohman 7303df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 7313df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 7323df24e667f04a7003342b534310919abc9c87418Dan Gohman MVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 7333df24e667f04a7003342b534310919abc9c87418Dan Gohman MVT DstVT = TLI.getValueType(I->getType()); 7343df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 7353df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 7363df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 7373df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 7383df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 7393df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 7403df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 7413df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 7423df24e667f04a7003342b534310919abc9c87418Dan Gohman } 743d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 7443df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 7453df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 7463df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 7473df24e667f04a7003342b534310919abc9c87418Dan Gohman } 748b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 749b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7503df24e667f04a7003342b534310919abc9c87418Dan GohmanFastISel::FastISel(MachineFunction &mf, 751d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MachineModuleInfo *mmi, 75283489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DwarfWriter *dw, 7533df24e667f04a7003342b534310919abc9c87418Dan Gohman DenseMap<const Value *, unsigned> &vm, 7540586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman DenseMap<const BasicBlock *, MachineBasicBlock *> &bm, 755dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman DenseMap<const AllocaInst *, int> &am 756dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 757dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman , SmallSet<Instruction*, 8> &cil 758dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 759dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman ) 7603df24e667f04a7003342b534310919abc9c87418Dan Gohman : MBB(0), 7613df24e667f04a7003342b534310919abc9c87418Dan Gohman ValueMap(vm), 7623df24e667f04a7003342b534310919abc9c87418Dan Gohman MBBMap(bm), 7630586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman StaticAllocaMap(am), 764dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 765dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman CatchInfoLost(cil), 766dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 7673df24e667f04a7003342b534310919abc9c87418Dan Gohman MF(mf), 768d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MMI(mmi), 76983489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DW(dw), 7703df24e667f04a7003342b534310919abc9c87418Dan Gohman MRI(MF.getRegInfo()), 7710586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman MFI(*MF.getFrameInfo()), 7720586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman MCP(*MF.getConstantPool()), 7733df24e667f04a7003342b534310919abc9c87418Dan Gohman TM(MF.getTarget()), 77422bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TD(*TM.getTargetData()), 77522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 77622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TLI(*TM.getTargetLowering()) { 777bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 778bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 779e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 780e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 78136fd941fc029c6ea50ed08d26a2bfe4932b9789cEvan Chengunsigned FastISel::FastEmit_(MVT::SimpleValueType, MVT::SimpleValueType, 78236fd941fc029c6ea50ed08d26a2bfe4932b9789cEvan Cheng ISD::NodeType) { 783b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 784b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 785b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7860f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Andersonunsigned FastISel::FastEmit_r(MVT::SimpleValueType, MVT::SimpleValueType, 7870f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, unsigned /*Op0*/) { 788b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 789b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 790b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7910f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Andersonunsigned FastISel::FastEmit_rr(MVT::SimpleValueType, MVT::SimpleValueType, 7920f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, unsigned /*Op0*/, 7930f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned /*Op0*/) { 794b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 795b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 796b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7970f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Andersonunsigned FastISel::FastEmit_i(MVT::SimpleValueType, MVT::SimpleValueType, 7980f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, uint64_t /*Imm*/) { 79983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 80083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 80183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 80210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmit_f(MVT::SimpleValueType, MVT::SimpleValueType, 80310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::NodeType, ConstantFP * /*FPImm*/) { 80410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 80510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 80610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 8070f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Andersonunsigned FastISel::FastEmit_ri(MVT::SimpleValueType, MVT::SimpleValueType, 8080f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, unsigned /*Op0*/, 8090f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 810d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 811d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 812d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 81310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmit_rf(MVT::SimpleValueType, MVT::SimpleValueType, 81410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::NodeType, unsigned /*Op0*/, 81510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ConstantFP * /*FPImm*/) { 81610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 81710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 81810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 8190f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Andersonunsigned FastISel::FastEmit_rri(MVT::SimpleValueType, MVT::SimpleValueType, 8200f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson ISD::NodeType, 821d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned /*Op0*/, unsigned /*Op1*/, 822d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 82383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 82483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 82583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 82683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 82783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 82883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 82983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 83083785c80968165b30fcdd111ceb2c28d38bcff86Evan Chengunsigned FastISel::FastEmit_ri_(MVT::SimpleValueType VT, ISD::NodeType Opcode, 831d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, uint64_t Imm, 832d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman MVT::SimpleValueType ImmType) { 83383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 834151ed61a2f9c3482d35a54d502e7cd147f22a21bDan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Imm); 83583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 83683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 8370f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 838d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (MaterialReg == 0) 839d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 8400f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg); 841d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 842d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 84310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf_ - This method is a wrapper of FastEmit_ri. It first tries 84410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// to emit an instruction with a floating-point immediate operand using 84510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf. If that fails, it materializes the immediate into a register 84610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// and try FastEmit_rr instead. 84710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmit_rf_(MVT::SimpleValueType VT, ISD::NodeType Opcode, 84810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned Op0, ConstantFP *FPImm, 84910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman MVT::SimpleValueType ImmType) { 85010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // First check if immediate type is legal. If not, we can't use the rf form. 851151ed61a2f9c3482d35a54d502e7cd147f22a21bDan Gohman unsigned ResultReg = FastEmit_rf(VT, VT, Opcode, Op0, FPImm); 85210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ResultReg != 0) 85310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 85410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 85510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Materialize the constant in a register. 85610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned MaterialReg = FastEmit_f(ImmType, ImmType, ISD::ConstantFP, FPImm); 85710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) { 85896a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // If the target doesn't have a way to directly enter a floating-point 85996a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // value into a register, use an alternate approach. 86096a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // TODO: The current approach only supports floating-point constants 86196a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // that can be constructed by conversion from integer values. This should 86296a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // be replaced by code that creates a load from a constant-pool entry, 86396a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // which will require some target-specific work. 86410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const APFloat &Flt = FPImm->getValueAPF(); 86510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman MVT IntVT = TLI.getPointerTy(); 86610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 86710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint64_t x[2]; 86810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 86923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 87023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 87123a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 87223a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (!isExact) 87310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 87410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman APInt IntVal(IntBitWidth, 2, x); 87510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 87610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned IntegerReg = FastEmit_i(IntVT.getSimpleVT(), IntVT.getSimpleVT(), 87710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::Constant, IntVal.getZExtValue()); 87810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (IntegerReg == 0) 87910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 88010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman MaterialReg = FastEmit_r(IntVT.getSimpleVT(), VT, 88110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::SINT_TO_FP, IntegerReg); 88210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) 88310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 88410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 88510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg); 88610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 88710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 888d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 889d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 89083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 89183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 892b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 89377ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 894d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 895bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 896b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 8979bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg); 898b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 899b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 900b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 901b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 902b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 903b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman unsigned Op0) { 904d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 905bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 906b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 9075960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9089bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0); 9095960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9109bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0); 9115960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9125960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9135960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9145960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9155960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 9165960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 917b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 918b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 919b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 920b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 921b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 922b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman unsigned Op0, unsigned Op1) { 923d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 924bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 925b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 9265960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9279bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addReg(Op1); 9285960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9299bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addReg(Op1); 9305960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9315960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9325960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9335960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9345960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 935b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 936b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 937d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 938d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 939d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 940d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, uint64_t Imm) { 941d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 942d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 943d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 9445960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9459bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addImm(Imm); 9465960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9479bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addImm(Imm); 9485960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9495960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9505960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9515960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9525960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 953d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 954d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 955d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 95610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 95710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 95810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned Op0, ConstantFP *FPImm) { 95910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 96010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 96110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 9625960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9639bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addFPImm(FPImm); 9645960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9659bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addFPImm(FPImm); 9665960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9675960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9685960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9695960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9705960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 97110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 97210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 97310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 974d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 975d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 976d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, unsigned Op1, uint64_t Imm) { 977d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 978d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 979d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 9805960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9819bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addReg(Op1).addImm(Imm); 9825960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9839bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addReg(Op1).addImm(Imm); 9845960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9855960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9875960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9885960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 989d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 990d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 9916d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 9926d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 9936d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 9946d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 9956d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 9966d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetInstrDesc &II = TII.get(MachineInstOpcode); 9976d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 9985960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9999bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addImm(Imm); 10005960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 10019bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addImm(Imm); 10025960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 10035960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 10045960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 10055960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 10065960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 10076d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 1008b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 10098970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1010536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Chengunsigned FastISel::FastEmitInst_extractsubreg(MVT::SimpleValueType RetVT, 1011536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned Op0, uint32_t Idx) { 101240a468f24909792f000e3ccc1dda7a27b9c34b69Owen Anderson const TargetRegisterClass* RC = MRI.getRegClass(Op0); 10138970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1014536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 10158970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson const TargetInstrDesc &II = TII.get(TargetInstrInfo::EXTRACT_SUBREG); 10168970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 10175960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 10189bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addImm(Idx); 10195960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 10209bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addImm(Idx); 10215960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 10225960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 10235960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 10245960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 10255960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 10268970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 10278970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 102814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 102914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 103014ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 103114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohmanunsigned FastISel::FastEmitZExtFromI1(MVT::SimpleValueType VT, unsigned Op) { 103214ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op, 1); 103314ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1034