FastISel.cpp revision a61b17c18a67f1b3faef2f2108379c4337ce9bb7
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" 43b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/FastISel.h" 44d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 45d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Analysis/Loads.h" 46d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/Analysis.h" 474c3fd9f92f89810d659973d2666ab729758de64aDan Gohman#include "llvm/CodeGen/FunctionLoweringInfo.h" 48b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineInstrBuilder.h" 4933134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/CodeGen/MachineModuleInfo.h" 50b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineRegisterInfo.h" 513574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow#include "llvm/DataLayout.h" 52d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/DebugInfo.h" 53d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Function.h" 54d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/GlobalVariable.h" 55d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Instructions.h" 56d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/IntrinsicInst.h" 57d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Operator.h" 58d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Debug.h" 59d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/ErrorHandling.h" 60b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 61d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson#include "llvm/Target/TargetLibraryInfo.h" 6283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 63bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 64b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 65b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 66aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessIndependent, "Number of insts selected by " 67aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-independent selector"); 68aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessTarget, "Number of insts selected by " 69aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-specific selector"); 70ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad RosierSTATISTIC(NumFastIselDead, "Number of dead insts removed on failure"); 71053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier 7284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// startNewBlock - Set the current block to which generated machine 7384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// instructions will be appended, and clear the local CSE map. 7484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// 7584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::startNewBlock() { 7684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LocalValueMap.clear(); 7784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 7874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = 0; 7984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 8074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Advance the emit start point past any EH_LABEL instructions. 8184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator 8284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman I = FuncInfo.MBB->begin(), E = FuncInfo.MBB->end(); 8384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (I != E && I->getOpcode() == TargetOpcode::EH_LABEL) { 8474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = I; 8584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++I; 8684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 8774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 8874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin} 8974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 9074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasinvoid FastISel::flushLocalValueMap() { 9174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LocalValueMap.clear(); 9274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 9374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin recomputeInsertPt(); 9484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 9584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 96a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanbool FastISel::hasTrivialKill(const Value *V) const { 977f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Don't consider constants or arguments to have trivial kills. 98a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const Instruction *I = dyn_cast<Instruction>(V); 997f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (!I) 1007f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1017f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 1027f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // No-op casts are trivially coalesced by fast-isel. 1037f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (const CastInst *Cast = dyn_cast<CastInst>(I)) 104ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) && 105ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth !hasTrivialKill(Cast->getOperand(0))) 1067f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1077f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 10822b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier // GEPs with all zero indices are trivially coalesced by fast-isel. 10922b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) 11022b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (GEP->hasAllZeroIndices() && !hasTrivialKill(GEP->getOperand(0))) 11122b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier return false; 11222b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier 1137f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Only instructions with a single use in the same basic block are considered 1147f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // to have trivial kills. 1157f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return I->hasOneUse() && 1167f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !(I->getOpcode() == Instruction::BitCast || 1177f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::PtrToInt || 1187f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::IntToPtr) && 11996f1d8ebdd33b3f9bdb3b1163f36072c68599f42Gabor Greif cast<Instruction>(*I->use_begin())->getParent() == I->getParent(); 120a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman} 121a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 12246510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::getRegForValue(const Value *V) { 123e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 1244fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 1254fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 1264fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 127821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 128c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 129c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 130c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 131825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 132821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 13376927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Handle integer promotions, though, because they're common and easy. 13476927d7303046058c627691bd45d6bff608f49f4Eli Friedman if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 13523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 136821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 137821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 138821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 139821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 1404e27027562d6843364e0ab744f97958b6abca08dEric Christopher // Look up the value to see if we already have a register for it. 1414e27027562d6843364e0ab744f97958b6abca08dEric Christopher unsigned Reg = lookUpRegForValue(V); 142c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 143c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 144c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 14597c94b8fc630b55e17a37481910810639e28d086Dan Gohman // In bottom-up mode, just create the virtual register which will be used 14697c94b8fc630b55e17a37481910810639e28d086Dan Gohman // to hold the value. It will be materialized later. 14784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (isa<Instruction>(V) && 14884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman (!isa<AllocaInst>(V) || 14984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(V)))) 15084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return FuncInfo.InitializeRegForValue(V); 15184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 15276ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher SavePoint SaveInsertPt = enterLocalValueArea(); 15384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 15484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Materialize the value in a register. Emit any instructions in the 15584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // local value area. 15684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Reg = materializeRegForValue(V, VT); 15784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 15876ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher leaveLocalValueArea(SaveInsertPt); 15997c94b8fc630b55e17a37481910810639e28d086Dan Gohman 16084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return Reg; 1611fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman} 1621fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 16344a2c3476bd15e03f294bae1b50016851f214f8dEric Christopher/// materializeRegForValue - Helper for getRegForValue. This function is 1641fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// called when the value isn't already available in a register and must 1651fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// be materialized with new instructions. 1661fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohmanunsigned FastISel::materializeRegForValue(const Value *V, MVT VT) { 1671fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman unsigned Reg = 0; 1681fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 16946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 1702ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 1712ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 1720586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 1732ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 174205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 1751e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 1761e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 1771d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 178ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 17946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 180bd1253809bc1b2455793a64d2801db3d6317b08eEli Friedman if (CF->isNullValue()) { 1812790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = TargetMaterializeFloatZero(CF); 1822790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } else { 1832790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman // Try to emit the constant directly. 1842790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 1852790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } 186ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 187ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 1884183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Try to emit the constant by using an integer constant with a cast. 189ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 190e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 191ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 192ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 193ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 19423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 19523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 196c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher APFloat::rmTowardZero, &isExact); 19723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 1983ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin APInt IntVal(IntBitWidth, x); 199ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 200e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 201eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 2022ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 203a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, 204a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntegerReg, /*Kill=*/false); 2052ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 206ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 20746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const Operator *Op = dyn_cast<Operator>(V)) { 20820d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!SelectOperator(Op, Op->getOpcode())) 20920d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!isa<Instruction>(Op) || 21020d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman !TargetSelectInstruction(cast<Instruction>(Op))) 21120d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman return 0; 21237db6cdaea47d0637bdbe624f7b10ff8f82928adDan Gohman Reg = lookUpRegForValue(Op); 213205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 214104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 21584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 21684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.get(TargetOpcode::IMPLICIT_DEF), Reg); 217ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 218bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 219dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 220dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 2216e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 2222ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 223bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2242ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 2252ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 22684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (Reg != 0) { 227dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 22884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = MRI.getVRegDef(Reg); 22984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 230104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 231ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 232ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 23346510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::lookUpRegForValue(const Value *V) { 23459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 23559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 23659fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 2371fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman // def-dominates-use requirement enforced. 238a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 239a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (I != FuncInfo.ValueMap.end()) 2403193a689db3de8640d412ccd9482301647359a4eDan Gohman return I->second; 24176ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher return LocalValueMap[V]; 24259fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 24359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 244cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 245cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 246cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 247cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 248cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 249cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 250482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedmanvoid FastISel::UpdateValueMap(const Value *I, unsigned Reg, unsigned NumRegs) { 25140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 25240b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 253482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman return; 254c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 255bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 256a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned &AssignedReg = FuncInfo.ValueMap[I]; 257c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 25884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Use the new register. 259c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 26036e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 26184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Arrange for uses of AssignedReg to be replaced by uses of Reg. 262482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman for (unsigned i = 0; i < NumRegs; i++) 263482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman FuncInfo.RegFixups[AssignedReg+i] = Reg+i; 26484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 26584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman AssignedReg = Reg; 26640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 267cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 268cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 269a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanstd::pair<unsigned, bool> FastISel::getRegForGEPIndex(const Value *Idx) { 270c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 271c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 272c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 273a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(0, false); 274a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 275a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = hasTrivialKill(Idx); 276c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 277c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 278766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 279e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 280a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman if (IdxVT.bitsLT(PtrVT)) { 281a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, 282a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 283a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 284a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 285a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman else if (IdxVT.bitsGT(PtrVT)) { 286a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, 287a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 288a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 289a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 290a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(IdxN, IdxNIsKill); 291c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 292c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 29384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::recomputeInsertPt() { 29484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (getLastLocalValue()) { 29584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = getLastLocalValue(); 296c6e59b71f50c7c77bc448a936dba8e84d90911e8Dan Gohman FuncInfo.MBB = FuncInfo.InsertPt->getParent(); 29784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 29884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } else 29984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = FuncInfo.MBB->getFirstNonPHI(); 30084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 30184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Now skip past any EH_LABELs, which must remain at the beginning. 30284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (FuncInfo.InsertPt != FuncInfo.MBB->end() && 30384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt->getOpcode() == TargetOpcode::EH_LABEL) 30484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 30584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 30684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 307ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosiervoid FastISel::removeDeadCode(MachineBasicBlock::iterator I, 308ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator E) { 309ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier assert (I && E && std::distance(I, E) > 0 && "Invalid iterator!"); 310ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier while (I != E) { 311ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineInstr *Dead = &*I; 312ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier ++I; 313ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier Dead->eraseFromParent(); 314ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier ++NumFastIselDead; 315ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 316ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 317ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier} 318ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 31976ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric ChristopherFastISel::SavePoint FastISel::enterLocalValueArea() { 32084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt; 32176ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DebugLoc OldDL = DL; 32284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman recomputeInsertPt(); 32376ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DL = DebugLoc(); 32476ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher SavePoint SP = { OldInsertPt, OldDL }; 32576ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher return SP; 32684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 32784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 32876ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christophervoid FastISel::leaveLocalValueArea(SavePoint OldInsertPt) { 32984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.InsertPt != FuncInfo.MBB->begin()) 33084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = llvm::prior(FuncInfo.InsertPt); 33184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 33284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Restore the previous insert position. 33376ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher FuncInfo.InsertPt = OldInsertPt.InsertPt; 33476ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DL = OldInsertPt.DL; 33584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 33684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 337bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 338bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 339bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 34046510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBinaryOp(const User *I, unsigned ISDOpcode) { 341e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 342825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::Other || !VT.isSimple()) 343d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 344d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 345638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 346b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 347b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 348b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 349b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 350638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 351825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 352638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 353825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 3545dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 3555dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 35623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), VT); 357638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 358638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 359638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 360d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 361fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // Check if the first operand is a constant, and handle it as "ri". At -O0, 362fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // we don't have anything that canonicalizes operand order. 363fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(0))) 364fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (isa<Instruction>(I) && cast<Instruction>(I)->isCommutative()) { 365fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner unsigned Op1 = getRegForValue(I->getOperand(1)); 366fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (Op1 == 0) return false; 367fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner 368fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 369d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 370602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op1, 371602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op1IsKill, CI->getZExtValue(), 372602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner VT.getSimpleVT()); 373602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 374d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 375602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 376602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 377602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 378fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner } 379d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 380d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 3813df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 382602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Op0 == 0) // Unhandled operand. Halt "fast" selection and bail. 383a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 384a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 385a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 386a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 387d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 388d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 389602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner uint64_t Imm = CI->getZExtValue(); 390d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 391f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner // Transform "sdiv exact X, 8" -> "sra X, 3". 392f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner if (ISDOpcode == ISD::SDIV && isa<BinaryOperator>(I) && 393f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner cast<BinaryOperator>(I)->isExact() && 394f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner isPowerOf2_64(Imm)) { 395f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner Imm = Log2_64(Imm); 396f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner ISDOpcode = ISD::SRA; 397f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner } 398d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 399544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier // Transform "urem x, pow2" -> "and x, pow2-1". 400544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier if (ISDOpcode == ISD::UREM && isa<BinaryOperator>(I) && 401544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier isPowerOf2_64(Imm)) { 402544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier --Imm; 403544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier ISDOpcode = ISD::AND; 404544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier } 405544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier 406602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op0, 407602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op0IsKill, Imm, VT.getSimpleVT()); 408602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 409d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 410602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 411602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 412602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 413d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 414d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 41510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 41610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 417ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 418a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, Op0, Op0IsKill, CF); 419ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 420ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 4213df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 422ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 423ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 42410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 42510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 4263df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 427d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 428d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 429bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 430bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 431a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 432a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 433ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 4340f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 435a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, 436a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 437a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op1, Op1IsKill); 438bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 439bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 440bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 441bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 442bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 4438014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 4443df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 445bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 446bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 447bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 44846510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectGetElementPtr(const User *I) { 4493df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 45083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 45183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 45283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 45383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 454a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool NIsKill = hasTrivialKill(I->getOperand(0)); 455a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 456478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Keep a running tab of the total offset to coalesce multiple N = N + Offset 457478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // into a single N = N + TotalOffset. 458478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t TotalOffs = 0; 459478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // FIXME: What's a good SWAG number for MaxOffs? 460478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t MaxOffs = 2048; 461db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I->getOperand(0)->getType(); 462825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 46346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman for (GetElementPtrInst::const_op_iterator OI = I->op_begin()+1, 46446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman E = I->op_end(); OI != E; ++OI) { 46546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Idx = *OI; 466db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *StTy = dyn_cast<StructType>(Ty)) { 46783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 46883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 46983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 470478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs += TD.getStructLayout(StTy)->getElementOffset(Field); 471478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 472478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 473478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 474478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 475478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 476478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 477478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 478478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 47983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 48083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 48183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 48283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 48383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 48483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 48546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 486e368b460a206fafa0d31d5d059b1779b94f7df8cDan Gohman if (CI->isZero()) continue; 487478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // N = N + Offset 4886016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier TotalOffs += 489777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 490478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 491478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 492478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 493478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 494478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 495478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 496478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 497478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 498478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier continue; 499478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 500478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 501478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 50283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 50383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 50483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 505a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman NIsKill = true; 506478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 50783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 508bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 50983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 510777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 511a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman std::pair<unsigned, bool> Pair = getRegForGEPIndex(Idx); 512a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IdxN = Pair.first; 513a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = Pair.second; 51483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 51583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 51683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 51783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 51880bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 519a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, IdxNIsKill, ElementSize, VT); 52080bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 52180bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 52280bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 523a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 52480bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 525a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_rr(VT, VT, ISD::ADD, N, NIsKill, IdxN, IdxNIsKill); 52683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 52783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 52883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 52983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 53083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 531478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 532478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 533478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 534478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 535478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 536478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 53783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 53883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 5393df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 54083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 541bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 542bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 54346510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCall(const User *I) { 544a61e73bda5125c28e48b52e573d115370838596bDan Gohman const CallInst *Call = cast<CallInst>(I); 545a61e73bda5125c28e48b52e573d115370838596bDan Gohman 546a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Handle simple inline asms. 5479e15d658c99c3f0717cb83cc2bd2aa29abdbcdbbDan Gohman if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledValue())) { 548a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Don't attempt to handle constraints. 549a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (!IA->getConstraintString().empty()) 550a61e73bda5125c28e48b52e573d115370838596bDan Gohman return false; 551a61e73bda5125c28e48b52e573d115370838596bDan Gohman 552a61e73bda5125c28e48b52e573d115370838596bDan Gohman unsigned ExtraInfo = 0; 553a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->hasSideEffects()) 554a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_HasSideEffects; 555a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->isAlignStack()) 556a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_IsAlignStack; 557a61e73bda5125c28e48b52e573d115370838596bDan Gohman 558a61e73bda5125c28e48b52e573d115370838596bDan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 559a61e73bda5125c28e48b52e573d115370838596bDan Gohman TII.get(TargetOpcode::INLINEASM)) 560a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addExternalSymbol(IA->getAsmString().c_str()) 561a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addImm(ExtraInfo); 562a61e73bda5125c28e48b52e573d115370838596bDan Gohman return true; 563a61e73bda5125c28e48b52e573d115370838596bDan Gohman } 564a61e73bda5125c28e48b52e573d115370838596bDan Gohman 565c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer MachineModuleInfo &MMI = FuncInfo.MF->getMMI(); 566c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer ComputeUsesVAFloatArgument(*Call, &MMI); 567c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer 568a61e73bda5125c28e48b52e573d115370838596bDan Gohman const Function *F = Call->getCalledFunction(); 56933134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 57033134c4a75558288d663267c8991f6bd37a530afDan Gohman 5714183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Handle selected intrinsic function calls. 572832e4943598d821687cec79f512803c1ca03cff7Chris Lattner switch (F->getIntrinsicID()) { 57333134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 574aefd36bdda0dac496b8acabb25f0de29b370ebcaChad Rosier // At -O0 we don't care about the lifetime intrinsics. 5759b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_start: 5769b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_end: 577fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier // The donothing intrinsic does, well, nothing. 578fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier case Intrinsic::donothing: 5799b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher return true; 580fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier 58192c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 582a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgDeclareInst *DI = cast<DbgDeclareInst>(Call); 58302f0dbd97a9bc01528aa12c2f260d928683ab411Devang Patel if (!DIVariable(DI->getVariable()).Verify() || 584bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher !FuncInfo.MF->getMMI().hasDebugInfo()) { 585bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 5867e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 587bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 58892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 58946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Address = DI->getAddress(); 590ccaea7dc0bbc75e5d4ee92fb8cc6af0f928d056fEric Christopher if (!Address || isa<UndefValue>(Address)) { 591bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 592dc9185657593b5c1db86cb95a04a68fc09194993Dale Johannesen return true; 593bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 5946fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel 5956fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Reg = 0; 5966fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Offset = 0; 5976fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (const Argument *Arg = dyn_cast<Argument>(Address)) { 5989aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel // Some arguments' frame index is recorded during argument lowering. 5999aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel Offset = FuncInfo.getArgumentFrameIndex(Arg); 6009aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel if (Offset) 601c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher Reg = TRI.getFrameRegister(*FuncInfo.MF); 6024bafda9618f9dfa9edc8da08bb3001ef2d1a9b68Devang Patel } 6036fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (!Reg) 6048c5293c9556317143505c085cf428e11962e1273Eric Christopher Reg = lookUpRegForValue(Address); 6058c5293c9556317143505c085cf428e11962e1273Eric Christopher 60684364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we have a VLA that has a "use" in a metadata node that's then used 60784364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // here but it has no other uses, then we have a problem. E.g., 60884364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 60984364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // int foo (const int *x) { 61084364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // char a[*x]; 61184364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // return 0; 61284364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // } 61384364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 61484364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we assign 'a' a vreg and fast isel later on has to use the selection 61584364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // DAG isel, it will want to copy the value to the vreg. However, there are 61684364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // no uses, which goes counter to what selection DAG isel expects. 61784364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling if (!Reg && !Address->use_empty() && isa<Instruction>(Address) && 6188c5293c9556317143505c085cf428e11962e1273Eric Christopher (!isa<AllocaInst>(Address) || 6198c5293c9556317143505c085cf428e11962e1273Eric Christopher !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(Address)))) 6208c5293c9556317143505c085cf428e11962e1273Eric Christopher Reg = FuncInfo.InitializeRegForValue(Address); 621bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 6226fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (Reg) 623bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 6246fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel TII.get(TargetOpcode::DBG_VALUE)) 6256fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addReg(Reg, RegState::Debug).addImm(Offset) 6266fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addMetadata(DI->getVariable()); 6274476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher else 6284476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // We can't yet handle anything else here because it would require 6294476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // generating code, thus altering codegen because of debug info. 6304476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher DEBUG(dbgs() << "Dropping debug info for " << DI); 63133134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 63292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 63345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen case Intrinsic::dbg_value: { 634343b42e428079363ab09828734b2debfd7dbdc9eDale Johannesen // This form of DBG_VALUE is target-independent. 635a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgValueInst *DI = cast<DbgValueInst>(Call); 636e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE); 63746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *V = DI->getValue(); 63845df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen if (!V) { 63945df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // Currently the optimizer can produce this; insert an undef to 64045df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // help debugging. Probably the optimizer should not do this. 64184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 64284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(0U).addImm(DI->getOffset()) 64384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 64446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 6458594d429e02c688d428036f8563f09572da3fbffDevang Patel if (CI->getBitWidth() > 64) 6468594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6478594d429e02c688d428036f8563f09572da3fbffDevang Patel .addCImm(CI).addImm(DI->getOffset()) 6488594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 6496016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier else 6508594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6518594d429e02c688d428036f8563f09572da3fbffDevang Patel .addImm(CI->getZExtValue()).addImm(DI->getOffset()) 6528594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 65346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 65484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 65584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addFPImm(CF).addImm(DI->getOffset()) 65684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 65745df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else if (unsigned Reg = lookUpRegForValue(V)) { 65884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 65984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Reg, RegState::Debug).addImm(DI->getOffset()) 66084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 66145df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else { 66245df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // We can't yet handle anything else here because it would require 66345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // generating code, thus altering codegen because of debug info. 664afeaae7a940ce16e7874af31f3e5e91d8ca89e19Devang Patel DEBUG(dbgs() << "Dropping debug info for " << DI); 665bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 66645df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen return true; 66745df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } 668d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman case Intrinsic::objectsize: { 669d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman ConstantInt *CI = cast<ConstantInt>(Call->getArgOperand(1)); 670d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned long long Res = CI->isZero() ? -1ULL : 0; 671d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman Constant *ResCI = ConstantInt::get(Call->getType(), Res); 672d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned ResultReg = getRegForValue(ResCI); 673d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman if (ResultReg == 0) 674d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return false; 675d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman UpdateValueMap(Call, ResultReg); 676d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return true; 677d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman } 67833134c4a75558288d663267c8991f6bd37a530afDan Gohman } 6794183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman 68074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Usually, it does not make sense to initialize a value, 68174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // make an unrelated function call and use the value, because 68274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // it tends to be spilled on the stack. So, we move the pointer 68374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // to the last local value to the beginning of the block, so that 68474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // all the values which have already been materialized, 68574af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // appear after the call. It also makes sense to skip intrinsics 68674af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // since they tend to be inlined. 68774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin if (!isa<IntrinsicInst>(F)) 68874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin flushLocalValueMap(); 68974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 6904183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // An arbitrary call. Bail. 69133134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 69233134c4a75558288d663267c8991f6bd37a530afDan Gohman} 69333134c4a75558288d663267c8991f6bd37a530afDan Gohman 69446510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCast(const User *I, unsigned Opcode) { 695e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 696e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 697bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 698825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 699825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 700d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 701d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 702bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 70376927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the destination type is legal. 704474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 70576927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 706474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 70776927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the source operand is legal. 708474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 70976927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 710474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 7113df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 712d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 713d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 714d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 71514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 716a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool InputRegIsKill = hasTrivialKill(I->getOperand(0)); 717a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 718d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 719d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 720d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 721a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputReg, InputRegIsKill); 722d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 723d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 724bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7253df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 726d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 727d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 728d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 72946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBitCast(const User *I) { 730ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 731ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 7323df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 733a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 734a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 7353df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 736ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 737ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 738ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 739bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Bitcasts of other values become reg-reg copies or BITCAST operators. 740a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund MVT SrcVT = TLI.getSimpleValueType(I->getOperand(0)->getType()); 741a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund MVT DstVT = TLI.getSimpleValueType(I->getType()); 742bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 743a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund if (SrcVT == MVT::Other || DstVT == MVT::Other || 744d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 745d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 746d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 747bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7483df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 749ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 750ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 751d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 752a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 753a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 754bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 755ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 756ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 757a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund if (SrcVT == DstVT) { 75844d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 75944d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 760e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen // Don't attempt a cross-class copy. It will likely fail. 761e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen if (SrcClass == DstClass) { 762e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg = createResultReg(DstClass); 763e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 764e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg).addReg(Op0); 765e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen } 766ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 767bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 768bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If the reg-reg copy failed, select a BITCAST opcode. 769ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 770a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund ResultReg = FastEmit_r(SrcVT, DstVT, ISD::BITCAST, Op0, Op0IsKill); 771bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 772ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 773d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 774bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7753df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 776d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 777d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 778d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 7793df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 78046510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectInstruction(const Instruction *I) { 781e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // Just before the terminator instruction, insert instructions to 782e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // feed PHI nodes in successor blocks. 783e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (isa<TerminatorInst>(I)) 784e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (!HandlePHINodesInSuccessorBlocks(I->getParent())) 785e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman return false; 786e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman 7878ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = I->getDebugLoc(); 7888ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman 789ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator SavedInsertPt = FuncInfo.InsertPt; 790ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 791982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson // As a special case, don't handle calls to builtin library functions that 792982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson // may be translated directly to target instructions. 793d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson if (const CallInst *Call = dyn_cast<CallInst>(I)) { 794d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson const Function *F = Call->getCalledFunction(); 795d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibFunc::Func Func; 796d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson if (F && !F->hasLocalLinkage() && F->hasName() && 797d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibInfo->getLibFunc(F->getName(), Func) && 798982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson LibInfo->hasOptimizedCodeGen(Func)) 799d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson return false; 800d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson } 801d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson 8026e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // First, try doing target-independent selection. 8038ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (SelectOperator(I, I->getOpcode())) { 804053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier ++NumFastIselSuccessIndependent; 8058ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8066e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8078ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 8086016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier // Remove dead code. However, ignore call instructions since we've flushed 809ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // the local value map and recomputed the insert point. 810ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (!isa<CallInst>(I)) { 811ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 812ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 813ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 814ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 8156e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8166e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // Next, try calling the target to attempt to handle the instruction. 817ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier SavedInsertPt = FuncInfo.InsertPt; 8188ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (TargetSelectInstruction(I)) { 819053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier ++NumFastIselSuccessTarget; 8208ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8216e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8228ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 823ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // Check for dead code and remove as necessary. 824ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 825ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 826ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 8276e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8288ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8296e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return false; 83040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 83140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 832d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 833d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 834d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 835d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 8363bf912593301152b65accb9d9c37a95172f1df5aStuart HastingsFastISel::FastEmitBranch(MachineBasicBlock *MSucc, DebugLoc DL) { 83718112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher 83818112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher if (FuncInfo.MBB->getBasicBlock()->size() > 1 && FuncInfo.MBB->isLayoutSuccessor(MSucc)) { 83918112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // For more accurate line information if this is the only instruction 84018112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // in the block then emit it, otherwise we have the unconditional 84118112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // fall-through case, which needs no instructions. 842d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 843d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 84484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.InsertBranch(*FuncInfo.MBB, MSucc, NULL, 84584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVector<MachineOperand, 0>(), DL); 846d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 84784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.MBB->addSuccessor(MSucc); 848d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 849d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 8503d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// SelectFNeg - Emit an FNeg operation. 8513d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// 8523d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohmanbool 85346510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectFNeg(const User *I) { 8543d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 8553d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (OpReg == 0) return false; 8563d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 857a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool OpRegIsKill = hasTrivialKill(I); 858a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 8594a215a13c3035a8818254b61267be77def4a2a37Dan Gohman // If the target has ISD::FNEG, use it. 8604a215a13c3035a8818254b61267be77def4a2a37Dan Gohman EVT VT = TLI.getValueType(I->getType()); 8614a215a13c3035a8818254b61267be77def4a2a37Dan Gohman unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 862a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::FNEG, OpReg, OpRegIsKill); 8634a215a13c3035a8818254b61267be77def4a2a37Dan Gohman if (ResultReg != 0) { 8644a215a13c3035a8818254b61267be77def4a2a37Dan Gohman UpdateValueMap(I, ResultReg); 8654a215a13c3035a8818254b61267be77def4a2a37Dan Gohman return true; 8664a215a13c3035a8818254b61267be77def4a2a37Dan Gohman } 8674a215a13c3035a8818254b61267be77def4a2a37Dan Gohman 8685e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // Bitcast the value to integer, twiddle the sign bit with xor, 8695e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // and then bitcast it back to floating-point. 8703d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (VT.getSizeInBits() > 64) return false; 8715e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 8725e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (!TLI.isTypeLegal(IntVT)) 8735e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 8745e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 8755e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 876bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, OpReg, OpRegIsKill); 8775e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntReg == 0) 8785e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 8795e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 880a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, 881a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntReg, /*Kill=*/true, 8825e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman UINT64_C(1) << (VT.getSizeInBits()-1), 8835e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman IntVT.getSimpleVT()); 8845e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntResultReg == 0) 8855e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 8865e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 8875e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 888bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, IntResultReg, /*Kill=*/true); 8893d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (ResultReg == 0) 8903d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return false; 8913d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 8923d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman UpdateValueMap(I, ResultReg); 8933d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return true; 8943d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman} 8953d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 89640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 8972586b8f9366aed5a1efa44d3f18d095511601642Eli FriedmanFastISel::SelectExtractValue(const User *U) { 8982586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U); 899a4c920db7a3620f365144eac9aaad7ca23062caaEli Friedman if (!EVI) 9002586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9012586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 902482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // Make sure we only try to handle extracts with a legal result. But also 903482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // allow i1 because it's easy. 9042586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman EVT RealVT = TLI.getValueType(EVI->getType(), /*AllowUnknown=*/true); 9052586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (!RealVT.isSimple()) 9062586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9072586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman MVT VT = RealVT.getSimpleVT(); 908482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman if (!TLI.isTypeLegal(VT) && VT != MVT::i1) 9092586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9102586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9112586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const Value *Op0 = EVI->getOperand(0); 912db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AggTy = Op0->getType(); 9132586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9142586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the base result register. 9152586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman unsigned ResultReg; 9162586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0); 9172586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (I != FuncInfo.ValueMap.end()) 9182586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = I->second; 9190b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else if (isa<Instruction>(Op0)) 9202586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = FuncInfo.InitializeRegForValue(Op0); 9210b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else 9220b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman return false; // fast-isel can't handle aggregate constants at the moment 9232586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9242586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the actual result register, which is an offset from the base register. 925fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad unsigned VTIndex = ComputeLinearIndex(AggTy, EVI->getIndices()); 9262586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9272586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman SmallVector<EVT, 4> AggValueVTs; 9282586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ComputeValueVTs(TLI, AggTy, AggValueVTs); 9292586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9302586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman for (unsigned i = 0; i < VTIndex; i++) 9312586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg += TLI.getNumRegisters(FuncInfo.Fn->getContext(), AggValueVTs[i]); 9322586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9332586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman UpdateValueMap(EVI, ResultReg); 9342586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return true; 9352586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman} 9362586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9372586b8f9366aed5a1efa44d3f18d095511601642Eli Friedmanbool 93846510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectOperator(const User *I, unsigned Opcode) { 93940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 940ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 941ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 942ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 943ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 944ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 945ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 946ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 9473d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman // FNeg is currently represented in LLVM IR as a special case of FSub. 9483d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (BinaryOperator::isFNeg(I)) 9493d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return SelectFNeg(I); 950ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 951ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 952ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 953ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 954ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 9553df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 9563df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 9573df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 9583df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 9593df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 9603df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 9613df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 9623df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 9633df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 9643df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 9653df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 9663df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 9673df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 9683df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 9693df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 9703df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 9713df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 9723df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 9733df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 9743df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 9753df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 9763df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 9773df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 9783df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 9793df24e667f04a7003342b534310919abc9c87418Dan Gohman 9803df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 9813df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 9823df24e667f04a7003342b534310919abc9c87418Dan Gohman 9833df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 98446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BranchInst *BI = cast<BranchInst>(I); 9853df24e667f04a7003342b534310919abc9c87418Dan Gohman 9863df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 98746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BasicBlock *LLVMSucc = BI->getSuccessor(0); 988a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc]; 9893bf912593301152b65accb9d9c37a95172f1df5aStuart Hastings FastEmitBranch(MSucc, BI->getDebugLoc()); 9903df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 9919d5b41624003daf259b33fc953aa471049700353Owen Anderson } 9923df24e667f04a7003342b534310919abc9c87418Dan Gohman 9933df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 9943df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 9953df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 996b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 997b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 998087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 999087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 1000087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 1001087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 10020586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 10030586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 1004a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I))) 10050586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 10060586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 10070586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 10080586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 1009bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 101033134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 101133134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 1012bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 10133df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 10143df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 10153df24e667f04a7003342b534310919abc9c87418Dan Gohman 10163df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 10173df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 10183df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 10193df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10203df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 10213df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 10223df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 10233df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10243df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 10253df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 10263df24e667f04a7003342b534310919abc9c87418Dan Gohman 10273df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 10283df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 1029e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 1030e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 10313df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 10323df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10333df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 10343df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10353df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 10363df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 10373df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 10383df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 10393df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1040d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 10412586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman case Instruction::ExtractValue: 10422586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return SelectExtractValue(I); 10432586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 1044ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman case Instruction::PHI: 1045ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman llvm_unreachable("FastISel shouldn't visit PHI nodes!"); 1046ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman 10473df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 10483df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 10493df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 10503df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1051b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1052b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1053d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob WilsonFastISel::FastISel(FunctionLoweringInfo &funcInfo, 1054d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson const TargetLibraryInfo *libInfo) 105584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman : FuncInfo(funcInfo), 1056a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MRI(FuncInfo.MF->getRegInfo()), 1057a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MFI(*FuncInfo.MF->getFrameInfo()), 1058a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MCP(*FuncInfo.MF->getConstantPool()), 1059a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman TM(FuncInfo.MF->getTarget()), 10603574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow TD(*TM.getDataLayout()), 106122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 1062a7a0ed79012ea36f838239cf1d04959711aec2a9Dan Gohman TLI(*TM.getTargetLowering()), 1063d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson TRI(*TM.getRegisterInfo()), 1064d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibInfo(libInfo) { 1065bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 1066bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 1067e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 1068e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 1069825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 10707c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned) { 1071b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1072b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1073b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1074825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 1075a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1076a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/) { 1077b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1078b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1079b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1080bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckunsigned FastISel::FastEmit_rr(MVT, MVT, 1081a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1082a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1083a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/) { 1084b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1085b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1086b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 10877c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 108883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 108983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 109083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1091825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 109246510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned, const ConstantFP * /*FPImm*/) { 109310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 109410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 109510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1096825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 1097a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1098a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 10990f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 1100d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 1101d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1102d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1103825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 1104a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1105a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 110646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const ConstantFP * /*FPImm*/) { 110710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 110810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 110910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1110825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 11117c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, 1112a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1113a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/, 1114d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 111583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 111683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 111783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 111883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 111983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 112083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 112183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 11227c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 1123a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1124a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm, MVT ImmType) { 1125602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // If this is a multiply by a power of two, emit this as a shift left. 1126602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Opcode == ISD::MUL && isPowerOf2_64(Imm)) { 1127602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Opcode = ISD::SHL; 1128602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm = Log2_64(Imm); 1129090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner } else if (Opcode == ISD::UDIV && isPowerOf2_64(Imm)) { 1130090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner // div x, 8 -> srl x, 3 1131090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Opcode = ISD::SRL; 1132090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Imm = Log2_64(Imm); 1133602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner } 1134d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1135602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // Horrible hack (to be removed), check to make sure shift amounts are 1136602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // in-range. 1137602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if ((Opcode == ISD::SHL || Opcode == ISD::SRA || Opcode == ISD::SRL) && 1138602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm >= VT.getSizeInBits()) 1139602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return 0; 1140d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 114183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 1142a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Op0IsKill, Imm); 114383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 114483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 11450f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 1146b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman if (MaterialReg == 0) { 1147b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // This is a bit ugly/slow, but failing here means falling out of 1148b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // fast-isel, which would be very slow. 1149db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *ITy = IntegerType::get(FuncInfo.Fn->getContext(), 1150b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman VT.getSizeInBits()); 1151b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman MaterialReg = getRegForValue(ConstantInt::get(ITy, Imm)); 1152b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman } 1153a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_rr(VT, VT, Opcode, 1154a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 1155a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman MaterialReg, /*Kill=*/true); 1156d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1157d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1158d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 1159d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 116083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 116183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1162b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 116377ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 1164d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1165e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1166b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 116784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg); 1168b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1169b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1170b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1171b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 1172b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1173a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill) { 1174d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1175e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1176b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 11775960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 117884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 117984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 11805960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 118184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 118284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 1183e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1184e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 11855960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 11865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 1187b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1188b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1189b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1190b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 1191b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1192a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1193a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill) { 1194d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1195e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1196b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 11975960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 119884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1199a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1200a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 12015960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 120284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1203a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1204a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 1205e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1206e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12075960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1208b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1209b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1210d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1211d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Andersonunsigned FastISel::FastEmitInst_rrr(unsigned MachineInstOpcode, 1212d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson const TargetRegisterClass *RC, 1213d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op0, bool Op0IsKill, 1214d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op1, bool Op1IsKill, 1215d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op2, bool Op2IsKill) { 1216d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned ResultReg = createResultReg(RC); 1217e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1218d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1219d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson if (II.getNumDefs() >= 1) 1220d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1221d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1222d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1223d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1224d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson else { 1225d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1226d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1227d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1228d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1229d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1230d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1231d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson } 1232d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson return ResultReg; 1233d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson} 1234d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1235d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 1236d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1237a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1238a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1239d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1240e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1241d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12425960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 124384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1244a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1245a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 12465960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 124784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1248a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1249a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1250e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1251e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12525960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1253d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1254d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1255d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12562ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Andersonunsigned FastISel::FastEmitInst_rii(unsigned MachineInstOpcode, 12572ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson const TargetRegisterClass *RC, 12582ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned Op0, bool Op0IsKill, 12592ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson uint64_t Imm1, uint64_t Imm2) { 12602ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned ResultReg = createResultReg(RC); 1261e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 12622ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 12632ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson if (II.getNumDefs() >= 1) 12642ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 12652ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 12662ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 12672ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 12682ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson else { 12692ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 12702ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 12712ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 12722ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 12732ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 12742ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 12752ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson } 12762ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson return ResultReg; 12772ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson} 12782ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 127910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 128010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 1281a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1282a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const ConstantFP *FPImm) { 128310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 1284e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 128510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 12865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 128784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1288a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1289a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 12905960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 129184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1292a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1293a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 1294e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1295e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12965960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 129710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 129810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 129910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1300d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 1301d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1302a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1303a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill, 1304a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1305d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1306e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1307d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 13085960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 130984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1310a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1311a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1312a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 13135960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 131484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1315a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1316a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1317a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1318e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1319e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13205960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1321d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1322d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 13236d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 132468f25571e759c1fcf2da206109647259f49f7416Manman Renunsigned FastISel::FastEmitInst_rrii(unsigned MachineInstOpcode, 132568f25571e759c1fcf2da206109647259f49f7416Manman Ren const TargetRegisterClass *RC, 132668f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned Op0, bool Op0IsKill, 132768f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned Op1, bool Op1IsKill, 132868f25571e759c1fcf2da206109647259f49f7416Manman Ren uint64_t Imm1, uint64_t Imm2) { 132968f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned ResultReg = createResultReg(RC); 133068f25571e759c1fcf2da206109647259f49f7416Manman Ren const MCInstrDesc &II = TII.get(MachineInstOpcode); 133168f25571e759c1fcf2da206109647259f49f7416Manman Ren 133268f25571e759c1fcf2da206109647259f49f7416Manman Ren if (II.getNumDefs() >= 1) 133368f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 133468f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op0, Op0IsKill * RegState::Kill) 133568f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op1, Op1IsKill * RegState::Kill) 133668f25571e759c1fcf2da206109647259f49f7416Manman Ren .addImm(Imm1).addImm(Imm2); 133768f25571e759c1fcf2da206109647259f49f7416Manman Ren else { 133868f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 133968f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op0, Op0IsKill * RegState::Kill) 134068f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op1, Op1IsKill * RegState::Kill) 134168f25571e759c1fcf2da206109647259f49f7416Manman Ren .addImm(Imm1).addImm(Imm2); 134268f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 134368f25571e759c1fcf2da206109647259f49f7416Manman Ren ResultReg).addReg(II.ImplicitDefs[0]); 134468f25571e759c1fcf2da206109647259f49f7416Manman Ren } 134568f25571e759c1fcf2da206109647259f49f7416Manman Ren return ResultReg; 134668f25571e759c1fcf2da206109647259f49f7416Manman Ren} 134768f25571e759c1fcf2da206109647259f49f7416Manman Ren 13486d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 13496d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 13506d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 13516d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 1352e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1353bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 13545960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 135584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg).addImm(Imm); 13565960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 135784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm); 1358e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1359e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13605960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 13616d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 1362b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 13638970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1364d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Andersonunsigned FastISel::FastEmitInst_ii(unsigned MachineInstOpcode, 1365d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson const TargetRegisterClass *RC, 1366d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson uint64_t Imm1, uint64_t Imm2) { 1367d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson unsigned ResultReg = createResultReg(RC); 1368e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1369d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1370d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson if (II.getNumDefs() >= 1) 1371d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1372d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson .addImm(Imm1).addImm(Imm2); 1373d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson else { 1374d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm1).addImm(Imm2); 1375d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1376d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1377d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson } 1378d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson return ResultReg; 1379d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson} 1380d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1381825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 1382a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1383a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint32_t Idx) { 1384536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 13850bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Op0) && 13860bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen "Cannot yet extract from physregs"); 1387ee0d5d4398fb855c6674da94d902ef45e944f375Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI.getRegClass(Op0); 1388ee0d5d4398fb855c6674da94d902ef45e944f375Jakob Stoklund Olesen MRI.constrainRegClass(Op0, TRI.getSubClassWithSubReg(RC, Idx)); 138984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, 139084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman DL, TII.get(TargetOpcode::COPY), ResultReg) 13910bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen .addReg(Op0, getKillRegState(Op0IsKill), Idx); 13928970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 13938970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 139414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 139514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 139614ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 1397a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill) { 1398a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op0, Op0IsKill, 1); 139914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1400f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1401f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 1402f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Emit code to ensure constants are copied into registers when needed. 1403f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Remember the virtual registers that need to be added to the Machine PHI 1404f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// nodes as input. We cannot just directly add them, because expansion 1405f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// might result in multiple MBB's for one BB. As such, the start of the 1406f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// BB might correspond to a different MBB than the end. 1407f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohmanbool FastISel::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) { 1408f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const TerminatorInst *TI = LLVMBB->getTerminator(); 1409f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1410f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled; 1411a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size(); 1412f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1413f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Check successor nodes' PHI nodes that expect a constant to be available 1414f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // from this block. 1415f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 1416f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const BasicBlock *SuccBB = TI->getSuccessor(succ); 1417f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!isa<PHINode>(SuccBB->begin())) continue; 1418a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 1419f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1420f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // If this terminator has multiple identical successors (common for 1421f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // switches), only handle each succ once. 1422f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!SuccsHandled.insert(SuccMBB)) continue; 1423f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1424f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 1425f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1426f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // At this point we know that there is a 1-1 correspondence between LLVM PHI 1427f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // nodes and Machine PHI nodes, but the incoming operands have not been 1428f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // emitted yet. 1429f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (BasicBlock::const_iterator I = SuccBB->begin(); 1430f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1431fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1432f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Ignore dead phi's. 1433f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (PN->use_empty()) continue; 1434f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1435f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Only handle legal types. Two interesting things to note here. First, 1436f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // by bailing out early, we may leave behind some dead instructions, 1437f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its 14387a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // own moves. Second, this check is necessary because FastISel doesn't 143989496d0eb73ab8771b27b3d9c1db6492d8eefc3aDan Gohman // use CreateRegs to create registers, so it always creates 1440f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // exactly one register for each non-void instruction. 1441f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true); 1442f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (VT == MVT::Other || !TLI.isTypeLegal(VT)) { 14432f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier // Handle integer promotions, though, because they're common and easy. 14442f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 1445f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT); 1446f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman else { 1447a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1448f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1449f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1450f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1451f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1452f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1453f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1454fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // Set the DebugLoc for the copy. Prefer the location of the operand 1455fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // if there is one; use the location of the PHI otherwise. 1456fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = PN->getDebugLoc(); 1457fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman if (const Instruction *Inst = dyn_cast<Instruction>(PHIOp)) 1458fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = Inst->getDebugLoc(); 1459fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1460f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman unsigned Reg = getRegForValue(PHIOp); 1461f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (Reg == 0) { 1462a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1463f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1464f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1465a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); 1466fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = DebugLoc(); 1467f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1468f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1469f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1470f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return true; 1471f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman} 1472