FastISel.cpp revision 18112d83e7d54597bcd5870fb411c7997e02bc1e
13b172f1c018a093d0dae3105324d782103fcda6dDan 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 42053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier#define DEBUG_TYPE "isel" 4333134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/Function.h" 4433134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/GlobalVariable.h" 456f2766d59744bb3d48867f3151643eac7111e773Dan Gohman#include "llvm/Instructions.h" 4633134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/IntrinsicInst.h" 47562b84b3aea359d1f918184e355da82bf05eb290Jay Foad#include "llvm/Operator.h" 482586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman#include "llvm/CodeGen/Analysis.h" 49b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/FastISel.h" 504c3fd9f92f89810d659973d2666ab729758de64aDan Gohman#include "llvm/CodeGen/FunctionLoweringInfo.h" 51b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineInstrBuilder.h" 5233134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/CodeGen/MachineModuleInfo.h" 53b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineRegisterInfo.h" 5483489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/Analysis/DebugInfo.h" 557fbcc98f20c062273bf16ce9832f40e5b8a205c6Dan Gohman#include "llvm/Analysis/Loads.h" 5683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetData.h" 57b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 5883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 59bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 60ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman#include "llvm/Support/ErrorHandling.h" 61afeaae7a940ce16e7874af31f3e5e91d8ca89e19Devang Patel#include "llvm/Support/Debug.h" 62053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier#include "llvm/ADT/Statistic.h" 63b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 64b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 65aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessIndependent, "Number of insts selected by " 66aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-independent selector"); 67aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessTarget, "Number of insts selected by " 68aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-specific selector"); 69ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad RosierSTATISTIC(NumFastIselDead, "Number of dead insts removed on failure"); 70053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier 7184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// startNewBlock - Set the current block to which generated machine 7284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// instructions will be appended, and clear the local CSE map. 7384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// 7484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::startNewBlock() { 7584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LocalValueMap.clear(); 7684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 7774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = 0; 7884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 7974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Advance the emit start point past any EH_LABEL instructions. 8084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator 8184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman I = FuncInfo.MBB->begin(), E = FuncInfo.MBB->end(); 8284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (I != E && I->getOpcode() == TargetOpcode::EH_LABEL) { 8374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = I; 8484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++I; 8584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 8674af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 8774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin} 8874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 8974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasinvoid FastISel::flushLocalValueMap() { 9074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LocalValueMap.clear(); 9174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 9274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin recomputeInsertPt(); 9384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 9484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 95a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanbool FastISel::hasTrivialKill(const Value *V) const { 967f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Don't consider constants or arguments to have trivial kills. 97a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const Instruction *I = dyn_cast<Instruction>(V); 987f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (!I) 997f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1007f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 1017f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // No-op casts are trivially coalesced by fast-isel. 1027f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (const CastInst *Cast = dyn_cast<CastInst>(I)) 1037f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) && 1047f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !hasTrivialKill(Cast->getOperand(0))) 1057f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1067f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 10722b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier // GEPs with all zero indices are trivially coalesced by fast-isel. 10822b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) 10922b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (GEP->hasAllZeroIndices() && !hasTrivialKill(GEP->getOperand(0))) 11022b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier return false; 11122b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier 1127f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Only instructions with a single use in the same basic block are considered 1137f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // to have trivial kills. 1147f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return I->hasOneUse() && 1157f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !(I->getOpcode() == Instruction::BitCast || 1167f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::PtrToInt || 1177f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::IntToPtr) && 11896f1d8ebdd33b3f9bdb3b1163f36072c68599f42Gabor Greif cast<Instruction>(*I->use_begin())->getParent() == I->getParent(); 119a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman} 120a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 12146510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::getRegForValue(const Value *V) { 122e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 1234fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 1244fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 1254fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 126821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 127c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 128c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 129c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 130825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 131821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 13276927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Handle integer promotions, though, because they're common and easy. 13376927d7303046058c627691bd45d6bff608f49f4Eli Friedman if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 13423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 135821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 136821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 137821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 138821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 1394e27027562d6843364e0ab744f97958b6abca08dEric Christopher // Look up the value to see if we already have a register for it. 1404e27027562d6843364e0ab744f97958b6abca08dEric Christopher unsigned Reg = lookUpRegForValue(V); 141c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 142c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 143c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 14497c94b8fc630b55e17a37481910810639e28d086Dan Gohman // In bottom-up mode, just create the virtual register which will be used 14597c94b8fc630b55e17a37481910810639e28d086Dan Gohman // to hold the value. It will be materialized later. 14684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (isa<Instruction>(V) && 14784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman (!isa<AllocaInst>(V) || 14884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(V)))) 14984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return FuncInfo.InitializeRegForValue(V); 15084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 151a10b8494a50108482302f6f077d72fbc76d776edDan Gohman SavePoint SaveInsertPt = enterLocalValueArea(); 15284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 15384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Materialize the value in a register. Emit any instructions in the 15484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // local value area. 15584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Reg = materializeRegForValue(V, VT); 15684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 15784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman leaveLocalValueArea(SaveInsertPt); 15897c94b8fc630b55e17a37481910810639e28d086Dan Gohman 15984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return Reg; 1601fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman} 1611fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 16244a2c3476bd15e03f294bae1b50016851f214f8dEric Christopher/// materializeRegForValue - Helper for getRegForValue. This function is 1631fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// called when the value isn't already available in a register and must 1641fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// be materialized with new instructions. 1651fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohmanunsigned FastISel::materializeRegForValue(const Value *V, MVT VT) { 1661fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman unsigned Reg = 0; 1671fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 16846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 1692ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 1702ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 1710586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 1722ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 173205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 1741e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 1751e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 1761d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 1771d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 17846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 179bd1253809bc1b2455793a64d2801db3d6317b08eEli Friedman if (CF->isNullValue()) { 1802790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = TargetMaterializeFloatZero(CF); 1812790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } else { 1822790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman // Try to emit the constant directly. 1832790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 1842790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } 185ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 186ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 1874183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Try to emit the constant by using an integer constant with a cast. 188ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 189e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 190ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 191ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 192ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 19323a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 19423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 195c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher APFloat::rmTowardZero, &isExact); 19623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 1973ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin APInt IntVal(IntBitWidth, x); 198ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 199e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 200eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 2012ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 202a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, 203a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntegerReg, /*Kill=*/false); 2042ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 205ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 20646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const Operator *Op = dyn_cast<Operator>(V)) { 20720d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!SelectOperator(Op, Op->getOpcode())) 20820d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!isa<Instruction>(Op) || 20920d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman !TargetSelectInstruction(cast<Instruction>(Op))) 21020d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman return 0; 21137db6cdaea47d0637bdbe624f7b10ff8f82928adDan Gohman Reg = lookUpRegForValue(Op); 212205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 213104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 21484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 21584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.get(TargetOpcode::IMPLICIT_DEF), Reg); 216ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 217bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 218dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 219dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 2206e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 2212ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 222bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2232ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 2242ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 22584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (Reg != 0) { 226dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 22784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = MRI.getVRegDef(Reg); 22884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 229104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 230ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 231ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 23246510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::lookUpRegForValue(const Value *V) { 23359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 23459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 23559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 2361fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman // def-dominates-use requirement enforced. 237a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 238a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (I != FuncInfo.ValueMap.end()) 2393193a689db3de8640d412ccd9482301647359a4eDan Gohman return I->second; 24059fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return LocalValueMap[V]; 24159fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 24259fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 243cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 244cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 245cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 246cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 247cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 248cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 249482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedmanvoid FastISel::UpdateValueMap(const Value *I, unsigned Reg, unsigned NumRegs) { 25040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 25140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 252482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman return; 253c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 254bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 255a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned &AssignedReg = FuncInfo.ValueMap[I]; 256c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 25784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Use the new register. 258c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 25936e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 26084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Arrange for uses of AssignedReg to be replaced by uses of Reg. 261482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman for (unsigned i = 0; i < NumRegs; i++) 262482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman FuncInfo.RegFixups[AssignedReg+i] = Reg+i; 26384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 26484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman AssignedReg = Reg; 26540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 266cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 267cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 268a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanstd::pair<unsigned, bool> FastISel::getRegForGEPIndex(const Value *Idx) { 269c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 270c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 271c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 272a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(0, false); 273a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 274a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = hasTrivialKill(Idx); 275c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 276c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 277766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 278e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 279a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman if (IdxVT.bitsLT(PtrVT)) { 280a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, 281a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 282a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 283a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 284a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman else if (IdxVT.bitsGT(PtrVT)) { 285a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, 286a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 287a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 288a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 289a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(IdxN, IdxNIsKill); 290c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 291c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 29284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::recomputeInsertPt() { 29384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (getLastLocalValue()) { 29484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = getLastLocalValue(); 295c6e59b71f50c7c77bc448a936dba8e84d90911e8Dan Gohman FuncInfo.MBB = FuncInfo.InsertPt->getParent(); 29684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 29784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } else 29884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = FuncInfo.MBB->getFirstNonPHI(); 29984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 30084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Now skip past any EH_LABELs, which must remain at the beginning. 30184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (FuncInfo.InsertPt != FuncInfo.MBB->end() && 30284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt->getOpcode() == TargetOpcode::EH_LABEL) 30384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 30484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 30584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 306ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosiervoid FastISel::removeDeadCode(MachineBasicBlock::iterator I, 307ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator E) { 308ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier assert (I && E && std::distance(I, E) > 0 && "Invalid iterator!"); 309ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier while (I != E) { 310ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineInstr *Dead = &*I; 311ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier ++I; 312ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier Dead->eraseFromParent(); 313ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier ++NumFastIselDead; 314ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 315ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 316ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier} 317ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 318a10b8494a50108482302f6f077d72fbc76d776edDan GohmanFastISel::SavePoint FastISel::enterLocalValueArea() { 31984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt; 320163f78ea4016d594d921154d8df1c9d746fb0ea8Dan Gohman DebugLoc OldDL = DL; 32184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman recomputeInsertPt(); 322a10b8494a50108482302f6f077d72fbc76d776edDan Gohman DL = DebugLoc(); 323163f78ea4016d594d921154d8df1c9d746fb0ea8Dan Gohman SavePoint SP = { OldInsertPt, OldDL }; 324a10b8494a50108482302f6f077d72fbc76d776edDan Gohman return SP; 32584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 32684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 327a10b8494a50108482302f6f077d72fbc76d776edDan Gohmanvoid FastISel::leaveLocalValueArea(SavePoint OldInsertPt) { 32884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.InsertPt != FuncInfo.MBB->begin()) 32984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = llvm::prior(FuncInfo.InsertPt); 33084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 33184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Restore the previous insert position. 332a10b8494a50108482302f6f077d72fbc76d776edDan Gohman FuncInfo.InsertPt = OldInsertPt.InsertPt; 333a10b8494a50108482302f6f077d72fbc76d776edDan Gohman DL = OldInsertPt.DL; 33484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 33584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 336bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 337bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 338bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 33946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBinaryOp(const User *I, unsigned ISDOpcode) { 340e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 341825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::Other || !VT.isSimple()) 342d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 343d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 344638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 345b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 346b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 347b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 348b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 349638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 350825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 351638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 352825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 3535dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 3545dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 35523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), VT); 356638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 357638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 358638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 359d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 360fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // Check if the first operand is a constant, and handle it as "ri". At -O0, 361fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // we don't have anything that canonicalizes operand order. 362fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(0))) 363fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (isa<Instruction>(I) && cast<Instruction>(I)->isCommutative()) { 364fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner unsigned Op1 = getRegForValue(I->getOperand(1)); 365fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (Op1 == 0) return false; 366fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner 367fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 368d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 369602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op1, 370602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op1IsKill, CI->getZExtValue(), 371602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner VT.getSimpleVT()); 372602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 373d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 374602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 375602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 376602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 377fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner } 378d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 379d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 3803df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 381602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Op0 == 0) // Unhandled operand. Halt "fast" selection and bail. 382a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 383a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 384a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 385a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 386d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 387d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 388602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner uint64_t Imm = CI->getZExtValue(); 389d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 390f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner // Transform "sdiv exact X, 8" -> "sra X, 3". 391f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner if (ISDOpcode == ISD::SDIV && isa<BinaryOperator>(I) && 392f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner cast<BinaryOperator>(I)->isExact() && 393f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner isPowerOf2_64(Imm)) { 394f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner Imm = Log2_64(Imm); 395f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner ISDOpcode = ISD::SRA; 396f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner } 397d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 398544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier // Transform "urem x, pow2" -> "and x, pow2-1". 399544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier if (ISDOpcode == ISD::UREM && isa<BinaryOperator>(I) && 400544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier isPowerOf2_64(Imm)) { 401544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier --Imm; 402544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier ISDOpcode = ISD::AND; 403544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier } 404544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier 405602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op0, 406602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op0IsKill, Imm, VT.getSimpleVT()); 407602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 408d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 409602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 410602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 411602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 412d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 413d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 41410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 41510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 416ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 417a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, Op0, Op0IsKill, CF); 418ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 419ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 4203df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 421ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 422ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 42310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 42410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 4253df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 426d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 427d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 428bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 429bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 430a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 431a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 432ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 4330f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 434a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, 435a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 436a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op1, Op1IsKill); 437bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 438bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 439bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 440bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 441bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 4428014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 4433df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 444bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 445bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 446bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 44746510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectGetElementPtr(const User *I) { 4483df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 44983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 45083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 45183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 45283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 453a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool NIsKill = hasTrivialKill(I->getOperand(0)); 454a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 455478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Keep a running tab of the total offset to coalesce multiple N = N + Offset 456478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // into a single N = N + TotalOffset. 457478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t TotalOffs = 0; 458478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // FIXME: What's a good SWAG number for MaxOffs? 459478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t MaxOffs = 2048; 460db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I->getOperand(0)->getType(); 461825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 46246510a73e977273ec67747eb34cbdb43f815e451Dan Gohman for (GetElementPtrInst::const_op_iterator OI = I->op_begin()+1, 46346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman E = I->op_end(); OI != E; ++OI) { 46446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Idx = *OI; 465db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *StTy = dyn_cast<StructType>(Ty)) { 46683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 46783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 46883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 469478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs += TD.getStructLayout(StTy)->getElementOffset(Field); 470478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 471478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 472478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 473478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 474478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 475478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 476478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 477478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 47883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 47983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 48083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 48183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 48283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 48383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 48446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 485e368b460a206fafa0d31d5d059b1779b94f7df8cDan Gohman if (CI->isZero()) continue; 486478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // N = N + Offset 487478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs += 488777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 489478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 490478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 491478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 492478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 493478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 494478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 495478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 496478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 497478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier continue; 498478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 499478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 500478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 50183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 50283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 50383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 504a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman NIsKill = true; 505478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 50683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 507bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 50883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 509777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 510a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman std::pair<unsigned, bool> Pair = getRegForGEPIndex(Idx); 511a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IdxN = Pair.first; 512a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = Pair.second; 51383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 51483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 51583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 51683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 51780bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 518a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, IdxNIsKill, ElementSize, VT); 51980bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 52080bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 52180bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 522a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 52380bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 524a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_rr(VT, VT, ISD::ADD, N, NIsKill, IdxN, IdxNIsKill); 52583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 52683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 52783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 52883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 52983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 530478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 531478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 532478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 533478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 534478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 535478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 53683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 53783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 5383df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 53983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 540bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 541bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 54246510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCall(const User *I) { 543a61e73bda5125c28e48b52e573d115370838596bDan Gohman const CallInst *Call = cast<CallInst>(I); 544a61e73bda5125c28e48b52e573d115370838596bDan Gohman 545a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Handle simple inline asms. 5469e15d658c99c3f0717cb83cc2bd2aa29abdbcdbbDan Gohman if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledValue())) { 547a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Don't attempt to handle constraints. 548a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (!IA->getConstraintString().empty()) 549a61e73bda5125c28e48b52e573d115370838596bDan Gohman return false; 550a61e73bda5125c28e48b52e573d115370838596bDan Gohman 551a61e73bda5125c28e48b52e573d115370838596bDan Gohman unsigned ExtraInfo = 0; 552a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->hasSideEffects()) 553a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_HasSideEffects; 554a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->isAlignStack()) 555a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_IsAlignStack; 556a61e73bda5125c28e48b52e573d115370838596bDan Gohman 557a61e73bda5125c28e48b52e573d115370838596bDan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 558a61e73bda5125c28e48b52e573d115370838596bDan Gohman TII.get(TargetOpcode::INLINEASM)) 559a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addExternalSymbol(IA->getAsmString().c_str()) 560a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addImm(ExtraInfo); 561a61e73bda5125c28e48b52e573d115370838596bDan Gohman return true; 562a61e73bda5125c28e48b52e573d115370838596bDan Gohman } 563a61e73bda5125c28e48b52e573d115370838596bDan Gohman 564c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer MachineModuleInfo &MMI = FuncInfo.MF->getMMI(); 565c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer ComputeUsesVAFloatArgument(*Call, &MMI); 566c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer 567a61e73bda5125c28e48b52e573d115370838596bDan Gohman const Function *F = Call->getCalledFunction(); 56833134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 56933134c4a75558288d663267c8991f6bd37a530afDan Gohman 5704183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Handle selected intrinsic function calls. 571832e4943598d821687cec79f512803c1ca03cff7Chris Lattner switch (F->getIntrinsicID()) { 57233134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 5739b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher // At -O0 we don't care about the lifetime intrinsics. 5749b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_start: 5759b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_end: 5769b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher return true; 57792c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 578a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgDeclareInst *DI = cast<DbgDeclareInst>(Call); 57902f0dbd97a9bc01528aa12c2f260d928683ab411Devang Patel if (!DIVariable(DI->getVariable()).Verify() || 580bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher !FuncInfo.MF->getMMI().hasDebugInfo()) { 581bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 5827e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 583bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 58492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 58546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Address = DI->getAddress(); 586ccaea7dc0bbc75e5d4ee92fb8cc6af0f928d056fEric Christopher if (!Address || isa<UndefValue>(Address)) { 587bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 588dc9185657593b5c1db86cb95a04a68fc09194993Dale Johannesen return true; 589bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 5906fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel 5916fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Reg = 0; 5926fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Offset = 0; 5936fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (const Argument *Arg = dyn_cast<Argument>(Address)) { 5949aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel // Some arguments' frame index is recorded during argument lowering. 5959aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel Offset = FuncInfo.getArgumentFrameIndex(Arg); 5969aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel if (Offset) 597c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher Reg = TRI.getFrameRegister(*FuncInfo.MF); 5984bafda9618f9dfa9edc8da08bb3001ef2d1a9b68Devang Patel } 5996fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (!Reg) 6008c5293c9556317143505c085cf428e11962e1273Eric Christopher Reg = lookUpRegForValue(Address); 6018c5293c9556317143505c085cf428e11962e1273Eric Christopher 60284364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we have a VLA that has a "use" in a metadata node that's then used 60384364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // here but it has no other uses, then we have a problem. E.g., 60484364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 60584364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // int foo (const int *x) { 60684364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // char a[*x]; 60784364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // return 0; 60884364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // } 60984364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 61084364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we assign 'a' a vreg and fast isel later on has to use the selection 61184364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // DAG isel, it will want to copy the value to the vreg. However, there are 61284364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // no uses, which goes counter to what selection DAG isel expects. 61384364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling if (!Reg && !Address->use_empty() && isa<Instruction>(Address) && 6148c5293c9556317143505c085cf428e11962e1273Eric Christopher (!isa<AllocaInst>(Address) || 6158c5293c9556317143505c085cf428e11962e1273Eric Christopher !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(Address)))) 6168c5293c9556317143505c085cf428e11962e1273Eric Christopher Reg = FuncInfo.InitializeRegForValue(Address); 617bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 6186fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (Reg) 619bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 6206fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel TII.get(TargetOpcode::DBG_VALUE)) 6216fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addReg(Reg, RegState::Debug).addImm(Offset) 6226fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addMetadata(DI->getVariable()); 6234476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher else 6244476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // We can't yet handle anything else here because it would require 6254476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // generating code, thus altering codegen because of debug info. 6264476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher DEBUG(dbgs() << "Dropping debug info for " << DI); 62733134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 62892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 62945df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen case Intrinsic::dbg_value: { 630343b42e428079363ab09828734b2debfd7dbdc9eDale Johannesen // This form of DBG_VALUE is target-independent. 631a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgValueInst *DI = cast<DbgValueInst>(Call); 632e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE); 63346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *V = DI->getValue(); 63445df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen if (!V) { 63545df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // Currently the optimizer can produce this; insert an undef to 63645df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // help debugging. Probably the optimizer should not do this. 63784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 63884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(0U).addImm(DI->getOffset()) 63984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 64046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 6418594d429e02c688d428036f8563f09572da3fbffDevang Patel if (CI->getBitWidth() > 64) 6428594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6438594d429e02c688d428036f8563f09572da3fbffDevang Patel .addCImm(CI).addImm(DI->getOffset()) 6448594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 6458594d429e02c688d428036f8563f09572da3fbffDevang Patel else 6468594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6478594d429e02c688d428036f8563f09572da3fbffDevang Patel .addImm(CI->getZExtValue()).addImm(DI->getOffset()) 6488594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 64946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 65084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 65184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addFPImm(CF).addImm(DI->getOffset()) 65284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 65345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else if (unsigned Reg = lookUpRegForValue(V)) { 65484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 65584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Reg, RegState::Debug).addImm(DI->getOffset()) 65684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 65745df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else { 65845df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // We can't yet handle anything else here because it would require 65945df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // generating code, thus altering codegen because of debug info. 660afeaae7a940ce16e7874af31f3e5e91d8ca89e19Devang Patel DEBUG(dbgs() << "Dropping debug info for " << DI); 661bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 66245df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen return true; 66345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } 664d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman case Intrinsic::objectsize: { 665d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman ConstantInt *CI = cast<ConstantInt>(Call->getArgOperand(1)); 666d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned long long Res = CI->isZero() ? -1ULL : 0; 667d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman Constant *ResCI = ConstantInt::get(Call->getType(), Res); 668d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned ResultReg = getRegForValue(ResCI); 669d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman if (ResultReg == 0) 670d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return false; 671d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman UpdateValueMap(Call, ResultReg); 672d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return true; 673d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman } 67433134c4a75558288d663267c8991f6bd37a530afDan Gohman } 6754183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman 67674af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Usually, it does not make sense to initialize a value, 67774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // make an unrelated function call and use the value, because 67874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // it tends to be spilled on the stack. So, we move the pointer 67974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // to the last local value to the beginning of the block, so that 68074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // all the values which have already been materialized, 68174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // appear after the call. It also makes sense to skip intrinsics 68274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // since they tend to be inlined. 68374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin if (!isa<IntrinsicInst>(F)) 68474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin flushLocalValueMap(); 68574af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 6864183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // An arbitrary call. Bail. 68733134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 68833134c4a75558288d663267c8991f6bd37a530afDan Gohman} 68933134c4a75558288d663267c8991f6bd37a530afDan Gohman 69046510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCast(const User *I, unsigned Opcode) { 691e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 692e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 693bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 694825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 695825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 696d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 697d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 698bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 69976927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the destination type is legal. 700474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 70176927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 702474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 70376927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the source operand is legal. 704474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 70576927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 706474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 7073df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 708d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 709d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 710d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 71114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 712a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool InputRegIsKill = hasTrivialKill(I->getOperand(0)); 713a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 714d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 715d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 716d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 717a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputReg, InputRegIsKill); 718d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 719d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 720bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7213df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 722d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 723d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 724d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 72546510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBitCast(const User *I) { 726ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 727ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 7283df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 729a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 730a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 7313df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 732ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 733ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 734ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 735bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Bitcasts of other values become reg-reg copies or BITCAST operators. 736e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 737e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 738bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 739825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 740825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple() || 741d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 742d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 743d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 744bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7453df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 746ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 747ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 748d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 749a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 750a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 751bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 752ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 753ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 754ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) { 75544d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 75644d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 757e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen // Don't attempt a cross-class copy. It will likely fail. 758e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen if (SrcClass == DstClass) { 759e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg = createResultReg(DstClass); 760e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 761e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg).addReg(Op0); 762e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen } 763ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 764bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 765bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If the reg-reg copy failed, select a BITCAST opcode. 766ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 767ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), 768bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, Op0, Op0IsKill); 769bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 770ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 771d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 772bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7733df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 774d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 775d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 776d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 7773df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 77846510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectInstruction(const Instruction *I) { 779e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // Just before the terminator instruction, insert instructions to 780e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // feed PHI nodes in successor blocks. 781e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (isa<TerminatorInst>(I)) 782e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (!HandlePHINodesInSuccessorBlocks(I->getParent())) 783e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman return false; 784e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman 7858ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = I->getDebugLoc(); 7868ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman 787ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator SavedInsertPt = FuncInfo.InsertPt; 788ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 7896e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // First, try doing target-independent selection. 7908ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (SelectOperator(I, I->getOpcode())) { 791053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier ++NumFastIselSuccessIndependent; 7928ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 7936e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 7948ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 795ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // Remove dead code. However, ignore call instructions since we've flushed 796ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // the local value map and recomputed the insert point. 797ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (!isa<CallInst>(I)) { 798ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 799ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 800ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 801ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 8026e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8036e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // Next, try calling the target to attempt to handle the instruction. 804ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier SavedInsertPt = FuncInfo.InsertPt; 8058ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (TargetSelectInstruction(I)) { 806053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier ++NumFastIselSuccessTarget; 8078ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8086e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8098ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 810ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // Check for dead code and remove as necessary. 811ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 812ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 813ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 8146e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8158ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8166e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return false; 81740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 81840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 819d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 820d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 821d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 822d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 8233bf912593301152b65accb9d9c37a95172f1df5aStuart HastingsFastISel::FastEmitBranch(MachineBasicBlock *MSucc, DebugLoc DL) { 82418112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher 82518112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher if (FuncInfo.MBB->getBasicBlock()->size() > 1 && FuncInfo.MBB->isLayoutSuccessor(MSucc)) { 82618112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // For more accurate line information if this is the only instruction 82718112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // in the block then emit it, otherwise we have the unconditional 82818112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // fall-through case, which needs no instructions. 829d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 830d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 83184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.InsertBranch(*FuncInfo.MBB, MSucc, NULL, 83284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVector<MachineOperand, 0>(), DL); 833d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 83484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.MBB->addSuccessor(MSucc); 835d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 836d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 8373d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// SelectFNeg - Emit an FNeg operation. 8383d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// 8393d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohmanbool 84046510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectFNeg(const User *I) { 8413d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 8423d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (OpReg == 0) return false; 8433d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 844a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool OpRegIsKill = hasTrivialKill(I); 845a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 8464a215a13c3035a8818254b61267be77def4a2a37Dan Gohman // If the target has ISD::FNEG, use it. 8474a215a13c3035a8818254b61267be77def4a2a37Dan Gohman EVT VT = TLI.getValueType(I->getType()); 8484a215a13c3035a8818254b61267be77def4a2a37Dan Gohman unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 849a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::FNEG, OpReg, OpRegIsKill); 8504a215a13c3035a8818254b61267be77def4a2a37Dan Gohman if (ResultReg != 0) { 8514a215a13c3035a8818254b61267be77def4a2a37Dan Gohman UpdateValueMap(I, ResultReg); 8524a215a13c3035a8818254b61267be77def4a2a37Dan Gohman return true; 8534a215a13c3035a8818254b61267be77def4a2a37Dan Gohman } 8544a215a13c3035a8818254b61267be77def4a2a37Dan Gohman 8555e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // Bitcast the value to integer, twiddle the sign bit with xor, 8565e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // and then bitcast it back to floating-point. 8573d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (VT.getSizeInBits() > 64) return false; 8585e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 8595e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (!TLI.isTypeLegal(IntVT)) 8605e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 8615e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 8625e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 863bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, OpReg, OpRegIsKill); 8645e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntReg == 0) 8655e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 8665e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 867a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, 868a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntReg, /*Kill=*/true, 8695e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman UINT64_C(1) << (VT.getSizeInBits()-1), 8705e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman IntVT.getSimpleVT()); 8715e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntResultReg == 0) 8725e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 8735e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 8745e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 875bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, IntResultReg, /*Kill=*/true); 8763d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (ResultReg == 0) 8773d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return false; 8783d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 8793d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman UpdateValueMap(I, ResultReg); 8803d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return true; 8813d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman} 8823d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 88340b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 8842586b8f9366aed5a1efa44d3f18d095511601642Eli FriedmanFastISel::SelectExtractValue(const User *U) { 8852586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U); 886a4c920db7a3620f365144eac9aaad7ca23062caaEli Friedman if (!EVI) 8872586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 8882586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 889482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // Make sure we only try to handle extracts with a legal result. But also 890482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // allow i1 because it's easy. 8912586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman EVT RealVT = TLI.getValueType(EVI->getType(), /*AllowUnknown=*/true); 8922586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (!RealVT.isSimple()) 8932586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 8942586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman MVT VT = RealVT.getSimpleVT(); 895482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman if (!TLI.isTypeLegal(VT) && VT != MVT::i1) 8962586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 8972586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 8982586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const Value *Op0 = EVI->getOperand(0); 899db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AggTy = Op0->getType(); 9002586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9012586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the base result register. 9022586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman unsigned ResultReg; 9032586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0); 9042586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (I != FuncInfo.ValueMap.end()) 9052586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = I->second; 9060b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else if (isa<Instruction>(Op0)) 9072586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = FuncInfo.InitializeRegForValue(Op0); 9080b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else 9090b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman return false; // fast-isel can't handle aggregate constants at the moment 9102586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9112586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the actual result register, which is an offset from the base register. 912fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad unsigned VTIndex = ComputeLinearIndex(AggTy, EVI->getIndices()); 9132586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9142586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman SmallVector<EVT, 4> AggValueVTs; 9152586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ComputeValueVTs(TLI, AggTy, AggValueVTs); 9162586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9172586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman for (unsigned i = 0; i < VTIndex; i++) 9182586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg += TLI.getNumRegisters(FuncInfo.Fn->getContext(), AggValueVTs[i]); 9192586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9202586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman UpdateValueMap(EVI, ResultReg); 9212586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return true; 9222586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman} 9232586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9242586b8f9366aed5a1efa44d3f18d095511601642Eli Friedmanbool 92546510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectOperator(const User *I, unsigned Opcode) { 92640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 927ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 928ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 929ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 930ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 931ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 932ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 933ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 9343d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman // FNeg is currently represented in LLVM IR as a special case of FSub. 9353d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (BinaryOperator::isFNeg(I)) 9363d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return SelectFNeg(I); 937ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 938ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 939ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 940ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 941ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 9423df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 9433df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 9443df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 9453df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 9463df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 9473df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 9483df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 9493df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 9503df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 9513df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 9523df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 9533df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 9543df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 9553df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 9563df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 9573df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 9583df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 9593df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 9603df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 9613df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 9623df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 9633df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 9643df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 9653df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 9663df24e667f04a7003342b534310919abc9c87418Dan Gohman 9673df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 9683df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 9693df24e667f04a7003342b534310919abc9c87418Dan Gohman 9703df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 97146510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BranchInst *BI = cast<BranchInst>(I); 9723df24e667f04a7003342b534310919abc9c87418Dan Gohman 9733df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 97446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BasicBlock *LLVMSucc = BI->getSuccessor(0); 975a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc]; 9763bf912593301152b65accb9d9c37a95172f1df5aStuart Hastings FastEmitBranch(MSucc, BI->getDebugLoc()); 9773df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 9789d5b41624003daf259b33fc953aa471049700353Owen Anderson } 9793df24e667f04a7003342b534310919abc9c87418Dan Gohman 9803df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 9813df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 9823df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 983b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 984b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 985087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 986087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 987087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 988087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 9890586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 9900586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 991a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I))) 9920586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 9930586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 9940586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 9950586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 996bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 99733134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 99833134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 999bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 10003df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 10013df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 10023df24e667f04a7003342b534310919abc9c87418Dan Gohman 10033df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 10043df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 10053df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 10063df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10073df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 10083df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 10093df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 10103df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10113df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 10123df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 10133df24e667f04a7003342b534310919abc9c87418Dan Gohman 10143df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 10153df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 1016e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 1017e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 10183df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 10193df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10203df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 10213df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10223df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 10233df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 10243df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 10253df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 10263df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1027d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 10282586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman case Instruction::ExtractValue: 10292586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return SelectExtractValue(I); 10302586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 1031ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman case Instruction::PHI: 1032ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman llvm_unreachable("FastISel shouldn't visit PHI nodes!"); 1033ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman 10343df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 10353df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 10363df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 10373df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1038b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1039b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1040a4160c3434b08288d1f79f1acbe453d1b9610b22Dan GohmanFastISel::FastISel(FunctionLoweringInfo &funcInfo) 104184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman : FuncInfo(funcInfo), 1042a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MRI(FuncInfo.MF->getRegInfo()), 1043a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MFI(*FuncInfo.MF->getFrameInfo()), 1044a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MCP(*FuncInfo.MF->getConstantPool()), 1045a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman TM(FuncInfo.MF->getTarget()), 104622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TD(*TM.getTargetData()), 104722bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 1048a7a0ed79012ea36f838239cf1d04959711aec2a9Dan Gohman TLI(*TM.getTargetLowering()), 104984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TRI(*TM.getRegisterInfo()) { 1050bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 1051bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 1052e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 1053e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 1054825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 10557c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned) { 1056b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1057b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1058b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1059825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 1060a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1061a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/) { 1062b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1063b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1064b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1065bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckunsigned FastISel::FastEmit_rr(MVT, MVT, 1066a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1067a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1068a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/) { 1069b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1070b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1071b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 10727c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 107383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 107483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 107583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1076825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 107746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned, const ConstantFP * /*FPImm*/) { 107810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 107910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 108010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1081825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 1082a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1083a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 10840f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 1085d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 1086d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1087d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1088825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 1089a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1090a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 109146510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const ConstantFP * /*FPImm*/) { 109210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 109310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 109410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1095825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 10967c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, 1097a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1098a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/, 1099d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 110083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 110183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 110283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 110383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 110483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 110583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 110683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 11077c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 1108a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1109a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm, MVT ImmType) { 1110602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // If this is a multiply by a power of two, emit this as a shift left. 1111602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Opcode == ISD::MUL && isPowerOf2_64(Imm)) { 1112602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Opcode = ISD::SHL; 1113602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm = Log2_64(Imm); 1114090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner } else if (Opcode == ISD::UDIV && isPowerOf2_64(Imm)) { 1115090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner // div x, 8 -> srl x, 3 1116090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Opcode = ISD::SRL; 1117090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Imm = Log2_64(Imm); 1118602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner } 1119d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1120602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // Horrible hack (to be removed), check to make sure shift amounts are 1121602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // in-range. 1122602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if ((Opcode == ISD::SHL || Opcode == ISD::SRA || Opcode == ISD::SRL) && 1123602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm >= VT.getSizeInBits()) 1124602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return 0; 1125d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 112683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 1127a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Op0IsKill, Imm); 112883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 112983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 11300f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 1131b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman if (MaterialReg == 0) { 1132b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // This is a bit ugly/slow, but failing here means falling out of 1133b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // fast-isel, which would be very slow. 1134db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *ITy = IntegerType::get(FuncInfo.Fn->getContext(), 1135b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman VT.getSizeInBits()); 1136b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman MaterialReg = getRegForValue(ConstantInt::get(ITy, Imm)); 1137b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman } 1138a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_rr(VT, VT, Opcode, 1139a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 1140a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman MaterialReg, /*Kill=*/true); 1141d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1142d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1143d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 1144d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 114583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 114683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1147b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 114877ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 1149d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1150e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1151b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 115284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg); 1153b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1154b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1155b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1156b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 1157b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1158a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill) { 1159d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1160e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1161b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 11625960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 116384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 116484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 11655960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 116684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 116784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 1168e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1169e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 11705960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 11715960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 1172b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1173b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1174b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1175b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 1176b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1177a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1178a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill) { 1179d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1180e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1181b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 11825960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 118384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1184a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1185a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 11865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 118784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1188a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1189a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 1190e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1191e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 11925960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1193b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1194b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1195d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1196d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Andersonunsigned FastISel::FastEmitInst_rrr(unsigned MachineInstOpcode, 1197d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson const TargetRegisterClass *RC, 1198d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op0, bool Op0IsKill, 1199d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op1, bool Op1IsKill, 1200d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op2, bool Op2IsKill) { 1201d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned ResultReg = createResultReg(RC); 1202e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1203d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1204d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson if (II.getNumDefs() >= 1) 1205d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1206d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1207d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1208d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1209d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson else { 1210d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1211d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1212d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1213d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1214d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1215d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1216d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson } 1217d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson return ResultReg; 1218d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson} 1219d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1220d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 1221d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1222a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1223a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1224d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1225e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1226d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12275960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 122884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1229a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1230a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 12315960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 123284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1233a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1234a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1235e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1236e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12375960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1238d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1239d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1240d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12412ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Andersonunsigned FastISel::FastEmitInst_rii(unsigned MachineInstOpcode, 12422ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson const TargetRegisterClass *RC, 12432ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned Op0, bool Op0IsKill, 12442ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson uint64_t Imm1, uint64_t Imm2) { 12452ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned ResultReg = createResultReg(RC); 1246e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 12472ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 12482ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson if (II.getNumDefs() >= 1) 12492ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 12502ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 12512ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 12522ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 12532ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson else { 12542ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 12552ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 12562ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 12572ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 12582ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 12592ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 12602ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson } 12612ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson return ResultReg; 12622ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson} 12632ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 126410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 126510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 1266a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1267a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const ConstantFP *FPImm) { 126810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 1269e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 127010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 12715960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 127284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1273a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1274a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 12755960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 127684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1277a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1278a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 1279e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1280e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12815960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 128210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 128310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 128410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1285d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 1286d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1287a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1288a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill, 1289a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1290d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1291e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1292d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12935960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 129484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1295a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1296a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1297a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 12985960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 129984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1300a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1301a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1302a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1303e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1304e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13055960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1306d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1307d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 13086d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 13096d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 13106d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 13116d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 13126d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 1313e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1314bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 13155960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 131684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg).addImm(Imm); 13175960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 131884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm); 1319e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1320e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13215960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 13226d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 1323b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 13248970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1325d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Andersonunsigned FastISel::FastEmitInst_ii(unsigned MachineInstOpcode, 1326d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson const TargetRegisterClass *RC, 1327d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson uint64_t Imm1, uint64_t Imm2) { 1328d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson unsigned ResultReg = createResultReg(RC); 1329e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1330d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1331d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson if (II.getNumDefs() >= 1) 1332d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1333d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson .addImm(Imm1).addImm(Imm2); 1334d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson else { 1335d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm1).addImm(Imm2); 1336d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1337d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1338d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson } 1339d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson return ResultReg; 1340d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson} 1341d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1342825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 1343a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1344a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint32_t Idx) { 1345536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 13460bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Op0) && 13470bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen "Cannot yet extract from physregs"); 134884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, 134984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman DL, TII.get(TargetOpcode::COPY), ResultReg) 13500bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen .addReg(Op0, getKillRegState(Op0IsKill), Idx); 13518970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 13528970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 135314ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 135414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 135514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 1356a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill) { 1357a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op0, Op0IsKill, 1); 135814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1359f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1360f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 1361f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Emit code to ensure constants are copied into registers when needed. 1362f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Remember the virtual registers that need to be added to the Machine PHI 1363f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// nodes as input. We cannot just directly add them, because expansion 1364f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// might result in multiple MBB's for one BB. As such, the start of the 1365f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// BB might correspond to a different MBB than the end. 1366f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohmanbool FastISel::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) { 1367f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const TerminatorInst *TI = LLVMBB->getTerminator(); 1368f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1369f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled; 1370a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size(); 1371f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1372f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Check successor nodes' PHI nodes that expect a constant to be available 1373f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // from this block. 1374f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 1375f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const BasicBlock *SuccBB = TI->getSuccessor(succ); 1376f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!isa<PHINode>(SuccBB->begin())) continue; 1377a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 1378f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1379f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // If this terminator has multiple identical successors (common for 1380f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // switches), only handle each succ once. 1381f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!SuccsHandled.insert(SuccMBB)) continue; 1382f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1383f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 1384f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1385f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // At this point we know that there is a 1-1 correspondence between LLVM PHI 1386f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // nodes and Machine PHI nodes, but the incoming operands have not been 1387f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // emitted yet. 1388f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (BasicBlock::const_iterator I = SuccBB->begin(); 1389f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1390fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1391f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Ignore dead phi's. 1392f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (PN->use_empty()) continue; 1393f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1394f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Only handle legal types. Two interesting things to note here. First, 1395f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // by bailing out early, we may leave behind some dead instructions, 1396f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its 13977a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // own moves. Second, this check is necessary because FastISel doesn't 139889496d0eb73ab8771b27b3d9c1db6492d8eefc3aDan Gohman // use CreateRegs to create registers, so it always creates 1399f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // exactly one register for each non-void instruction. 1400f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true); 1401f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (VT == MVT::Other || !TLI.isTypeLegal(VT)) { 14022f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier // Handle integer promotions, though, because they're common and easy. 14032f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 1404f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT); 1405f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman else { 1406a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1407f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1408f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1409f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1410f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1411f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1412f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1413fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // Set the DebugLoc for the copy. Prefer the location of the operand 1414fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // if there is one; use the location of the PHI otherwise. 1415fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = PN->getDebugLoc(); 1416fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman if (const Instruction *Inst = dyn_cast<Instruction>(PHIOp)) 1417fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = Inst->getDebugLoc(); 1418fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1419f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman unsigned Reg = getRegForValue(PHIOp); 1420f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (Reg == 0) { 1421a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1422f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1423f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1424a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); 1425fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = DebugLoc(); 1426f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1427f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1428f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1429f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return true; 1430f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman} 1431