FastISel.cpp revision 7c3ecb6838ef7a2ca306c0f3cd68022f0855ae71
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" 562048b85c7c2c987874b9423e682ec8e60b60574bDan Gohman#include "SelectionDAGBuilder.h" 5766336edf823f8d64d77dc5ab2bbefc21ef82f6ecDan Gohman#include "FunctionLoweringInfo.h" 58b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 59b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 603df24e667f04a7003342b534310919abc9c87418Dan Gohmanunsigned FastISel::getRegForValue(Value *V) { 61e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT 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. 69825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 70821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 71825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // Promote MVT::i1 to a legal type though, because it's common and easy. 72825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1) 7323b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), 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. 961d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 971d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 98ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 99104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 100ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 101ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 102ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 103e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 104ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 105ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 106ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 10723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 10823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 10923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 11023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 1112ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman APInt IntVal(IntBitWidth, 2, x); 112ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 113e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 114eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 1152ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 1162ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, IntegerReg); 1172ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 118ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 11940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 12040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!SelectOperator(CE, CE->getOpcode())) return 0; 12140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman Reg = LocalValueMap[CE]; 122205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 123104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 1249bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, TII.get(TargetInstrInfo::IMPLICIT_DEF), Reg); 125ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 126d5d81a457b5ff758b3fcc527af38827490bc68a5Owen Anderson 127dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 128dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 1296e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 1302ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 1316e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson 1322ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 1332ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 134dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman if (Reg != 0) 135dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 136104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 137ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 138ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 13959fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Chengunsigned FastISel::lookUpRegForValue(Value *V) { 14059fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 14159fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 14259fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 14359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // def-dominatess-use requirement enforced. 14459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng if (ValueMap.count(V)) 14559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return ValueMap[V]; 14659fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return LocalValueMap[V]; 14759fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 14859fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 149cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 150cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 151cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 152cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 153cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 154cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 155c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattnerunsigned FastISel::UpdateValueMap(Value* I, unsigned Reg) { 15640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 15740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 158c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return Reg; 159c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 160c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner 161c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner unsigned &AssignedReg = ValueMap[I]; 162c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 163c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 16436e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 165c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner const TargetRegisterClass *RegClass = MRI.getRegClass(Reg); 166c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner TII.copyRegToReg(*MBB, MBB->end(), AssignedReg, 167c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner Reg, RegClass, RegClass); 16840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 169c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return AssignedReg; 170cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 171cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 172c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohmanunsigned FastISel::getRegForGEPIndex(Value *Idx) { 173c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 174c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 175c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 176c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return 0; 177c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 178c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 179766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 180e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 181c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxVT.bitsLT(PtrVT)) 182766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, IdxN); 183c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman else if (IdxVT.bitsGT(PtrVT)) 184766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, 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/// 1917c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanbool FastISel::SelectBinaryOp(User *I, unsigned ISDOpcode) { 192e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 193825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson 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)) { 202825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 203638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 204825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 2055dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 2065dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 20723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), 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(); 264825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 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; 32892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 32992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling DbgDeclareInst *DI = cast<DbgDeclareInst>(I); 330bf0ca2b477e761e2c81f6c36d6c7bec055933b15Chris Lattner if (!DIDescriptor::ValidDebugInfo(DI->getVariable(), CodeGenOpt::None)||!DW 3317e1e31f467d87c834d8baf673929865907901313Devang Patel || !DW->ShouldEmitDwarfDebug()) 3327e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 33392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 3347e1e31f467d87c834d8baf673929865907901313Devang Patel Value *Address = DI->getAddress(); 3357e1e31f467d87c834d8baf673929865907901313Devang Patel if (BitCastInst *BCI = dyn_cast<BitCastInst>(Address)) 3367e1e31f467d87c834d8baf673929865907901313Devang Patel Address = BCI->getOperand(0); 3377e1e31f467d87c834d8baf673929865907901313Devang Patel AllocaInst *AI = dyn_cast<AllocaInst>(Address); 3387e1e31f467d87c834d8baf673929865907901313Devang Patel // Don't handle byval struct arguments or VLAs, for example. 3397e1e31f467d87c834d8baf673929865907901313Devang Patel if (!AI) break; 3407e1e31f467d87c834d8baf673929865907901313Devang Patel DenseMap<const AllocaInst*, int>::iterator SI = 3417e1e31f467d87c834d8baf673929865907901313Devang Patel StaticAllocaMap.find(AI); 3427e1e31f467d87c834d8baf673929865907901313Devang Patel if (SI == StaticAllocaMap.end()) break; // VLAs. 3437e1e31f467d87c834d8baf673929865907901313Devang Patel int FI = SI->second; 34453bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (MMI) { 3453990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner if (MDNode *Dbg = DI->getMetadata("dbg")) 3460eb419800ae51d6e0e00a656ede0627483755361Chris Lattner MMI->setVariableDbgInfo(DI->getVariable(), FI, Dbg); 34753bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel } 34833134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 34992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 350dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_exception: { 351e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = TLI.getValueType(I->getType()); 352dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EXCEPTIONADDR, VT)) { 353dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 354dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 355b0f1e1780c736c62fb99e5824825d2a60a53b53bDuncan Sands assert(MBB->isLandingPad() && "Call to eh.exception not in landing pad!"); 356dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionAddressRegister(); 357dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetRegisterClass *RC = TLI.getRegClassFor(VT); 358dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 359dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 360dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman Reg, RC, RC); 361dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman assert(InsertedCopy && "Can't copy address registers!"); 36224ac408ce891321d1a5d62beaf3487efce6f2b22Evan Cheng InsertedCopy = InsertedCopy; 363dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 364dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 365dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 366dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 367dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 368dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 369b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands case Intrinsic::eh_selector: { 370e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = TLI.getValueType(I->getType()); 371dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EHSELECTION, VT)) { 372dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 373dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 374dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MMI) { 375dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (MBB->isLandingPad()) 376dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman AddCatchInfo(*cast<CallInst>(I), MMI, MBB); 377dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman else { 378dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 379dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman CatchInfoLost.insert(cast<CallInst>(I)); 380dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 381dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman // FIXME: Mark exception selector register as live in. Hack for PR1508. 382dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 383dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman if (Reg) MBB->addLiveIn(Reg); 384dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 385dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman 386dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 387b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands EVT SrcVT = TLI.getPointerTy(); 388b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands const TargetRegisterClass *RC = TLI.getRegClassFor(SrcVT); 389dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 390b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, Reg, 391b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands RC, RC); 392dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman assert(InsertedCopy && "Can't copy address registers!"); 39324ac408ce891321d1a5d62beaf3487efce6f2b22Evan Cheng InsertedCopy = InsertedCopy; 394b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands 395b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands // Cast the register to the type of the selector. 396b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands if (SrcVT.bitsGT(MVT::i32)) 397b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands ResultReg = FastEmit_r(SrcVT.getSimpleVT(), MVT::i32, ISD::TRUNCATE, 398b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands ResultReg); 399b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands else if (SrcVT.bitsLT(MVT::i32)) 400b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands ResultReg = FastEmit_r(SrcVT.getSimpleVT(), MVT::i32, 401b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands ISD::SIGN_EXTEND, ResultReg); 402b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands if (ResultReg == 0) 403b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands // Unhandled operand. Halt "fast" selection and bail. 404b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands return false; 405b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands 406dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 407dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } else { 408dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = 409a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson getRegForValue(Constant::getNullValue(I->getType())); 410dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 411dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 412dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 413dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 414dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 415dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 416dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 41733134c4a75558288d663267c8991f6bd37a530afDan Gohman } 41833134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 41933134c4a75558288d663267c8991f6bd37a530afDan Gohman} 42033134c4a75558288d663267c8991f6bd37a530afDan Gohman 4217c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanbool FastISel::SelectCast(User *I, unsigned Opcode) { 422e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 423e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 424d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 425825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 426825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 427d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 428d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 429d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 430474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Check if the destination type is legal. Or as a special case, 431474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // it may be i1 if we're doing a truncate because that's 432474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 433474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 434825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DstVT != MVT::i1 || Opcode != ISD::TRUNCATE) 435474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Unhandled type. Halt "fast" selection and bail. 436474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman return false; 437474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 43891b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Check if the source operand is legal. Or as a special case, 43991b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // it may be i1 if we're doing zero-extension because that's 440474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 441474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 442825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT != MVT::i1 || Opcode != ISD::ZERO_EXTEND) 44391b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Unhandled type. Halt "fast" selection and bail. 44491b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman return false; 445474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 4463df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 447d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 448d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 449d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 45014ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 45114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman // If the operand is i1, arrange for the high bits in the register to be zero. 452825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::i1) { 45323b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson SrcVT = TLI.getTypeToTransformTo(I->getContext(), SrcVT); 45414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman InputReg = FastEmitZExtFromI1(SrcVT.getSimpleVT(), InputReg); 45514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman if (!InputReg) 45614ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return false; 45714ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman } 458474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // If the result is i1, truncate to the target's type for i1 first. 459825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DstVT == MVT::i1) 46023b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson DstVT = TLI.getTypeToTransformTo(I->getContext(), DstVT); 46114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 462d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 463d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 464d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 465d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson InputReg); 466d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 467d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 468d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 4693df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 470d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 471d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 472d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 47340b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool FastISel::SelectBitCast(User *I) { 474ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 475ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 4763df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 477a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 478a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 4793df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 480ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 481ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 482ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 483ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Bitcasts of other values become reg-reg copies or BIT_CONVERT operators. 484e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 485e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 486d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 487825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 488825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple() || 489d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 490d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 491d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 492d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 4933df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 494ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 495ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 496d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 497d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 498ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 499ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 500ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) { 501ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 502ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 503ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = createResultReg(DstClass); 504ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 505ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 506ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman Op0, DstClass, SrcClass); 507ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!InsertedCopy) 508ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = 0; 509ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 510ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 511ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the reg-reg copy failed, select a BIT_CONVERT opcode. 512ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 513ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), 514ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ISD::BIT_CONVERT, Op0); 515ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 516ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 517d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 518d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5193df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 520d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 521d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 522d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 5233df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 5243df24e667f04a7003342b534310919abc9c87418Dan GohmanFastISel::SelectInstruction(Instruction *I) { 5256e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // First, try doing target-independent selection. 5266e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman if (SelectOperator(I, I->getOpcode())) 5276e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 5286e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 5296e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // Next, try calling the target to attempt to handle the instruction. 5306e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman if (TargetSelectInstruction(I)) 5316e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 5326e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 5336e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return false; 53440b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 53540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 536d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 537d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 538d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 539d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 540d98d6203e429b2d7208b6687931e9079e85e95ecDan GohmanFastISel::FastEmitBranch(MachineBasicBlock *MSucc) { 541d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman if (MBB->isLayoutSuccessor(MSucc)) { 542d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional fall-through case, which needs no instructions. 543d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 544d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 545d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman TII.InsertBranch(*MBB, MSucc, NULL, SmallVector<MachineOperand, 0>()); 546d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 547d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman MBB->addSuccessor(MSucc); 548d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 549d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 5503d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// SelectFNeg - Emit an FNeg operation. 5513d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// 5523d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohmanbool 5533d45a853db014fdddcdb79424e663dfed5eccbc7Dan GohmanFastISel::SelectFNeg(User *I) { 5543d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 5553d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (OpReg == 0) return false; 5563d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 5574a215a13c3035a8818254b61267be77def4a2a37Dan Gohman // If the target has ISD::FNEG, use it. 5584a215a13c3035a8818254b61267be77def4a2a37Dan Gohman EVT VT = TLI.getValueType(I->getType()); 5594a215a13c3035a8818254b61267be77def4a2a37Dan Gohman unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 5604a215a13c3035a8818254b61267be77def4a2a37Dan Gohman ISD::FNEG, OpReg); 5614a215a13c3035a8818254b61267be77def4a2a37Dan Gohman if (ResultReg != 0) { 5624a215a13c3035a8818254b61267be77def4a2a37Dan Gohman UpdateValueMap(I, ResultReg); 5634a215a13c3035a8818254b61267be77def4a2a37Dan Gohman return true; 5644a215a13c3035a8818254b61267be77def4a2a37Dan Gohman } 5654a215a13c3035a8818254b61267be77def4a2a37Dan Gohman 5665e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // Bitcast the value to integer, twiddle the sign bit with xor, 5675e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // and then bitcast it back to floating-point. 5683d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (VT.getSizeInBits() > 64) return false; 5695e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 5705e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (!TLI.isTypeLegal(IntVT)) 5715e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 5725e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 5735e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 5745e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ISD::BIT_CONVERT, OpReg); 5755e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntReg == 0) 5765e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 5775e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 5785e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, IntReg, 5795e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman UINT64_C(1) << (VT.getSizeInBits()-1), 5805e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman IntVT.getSimpleVT()); 5815e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntResultReg == 0) 5825e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 5835e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 5845e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 5855e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ISD::BIT_CONVERT, IntResultReg); 5863d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (ResultReg == 0) 5873d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return false; 5883d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 5893d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman UpdateValueMap(I, ResultReg); 5903d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return true; 5913d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman} 5923d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 59340b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 59440b189e4e257924d90aaf63bf2e12bc7bbca961aDan GohmanFastISel::SelectOperator(User *I, unsigned Opcode) { 59540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 596ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 597ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 598ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 599ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 600ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 601ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 602ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 6033d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman // FNeg is currently represented in LLVM IR as a special case of FSub. 6043d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (BinaryOperator::isFNeg(I)) 6053d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return SelectFNeg(I); 606ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 607ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 608ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 609ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 610ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 6113df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 6123df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 6133df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 6143df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 6153df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 6163df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 6173df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 6183df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 6193df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 6203df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 6213df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 6223df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 6233df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 6243df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 6253df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 6263df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 6273df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 6283df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 6293df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 6303df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 6313df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 6323df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 6333df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 6343df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 6353df24e667f04a7003342b534310919abc9c87418Dan Gohman 6363df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 6373df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 6383df24e667f04a7003342b534310919abc9c87418Dan Gohman 6393df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 6403df24e667f04a7003342b534310919abc9c87418Dan Gohman BranchInst *BI = cast<BranchInst>(I); 6413df24e667f04a7003342b534310919abc9c87418Dan Gohman 6423df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 6433df24e667f04a7003342b534310919abc9c87418Dan Gohman BasicBlock *LLVMSucc = BI->getSuccessor(0); 6443df24e667f04a7003342b534310919abc9c87418Dan Gohman MachineBasicBlock *MSucc = MBBMap[LLVMSucc]; 645d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman FastEmitBranch(MSucc); 6463df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 6479d5b41624003daf259b33fc953aa471049700353Owen Anderson } 6483df24e667f04a7003342b534310919abc9c87418Dan Gohman 6493df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 6503df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 6513df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 652b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 653b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 654087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 655087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 656087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 657087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 6583df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PHI: 6593df24e667f04a7003342b534310919abc9c87418Dan Gohman // PHI nodes are already emitted. 6603df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 6610586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 6620586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 6630586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 6640586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman if (StaticAllocaMap.count(cast<AllocaInst>(I))) 6650586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 6660586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 6670586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 6680586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 6693df24e667f04a7003342b534310919abc9c87418Dan Gohman 67033134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 67133134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 67233134c4a75558288d663267c8991f6bd37a530afDan Gohman 6733df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 6743df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 6753df24e667f04a7003342b534310919abc9c87418Dan Gohman 6763df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 6773df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 6783df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 6793df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 6803df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 6813df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 6823df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 6833df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 6843df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 6853df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 6863df24e667f04a7003342b534310919abc9c87418Dan Gohman 6873df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 6883df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 689e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 690e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 6913df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 6923df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 6933df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 6943df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 6953df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 6963df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 6973df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 6983df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 6993df24e667f04a7003342b534310919abc9c87418Dan Gohman } 700d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 7013df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 7023df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 7033df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 7043df24e667f04a7003342b534310919abc9c87418Dan Gohman } 705b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 706b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7073df24e667f04a7003342b534310919abc9c87418Dan GohmanFastISel::FastISel(MachineFunction &mf, 708d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MachineModuleInfo *mmi, 70983489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DwarfWriter *dw, 7103df24e667f04a7003342b534310919abc9c87418Dan Gohman DenseMap<const Value *, unsigned> &vm, 7110586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman DenseMap<const BasicBlock *, MachineBasicBlock *> &bm, 712dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman DenseMap<const AllocaInst *, int> &am 713dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 714dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman , SmallSet<Instruction*, 8> &cil 715dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 716dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman ) 7173df24e667f04a7003342b534310919abc9c87418Dan Gohman : MBB(0), 7183df24e667f04a7003342b534310919abc9c87418Dan Gohman ValueMap(vm), 7193df24e667f04a7003342b534310919abc9c87418Dan Gohman MBBMap(bm), 7200586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman StaticAllocaMap(am), 721dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 722dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman CatchInfoLost(cil), 723dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 7243df24e667f04a7003342b534310919abc9c87418Dan Gohman MF(mf), 725d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman MMI(mmi), 72683489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel DW(dw), 7273df24e667f04a7003342b534310919abc9c87418Dan Gohman MRI(MF.getRegInfo()), 7280586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman MFI(*MF.getFrameInfo()), 7290586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman MCP(*MF.getConstantPool()), 7303df24e667f04a7003342b534310919abc9c87418Dan Gohman TM(MF.getTarget()), 73122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TD(*TM.getTargetData()), 73222bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 733e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson TLI(*TM.getTargetLowering()) { 734bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 735bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 736e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 737e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 738825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 7397c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned) { 740b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 741b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 742b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 743825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 7447c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, unsigned /*Op0*/) { 745b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 746b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 747b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 748825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rr(MVT, MVT, 7497c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, unsigned /*Op0*/, 7500f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned /*Op0*/) { 751b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 752b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 753b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 7547c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 75583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 75683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 75783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 758825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 7597c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, ConstantFP * /*FPImm*/) { 76010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 76110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 76210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 763825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 7647c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, unsigned /*Op0*/, 7650f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 766d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 767d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 768d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 769825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 7707c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, unsigned /*Op0*/, 77110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ConstantFP * /*FPImm*/) { 77210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 77310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 77410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 775825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 7767c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, 777d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned /*Op0*/, unsigned /*Op1*/, 778d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 77983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 78083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 78183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 78283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 78383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 78483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 78583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 7867c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 787d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, uint64_t Imm, 788825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT ImmType) { 78983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 790151ed61a2f9c3482d35a54d502e7cd147f22a21bDan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Imm); 79183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 79283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 7930f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 794d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (MaterialReg == 0) 795d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 7960f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg); 797d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 798d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 79910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf_ - This method is a wrapper of FastEmit_ri. It first tries 80010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// to emit an instruction with a floating-point immediate operand using 80110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf. If that fails, it materializes the immediate into a register 80210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// and try FastEmit_rr instead. 8037c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_rf_(MVT VT, unsigned Opcode, 80410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned Op0, ConstantFP *FPImm, 805825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT ImmType) { 80610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // First check if immediate type is legal. If not, we can't use the rf form. 807151ed61a2f9c3482d35a54d502e7cd147f22a21bDan Gohman unsigned ResultReg = FastEmit_rf(VT, VT, Opcode, Op0, FPImm); 80810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ResultReg != 0) 80910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 81010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 81110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Materialize the constant in a register. 81210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned MaterialReg = FastEmit_f(ImmType, ImmType, ISD::ConstantFP, FPImm); 81310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) { 81496a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // If the target doesn't have a way to directly enter a floating-point 81596a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // value into a register, use an alternate approach. 81696a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // TODO: The current approach only supports floating-point constants 81796a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // that can be constructed by conversion from integer values. This should 81896a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // be replaced by code that creates a load from a constant-pool entry, 81996a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // which will require some target-specific work. 82010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const APFloat &Flt = FPImm->getValueAPF(); 821e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 82210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 82310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint64_t x[2]; 82410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 82523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 82623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 82723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 82823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (!isExact) 82910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 83010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman APInt IntVal(IntBitWidth, 2, x); 83110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 83210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned IntegerReg = FastEmit_i(IntVT.getSimpleVT(), IntVT.getSimpleVT(), 83310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::Constant, IntVal.getZExtValue()); 83410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (IntegerReg == 0) 83510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 83610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman MaterialReg = FastEmit_r(IntVT.getSimpleVT(), VT, 83710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::SINT_TO_FP, IntegerReg); 83810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) 83910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 84010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 84110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return FastEmit_rr(VT, VT, Opcode, Op0, MaterialReg); 84210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 84310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 844d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 845d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 84683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 84783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 848b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 84977ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 850d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 851bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 852b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 8539bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg); 854b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 855b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 856b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 857b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 858b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 859b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman unsigned Op0) { 860d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 861bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 862b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 8635960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 8649bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0); 8655960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 8669bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0); 8675960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 8685960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 8695960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 8705960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 8715960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 8725960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 873b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 874b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 875b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 876b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 877b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 878b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman unsigned Op0, unsigned Op1) { 879d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 880bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 881b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 8825960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 8839bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addReg(Op1); 8845960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 8859bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addReg(Op1); 8865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 8875960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 8885960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 8895960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 8905960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 891b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 892b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 893d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 894d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 895d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 896d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, uint64_t Imm) { 897d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 898d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 899d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 9005960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9019bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addImm(Imm); 9025960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9039bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addImm(Imm); 9045960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9055960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9065960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9075960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9085960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 909d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 910d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 911d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 91210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 91310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 91410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned Op0, ConstantFP *FPImm) { 91510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 91610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 91710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 9185960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9199bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addFPImm(FPImm); 9205960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9219bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addFPImm(FPImm); 9225960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9235960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9245960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9255960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9265960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 92710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 92810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 92910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 930d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 931d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 932d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned Op0, unsigned Op1, uint64_t Imm) { 933d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 934d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 935d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 9365960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9379bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addReg(Op1).addImm(Imm); 9385960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9399bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addReg(Op1).addImm(Imm); 9405960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9415960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9425960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9435960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9445960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 945d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 946d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 9476d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 9486d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 9496d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 9506d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 9516d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 9526d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetInstrDesc &II = TII.get(MachineInstOpcode); 9536d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 9545960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9559bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addImm(Imm); 9565960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9579bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addImm(Imm); 9585960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9595960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9605960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9615960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9625960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 9636d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 964b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 9658970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 966825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 967536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned Op0, uint32_t Idx) { 96840a468f24909792f000e3ccc1dda7a27b9c34b69Owen Anderson const TargetRegisterClass* RC = MRI.getRegClass(Op0); 9698970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 970536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 9718970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson const TargetInstrDesc &II = TII.get(TargetInstrInfo::EXTRACT_SUBREG); 9728970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 9735960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 9749bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II, ResultReg).addReg(Op0).addImm(Idx); 9755960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 9769bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling BuildMI(MBB, DL, II).addReg(Op0).addImm(Idx); 9775960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng bool InsertedCopy = TII.copyRegToReg(*MBB, MBB->end(), ResultReg, 9785960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng II.ImplicitDefs[0], RC, RC); 9795960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (!InsertedCopy) 9805960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng ResultReg = 0; 9815960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 9828970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 9838970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 98414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 98514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 98614ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 987825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op) { 98814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op, 1); 98914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 990