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" 446d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie#include "llvm/ADT/Optional.h" 45d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 46d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Analysis/Loads.h" 47d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/Analysis.h" 484c3fd9f92f89810d659973d2666ab729758de64aDan Gohman#include "llvm/CodeGen/FunctionLoweringInfo.h" 49b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineInstrBuilder.h" 5033134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/CodeGen/MachineModuleInfo.h" 51b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineRegisterInfo.h" 52d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/DebugInfo.h" 530b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 540b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 550b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalVariable.h" 560b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 570b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/IntrinsicInst.h" 580b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 59d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Debug.h" 60d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/ErrorHandling.h" 61b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 62d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson#include "llvm/Target/TargetLibraryInfo.h" 6383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 64bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 65b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 66b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 67aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessIndependent, "Number of insts selected by " 68aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-independent selector"); 69aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessTarget, "Number of insts selected by " 70aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-specific selector"); 71ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad RosierSTATISTIC(NumFastIselDead, "Number of dead insts removed on failure"); 72053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier 7384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// startNewBlock - Set the current block to which generated machine 7484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// instructions will be appended, and clear the local CSE map. 7584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// 7684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::startNewBlock() { 7784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LocalValueMap.clear(); 7884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 791ab111ed01457887a8dece6fb36336aff41cc703Jakob Stoklund Olesen // Instructions are appended to FuncInfo.MBB. If the basic block already 80ef22e0e0b583e727f01ae70d51a143172eb31814Jakob Stoklund Olesen // contains labels or copies, use the last instruction as the last local 81ef22e0e0b583e727f01ae70d51a143172eb31814Jakob Stoklund Olesen // value. 8274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = 0; 83ef22e0e0b583e727f01ae70d51a143172eb31814Jakob Stoklund Olesen if (!FuncInfo.MBB->empty()) 84ef22e0e0b583e727f01ae70d51a143172eb31814Jakob Stoklund Olesen EmitStartPt = &FuncInfo.MBB->back(); 8574af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 8674af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin} 8774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 88092e5e75661fdd5d54a748fb00fab59d21031268Evan Chengbool FastISel::LowerArguments() { 89092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (!FuncInfo.CanLowerReturn) 90092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng // Fallback to SDISel argument lowering code to deal with sret pointer 91092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng // parameter. 92092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return false; 93155615d7dc4e4fbfd3b7273720a76356468edf46Stephen Lin 94092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (!FastLowerArguments()) 95092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return false; 96092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 971948910e3186d31bc0d213ecd0d7e87bb2c2760dDavid Blaikie // Enter arguments into ValueMap for uses in non-entry BBs. 98092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng for (Function::const_arg_iterator I = FuncInfo.Fn->arg_begin(), 99092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng E = FuncInfo.Fn->arg_end(); I != E; ++I) { 1001948910e3186d31bc0d213ecd0d7e87bb2c2760dDavid Blaikie DenseMap<const Value *, unsigned>::iterator VI = LocalValueMap.find(I); 1011948910e3186d31bc0d213ecd0d7e87bb2c2760dDavid Blaikie assert(VI != LocalValueMap.end() && "Missed an argument?"); 1021948910e3186d31bc0d213ecd0d7e87bb2c2760dDavid Blaikie FuncInfo.ValueMap[I] = VI->second; 103092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng } 104092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return true; 105092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng} 106092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 10774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasinvoid FastISel::flushLocalValueMap() { 10874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LocalValueMap.clear(); 10974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 11074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin recomputeInsertPt(); 11184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 11284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 113a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanbool FastISel::hasTrivialKill(const Value *V) const { 1147f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Don't consider constants or arguments to have trivial kills. 115a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const Instruction *I = dyn_cast<Instruction>(V); 1167f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (!I) 1177f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1187f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 1197f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // No-op casts are trivially coalesced by fast-isel. 1207f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (const CastInst *Cast = dyn_cast<CastInst>(I)) 121ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) && 122ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth !hasTrivialKill(Cast->getOperand(0))) 1237f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1247f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 12522b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier // GEPs with all zero indices are trivially coalesced by fast-isel. 12622b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) 12722b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (GEP->hasAllZeroIndices() && !hasTrivialKill(GEP->getOperand(0))) 12822b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier return false; 12922b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier 1307f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Only instructions with a single use in the same basic block are considered 1317f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // to have trivial kills. 1327f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return I->hasOneUse() && 1337f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !(I->getOpcode() == Instruction::BitCast || 1347f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::PtrToInt || 1357f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::IntToPtr) && 13696f1d8ebdd33b3f9bdb3b1163f36072c68599f42Gabor Greif cast<Instruction>(*I->use_begin())->getParent() == I->getParent(); 137a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman} 138a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 13946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::getRegForValue(const Value *V) { 140e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 1414fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 1424fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 1434fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 144821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 145c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 146c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 147c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 148825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 149821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 15076927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Handle integer promotions, though, because they're common and easy. 15176927d7303046058c627691bd45d6bff608f49f4Eli Friedman if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 15223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 153821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 154821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 155821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 156821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 1574e27027562d6843364e0ab744f97958b6abca08dEric Christopher // Look up the value to see if we already have a register for it. 1584e27027562d6843364e0ab744f97958b6abca08dEric Christopher unsigned Reg = lookUpRegForValue(V); 159c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 160c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 161c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 16297c94b8fc630b55e17a37481910810639e28d086Dan Gohman // In bottom-up mode, just create the virtual register which will be used 16397c94b8fc630b55e17a37481910810639e28d086Dan Gohman // to hold the value. It will be materialized later. 16484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (isa<Instruction>(V) && 16584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman (!isa<AllocaInst>(V) || 16684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(V)))) 16784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return FuncInfo.InitializeRegForValue(V); 16884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 16976ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher SavePoint SaveInsertPt = enterLocalValueArea(); 17084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 17184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Materialize the value in a register. Emit any instructions in the 17284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // local value area. 17384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Reg = materializeRegForValue(V, VT); 17484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 17576ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher leaveLocalValueArea(SaveInsertPt); 17697c94b8fc630b55e17a37481910810639e28d086Dan Gohman 17784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return Reg; 1781fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman} 1791fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 18044a2c3476bd15e03f294bae1b50016851f214f8dEric Christopher/// materializeRegForValue - Helper for getRegForValue. This function is 1811fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// called when the value isn't already available in a register and must 1821fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// be materialized with new instructions. 1831fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohmanunsigned FastISel::materializeRegForValue(const Value *V, MVT VT) { 1841fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman unsigned Reg = 0; 1851fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 18646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 1872ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 1882ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 1890586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 1902ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 191205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 1921e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 1931e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 1941d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 195ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 19646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 197bd1253809bc1b2455793a64d2801db3d6317b08eEli Friedman if (CF->isNullValue()) { 1982790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = TargetMaterializeFloatZero(CF); 1992790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } else { 2002790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman // Try to emit the constant directly. 2012790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 2022790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } 203ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 204ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 2054183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Try to emit the constant by using an integer constant with a cast. 206ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 207e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 208ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 209ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 210ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 21123a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 21223a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 213c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher APFloat::rmTowardZero, &isExact); 21423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 2153ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin APInt IntVal(IntBitWidth, x); 216ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 217e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 218eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 2192ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 220a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, 221a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntegerReg, /*Kill=*/false); 2222ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 223ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 22446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const Operator *Op = dyn_cast<Operator>(V)) { 22520d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!SelectOperator(Op, Op->getOpcode())) 22620d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!isa<Instruction>(Op) || 22720d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman !TargetSelectInstruction(cast<Instruction>(Op))) 22820d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman return 0; 22937db6cdaea47d0637bdbe624f7b10ff8f82928adDan Gohman Reg = lookUpRegForValue(Op); 230205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 231104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 23284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 23384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.get(TargetOpcode::IMPLICIT_DEF), Reg); 234ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 235bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 236dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 237dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 2386e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 2392ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 240bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2412ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 2422ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 24384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (Reg != 0) { 244dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 24584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = MRI.getVRegDef(Reg); 24684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 247104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 248ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 249ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 25046510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::lookUpRegForValue(const Value *V) { 25159fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 25259fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 25359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 2541fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman // def-dominates-use requirement enforced. 255a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 256a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (I != FuncInfo.ValueMap.end()) 2573193a689db3de8640d412ccd9482301647359a4eDan Gohman return I->second; 25876ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher return LocalValueMap[V]; 25959fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 26059fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 261cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 262cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 263cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 264cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 265cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 266cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 267482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedmanvoid FastISel::UpdateValueMap(const Value *I, unsigned Reg, unsigned NumRegs) { 26840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 26940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 270482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman return; 271c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 272bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 273a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned &AssignedReg = FuncInfo.ValueMap[I]; 274c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 27584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Use the new register. 276c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 27736e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 27884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Arrange for uses of AssignedReg to be replaced by uses of Reg. 279482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman for (unsigned i = 0; i < NumRegs; i++) 280482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman FuncInfo.RegFixups[AssignedReg+i] = Reg+i; 28184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 28284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman AssignedReg = Reg; 28340b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 284cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 285cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 286a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanstd::pair<unsigned, bool> FastISel::getRegForGEPIndex(const Value *Idx) { 287c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 288c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 289c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 290a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(0, false); 291a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 292a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = hasTrivialKill(Idx); 293c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 294c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 295766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 296e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 297a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman if (IdxVT.bitsLT(PtrVT)) { 298a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, 299a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 300a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 301a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 302a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman else if (IdxVT.bitsGT(PtrVT)) { 303a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, 304a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 305a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 306a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 307a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(IdxN, IdxNIsKill); 308c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 309c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 31084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::recomputeInsertPt() { 31184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (getLastLocalValue()) { 31284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = getLastLocalValue(); 313c6e59b71f50c7c77bc448a936dba8e84d90911e8Dan Gohman FuncInfo.MBB = FuncInfo.InsertPt->getParent(); 31484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 31584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } else 31684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = FuncInfo.MBB->getFirstNonPHI(); 31784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 31884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Now skip past any EH_LABELs, which must remain at the beginning. 31984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (FuncInfo.InsertPt != FuncInfo.MBB->end() && 32084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt->getOpcode() == TargetOpcode::EH_LABEL) 32184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 32284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 32384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 324ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosiervoid FastISel::removeDeadCode(MachineBasicBlock::iterator I, 325ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator E) { 326ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier assert (I && E && std::distance(I, E) > 0 && "Invalid iterator!"); 327ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier while (I != E) { 328ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineInstr *Dead = &*I; 329ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier ++I; 330ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier Dead->eraseFromParent(); 331fa785cb22d50c657eb08c762d627cd6aa96982f3Jan Wen Voung ++NumFastIselDead; 332ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 333ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 334ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier} 335ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 33676ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric ChristopherFastISel::SavePoint FastISel::enterLocalValueArea() { 33784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt; 33876ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DebugLoc OldDL = DL; 33984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman recomputeInsertPt(); 34076ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DL = DebugLoc(); 34176ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher SavePoint SP = { OldInsertPt, OldDL }; 34276ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher return SP; 34384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 34484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 34576ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christophervoid FastISel::leaveLocalValueArea(SavePoint OldInsertPt) { 34684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.InsertPt != FuncInfo.MBB->begin()) 34784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = llvm::prior(FuncInfo.InsertPt); 34884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 34984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Restore the previous insert position. 35076ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher FuncInfo.InsertPt = OldInsertPt.InsertPt; 35176ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DL = OldInsertPt.DL; 35284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 35384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 354bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 355bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 356bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 35746510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBinaryOp(const User *I, unsigned ISDOpcode) { 358e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 359825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::Other || !VT.isSimple()) 360d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 361d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 362638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 363b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 364b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 365b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 366b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 367638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 368825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 369638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 370825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 3715dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 3725dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 37323b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), VT); 374638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 375638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 376638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 377d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 378fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // Check if the first operand is a constant, and handle it as "ri". At -O0, 379fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // we don't have anything that canonicalizes operand order. 380fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(0))) 381fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (isa<Instruction>(I) && cast<Instruction>(I)->isCommutative()) { 382fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner unsigned Op1 = getRegForValue(I->getOperand(1)); 383fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (Op1 == 0) return false; 384fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner 385fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 386d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 387602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op1, 388602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op1IsKill, CI->getZExtValue(), 389602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner VT.getSimpleVT()); 390602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 391d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 392602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 393602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 394602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 395fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner } 396d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 397d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 3983df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 399602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Op0 == 0) // Unhandled operand. Halt "fast" selection and bail. 400a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 401a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 402a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 403a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 404d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 405d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 406602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner uint64_t Imm = CI->getZExtValue(); 407d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 408f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner // Transform "sdiv exact X, 8" -> "sra X, 3". 409f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner if (ISDOpcode == ISD::SDIV && isa<BinaryOperator>(I) && 410f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner cast<BinaryOperator>(I)->isExact() && 411f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner isPowerOf2_64(Imm)) { 412f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner Imm = Log2_64(Imm); 413f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner ISDOpcode = ISD::SRA; 414f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner } 415d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 416544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier // Transform "urem x, pow2" -> "and x, pow2-1". 417544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier if (ISDOpcode == ISD::UREM && isa<BinaryOperator>(I) && 418544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier isPowerOf2_64(Imm)) { 419544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier --Imm; 420544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier ISDOpcode = ISD::AND; 421544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier } 422544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier 423602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op0, 424602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op0IsKill, Imm, VT.getSimpleVT()); 425602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 426d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 427602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 428602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 429602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 430d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 431d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 43210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 43310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 434ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 435a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, Op0, Op0IsKill, CF); 436ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 437ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 4383df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 439ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 440ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 44110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 44210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 4433df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 444d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 445d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 446bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 447bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 448a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 449a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 450ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 4510f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 452a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, 453a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 454a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op1, Op1IsKill); 455bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 456bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 457bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 458bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 459bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 4608014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 4613df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 462bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 463bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 464bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 46546510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectGetElementPtr(const User *I) { 4663df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 46783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 46883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 46983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 47083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 471a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool NIsKill = hasTrivialKill(I->getOperand(0)); 472a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 473478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Keep a running tab of the total offset to coalesce multiple N = N + Offset 474478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // into a single N = N + TotalOffset. 475478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t TotalOffs = 0; 476478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // FIXME: What's a good SWAG number for MaxOffs? 477478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t MaxOffs = 2048; 478db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I->getOperand(0)->getType(); 479825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 48046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman for (GetElementPtrInst::const_op_iterator OI = I->op_begin()+1, 48146510a73e977273ec67747eb34cbdb43f815e451Dan Gohman E = I->op_end(); OI != E; ++OI) { 48246510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Idx = *OI; 483db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *StTy = dyn_cast<StructType>(Ty)) { 48483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 48583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 48683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 487478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs += TD.getStructLayout(StTy)->getElementOffset(Field); 488478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 489478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 490478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 491478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 492478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 493478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 494478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 495478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 49683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 49783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 49883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 49983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 50083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 50183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 50246510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 503e368b460a206fafa0d31d5d059b1779b94f7df8cDan Gohman if (CI->isZero()) continue; 504478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // N = N + Offset 5056016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier TotalOffs += 506777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 507478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 508478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 509478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 510478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 511478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 512478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 513478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 514478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 515478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier continue; 516478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 517478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 518478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 51983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 52083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 52183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 522a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman NIsKill = true; 523478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 52483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 525bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 52683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 527777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 528a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman std::pair<unsigned, bool> Pair = getRegForGEPIndex(Idx); 529a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IdxN = Pair.first; 530a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = Pair.second; 53183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 53283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 53383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 53483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 53580bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 536a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, IdxNIsKill, ElementSize, VT); 53780bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 53880bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 53980bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 540a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 54180bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 542a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_rr(VT, VT, ISD::ADD, N, NIsKill, IdxN, IdxNIsKill); 54383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 54483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 54583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 54683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 54783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 548478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 549478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 550478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 551478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 552478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 553478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 55483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 55583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 5563df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 55783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 558bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 559bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 56046510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCall(const User *I) { 561a61e73bda5125c28e48b52e573d115370838596bDan Gohman const CallInst *Call = cast<CallInst>(I); 562a61e73bda5125c28e48b52e573d115370838596bDan Gohman 563a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Handle simple inline asms. 5649e15d658c99c3f0717cb83cc2bd2aa29abdbcdbbDan Gohman if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledValue())) { 565a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Don't attempt to handle constraints. 566a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (!IA->getConstraintString().empty()) 567a61e73bda5125c28e48b52e573d115370838596bDan Gohman return false; 568a61e73bda5125c28e48b52e573d115370838596bDan Gohman 569a61e73bda5125c28e48b52e573d115370838596bDan Gohman unsigned ExtraInfo = 0; 570a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->hasSideEffects()) 571a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_HasSideEffects; 572a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->isAlignStack()) 573a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_IsAlignStack; 574a61e73bda5125c28e48b52e573d115370838596bDan Gohman 575a61e73bda5125c28e48b52e573d115370838596bDan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 576a61e73bda5125c28e48b52e573d115370838596bDan Gohman TII.get(TargetOpcode::INLINEASM)) 577a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addExternalSymbol(IA->getAsmString().c_str()) 578a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addImm(ExtraInfo); 579a61e73bda5125c28e48b52e573d115370838596bDan Gohman return true; 580a61e73bda5125c28e48b52e573d115370838596bDan Gohman } 581a61e73bda5125c28e48b52e573d115370838596bDan Gohman 582c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer MachineModuleInfo &MMI = FuncInfo.MF->getMMI(); 583c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer ComputeUsesVAFloatArgument(*Call, &MMI); 584c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer 585a61e73bda5125c28e48b52e573d115370838596bDan Gohman const Function *F = Call->getCalledFunction(); 58633134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 58733134c4a75558288d663267c8991f6bd37a530afDan Gohman 5884183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Handle selected intrinsic function calls. 589832e4943598d821687cec79f512803c1ca03cff7Chris Lattner switch (F->getIntrinsicID()) { 59033134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 591aefd36bdda0dac496b8acabb25f0de29b370ebcaChad Rosier // At -O0 we don't care about the lifetime intrinsics. 5929b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_start: 5939b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_end: 594fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier // The donothing intrinsic does, well, nothing. 595fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier case Intrinsic::donothing: 5969b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher return true; 597fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier 59892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 599a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgDeclareInst *DI = cast<DbgDeclareInst>(Call); 600cbafae6d33031a72ba8219c28cb0e852511f79a3Manman Ren DIVariable DIVar(DI->getVariable()); 601155615d7dc4e4fbfd3b7273720a76356468edf46Stephen Lin assert((!DIVar || DIVar.isVariable()) && 602cbafae6d33031a72ba8219c28cb0e852511f79a3Manman Ren "Variable in DbgDeclareInst should be either null or a DIVariable."); 603cbafae6d33031a72ba8219c28cb0e852511f79a3Manman Ren if (!DIVar || 604bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher !FuncInfo.MF->getMMI().hasDebugInfo()) { 605bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 6067e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 607bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 60892c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 60946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Address = DI->getAddress(); 610ccaea7dc0bbc75e5d4ee92fb8cc6af0f928d056fEric Christopher if (!Address || isa<UndefValue>(Address)) { 611bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 612dc9185657593b5c1db86cb95a04a68fc09194993Dale Johannesen return true; 613bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 6146fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel 6153517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl unsigned Offset = 0; 6166d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie Optional<MachineOperand> Op; 6176d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie if (const Argument *Arg = dyn_cast<Argument>(Address)) 6189aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel // Some arguments' frame index is recorded during argument lowering. 6193517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl Offset = FuncInfo.getArgumentFrameIndex(Arg); 6203517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl if (Offset) 6213517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl Op = MachineOperand::CreateFI(Offset); 6226d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie if (!Op) 6236d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie if (unsigned Reg = lookUpRegForValue(Address)) 6246d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie Op = MachineOperand::CreateReg(Reg, false); 6258c5293c9556317143505c085cf428e11962e1273Eric Christopher 62684364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we have a VLA that has a "use" in a metadata node that's then used 62784364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // here but it has no other uses, then we have a problem. E.g., 62884364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 62984364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // int foo (const int *x) { 63084364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // char a[*x]; 63184364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // return 0; 63284364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // } 63384364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 63484364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we assign 'a' a vreg and fast isel later on has to use the selection 63584364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // DAG isel, it will want to copy the value to the vreg. However, there are 63684364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // no uses, which goes counter to what selection DAG isel expects. 6376d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie if (!Op && !Address->use_empty() && isa<Instruction>(Address) && 6388c5293c9556317143505c085cf428e11962e1273Eric Christopher (!isa<AllocaInst>(Address) || 6398c5293c9556317143505c085cf428e11962e1273Eric Christopher !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(Address)))) 6406d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie Op = MachineOperand::CreateReg(FuncInfo.InitializeRegForValue(Address), 6416d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie false); 6426d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie 6436d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie if (Op) 6443517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl if (Op->isReg()) { 64545ff709caf46d9f472c9229493853dec27477935Adrian Prantl // Set the indirect flag if the type and the DIVariable's 64645ff709caf46d9f472c9229493853dec27477935Adrian Prantl // indirect field are in disagreement: Indirectly-addressed 64745ff709caf46d9f472c9229493853dec27477935Adrian Prantl // variables that are nonpointer types should be marked as 64845ff709caf46d9f472c9229493853dec27477935Adrian Prantl // indirect, and VLAs should be marked as indirect eventhough 64945ff709caf46d9f472c9229493853dec27477935Adrian Prantl // they are a pointer type. 65045ff709caf46d9f472c9229493853dec27477935Adrian Prantl bool IsIndirect = DI->getAddress()->getType()->isPointerTy() 65145ff709caf46d9f472c9229493853dec27477935Adrian Prantl ^ DIVar.isIndirect(); 6523517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl Op->setIsDebug(true); 6533517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 6543517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl TII.get(TargetOpcode::DBG_VALUE), 65545ff709caf46d9f472c9229493853dec27477935Adrian Prantl IsIndirect, Op->getReg(), Offset, DI->getVariable()); 6563517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl } else 6573517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 6583517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl TII.get(TargetOpcode::DBG_VALUE)).addOperand(*Op).addImm(0) 6596d9dbd5526e3161db884fc4fe99c278bb59ccc19David Blaikie .addMetadata(DI->getVariable()); 66086a87d9ba1faf153e0e6eaddfd3e95595c83bcb1Adrian Prantl else 6614476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // We can't yet handle anything else here because it would require 6624476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // generating code, thus altering codegen because of debug info. 6635da4e4f3b10148e811de82ec57b3f82c15411a81Adrian Prantl DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 66433134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 66592c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 66645df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen case Intrinsic::dbg_value: { 667343b42e428079363ab09828734b2debfd7dbdc9eDale Johannesen // This form of DBG_VALUE is target-independent. 668a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgValueInst *DI = cast<DbgValueInst>(Call); 669e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE); 67046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *V = DI->getValue(); 67145df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen if (!V) { 67245df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // Currently the optimizer can produce this; insert an undef to 67345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // help debugging. Probably the optimizer should not do this. 67484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 67584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(0U).addImm(DI->getOffset()) 67684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 67746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 6788594d429e02c688d428036f8563f09572da3fbffDevang Patel if (CI->getBitWidth() > 64) 6798594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6808594d429e02c688d428036f8563f09572da3fbffDevang Patel .addCImm(CI).addImm(DI->getOffset()) 6818594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 6826016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier else 6838594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6848594d429e02c688d428036f8563f09572da3fbffDevang Patel .addImm(CI->getZExtValue()).addImm(DI->getOffset()) 6858594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 68646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 68784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 68884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addFPImm(CF).addImm(DI->getOffset()) 68984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 69045df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else if (unsigned Reg = lookUpRegForValue(V)) { 6913517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl bool IsIndirect = DI->getOffset() != 0; 6923517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, IsIndirect, 6933517640443f0b5224e2a6414c246ac60016ee9d4Adrian Prantl Reg, DI->getOffset(), DI->getVariable()); 69445df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else { 69545df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // We can't yet handle anything else here because it would require 69645df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // generating code, thus altering codegen because of debug info. 6975da4e4f3b10148e811de82ec57b3f82c15411a81Adrian Prantl DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 698bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 69945df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen return true; 70045df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } 701d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman case Intrinsic::objectsize: { 702d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman ConstantInt *CI = cast<ConstantInt>(Call->getArgOperand(1)); 703d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned long long Res = CI->isZero() ? -1ULL : 0; 704d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman Constant *ResCI = ConstantInt::get(Call->getType(), Res); 705d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned ResultReg = getRegForValue(ResCI); 706d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman if (ResultReg == 0) 707d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return false; 708d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman UpdateValueMap(Call, ResultReg); 709d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return true; 710d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman } 71133947b4391458ed3ba2d7e7c741968325cbffa1dChad Rosier case Intrinsic::expect: { 7124fde76db466a749200af555b0f400af873111767Chad Rosier unsigned ResultReg = getRegForValue(Call->getArgOperand(0)); 71333cdfe9f1943418604be5c800800394ae809fc4cNick Lewycky if (ResultReg == 0) 71433cdfe9f1943418604be5c800800394ae809fc4cNick Lewycky return false; 7154fde76db466a749200af555b0f400af873111767Chad Rosier UpdateValueMap(Call, ResultReg); 7164fde76db466a749200af555b0f400af873111767Chad Rosier return true; 71733947b4391458ed3ba2d7e7c741968325cbffa1dChad Rosier } 71833134c4a75558288d663267c8991f6bd37a530afDan Gohman } 7194183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman 72074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Usually, it does not make sense to initialize a value, 72174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // make an unrelated function call and use the value, because 72274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // it tends to be spilled on the stack. So, we move the pointer 72374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // to the last local value to the beginning of the block, so that 72474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // all the values which have already been materialized, 72574af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // appear after the call. It also makes sense to skip intrinsics 72674af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // since they tend to be inlined. 727b704ffbb46cae716dc51bd8e6ba425c0a4949a47Pete Cooper if (!isa<IntrinsicInst>(Call)) 72874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin flushLocalValueMap(); 72974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 7304183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // An arbitrary call. Bail. 73133134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 73233134c4a75558288d663267c8991f6bd37a530afDan Gohman} 73333134c4a75558288d663267c8991f6bd37a530afDan Gohman 73446510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCast(const User *I, unsigned Opcode) { 735e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 736e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 737bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 738825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 739825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 740d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 741d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 742bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 74376927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the destination type is legal. 744474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 74576927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 746474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 74776927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the source operand is legal. 748474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 74976927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 750474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 7513df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 752d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 753d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 754d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 75514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 756a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool InputRegIsKill = hasTrivialKill(I->getOperand(0)); 757a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 758d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 759d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 760d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 761a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputReg, InputRegIsKill); 762d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 763d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 764bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7653df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 766d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 767d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 768d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 76946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBitCast(const User *I) { 770ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 771ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 7723df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 773a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 774a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 7753df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 776ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 777ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 778ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 779bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Bitcasts of other values become reg-reg copies or BITCAST operators. 7803d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund EVT SrcEVT = TLI.getValueType(I->getOperand(0)->getType()); 7813d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund EVT DstEVT = TLI.getValueType(I->getType()); 7823d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund if (SrcEVT == MVT::Other || DstEVT == MVT::Other || 7833d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund !TLI.isTypeLegal(SrcEVT) || !TLI.isTypeLegal(DstEVT)) 784d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 785d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 786bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7873d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund MVT SrcVT = SrcEVT.getSimpleVT(); 7883d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund MVT DstVT = DstEVT.getSimpleVT(); 7893df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 790ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 791ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 792d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 793a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 794a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 795bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 796ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 797ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 798a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund if (SrcVT == DstVT) { 79944d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 80044d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 801e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen // Don't attempt a cross-class copy. It will likely fail. 802e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen if (SrcClass == DstClass) { 803e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg = createResultReg(DstClass); 804e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 805e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg).addReg(Op0); 806e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen } 807ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 808bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 809bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If the reg-reg copy failed, select a BITCAST opcode. 810ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 811a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund ResultReg = FastEmit_r(SrcVT, DstVT, ISD::BITCAST, Op0, Op0IsKill); 812bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 813ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 814d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 815bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 8163df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 817d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 818d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 819d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 8203df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 82146510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectInstruction(const Instruction *I) { 822e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // Just before the terminator instruction, insert instructions to 823e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // feed PHI nodes in successor blocks. 824e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (isa<TerminatorInst>(I)) 825e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (!HandlePHINodesInSuccessorBlocks(I->getParent())) 826e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman return false; 827e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman 8288ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = I->getDebugLoc(); 8298ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman 830ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator SavedInsertPt = FuncInfo.InsertPt; 831ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 832982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson // As a special case, don't handle calls to builtin library functions that 833982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson // may be translated directly to target instructions. 834d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson if (const CallInst *Call = dyn_cast<CallInst>(I)) { 835d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson const Function *F = Call->getCalledFunction(); 836d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibFunc::Func Func; 837d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson if (F && !F->hasLocalLinkage() && F->hasName() && 838d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibInfo->getLibFunc(F->getName(), Func) && 839982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson LibInfo->hasOptimizedCodeGen(Func)) 840d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson return false; 841d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson } 842d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson 8436e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // First, try doing target-independent selection. 8447dbd34b199be8d053240a67cc1e81a04096af1c2Michael Ilseman if (SelectOperator(I, I->getOpcode())) { 845fa785cb22d50c657eb08c762d627cd6aa96982f3Jan Wen Voung ++NumFastIselSuccessIndependent; 8468ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8476e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8488ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 8496016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier // Remove dead code. However, ignore call instructions since we've flushed 850ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // the local value map and recomputed the insert point. 851ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (!isa<CallInst>(I)) { 852ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 853ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 854ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 855ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 8566e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8576e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // Next, try calling the target to attempt to handle the instruction. 858ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier SavedInsertPt = FuncInfo.InsertPt; 8598ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (TargetSelectInstruction(I)) { 860fa785cb22d50c657eb08c762d627cd6aa96982f3Jan Wen Voung ++NumFastIselSuccessTarget; 8618ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8626e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8638ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 864ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // Check for dead code and remove as necessary. 865ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 866ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 867ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 8686e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8698ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8706e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return false; 87140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 87240b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 873d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 874d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 875d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 876d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 8773bf912593301152b65accb9d9c37a95172f1df5aStuart HastingsFastISel::FastEmitBranch(MachineBasicBlock *MSucc, DebugLoc DL) { 87818112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher 879092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (FuncInfo.MBB->getBasicBlock()->size() > 1 && 880092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng FuncInfo.MBB->isLayoutSuccessor(MSucc)) { 88118112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // For more accurate line information if this is the only instruction 88218112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // in the block then emit it, otherwise we have the unconditional 88318112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // fall-through case, which needs no instructions. 884d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 885d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 88684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.InsertBranch(*FuncInfo.MBB, MSucc, NULL, 88784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVector<MachineOperand, 0>(), DL); 888d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 88984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.MBB->addSuccessor(MSucc); 890d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 891d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 8923d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// SelectFNeg - Emit an FNeg operation. 8933d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// 8943d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohmanbool 89546510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectFNeg(const User *I) { 8963d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 8973d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (OpReg == 0) return false; 8983d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 899a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool OpRegIsKill = hasTrivialKill(I); 900a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 9014a215a13c3035a8818254b61267be77def4a2a37Dan Gohman // If the target has ISD::FNEG, use it. 9024a215a13c3035a8818254b61267be77def4a2a37Dan Gohman EVT VT = TLI.getValueType(I->getType()); 9034a215a13c3035a8818254b61267be77def4a2a37Dan Gohman unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 904a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::FNEG, OpReg, OpRegIsKill); 9054a215a13c3035a8818254b61267be77def4a2a37Dan Gohman if (ResultReg != 0) { 9064a215a13c3035a8818254b61267be77def4a2a37Dan Gohman UpdateValueMap(I, ResultReg); 9074a215a13c3035a8818254b61267be77def4a2a37Dan Gohman return true; 9084a215a13c3035a8818254b61267be77def4a2a37Dan Gohman } 9094a215a13c3035a8818254b61267be77def4a2a37Dan Gohman 9105e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // Bitcast the value to integer, twiddle the sign bit with xor, 9115e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // and then bitcast it back to floating-point. 9123d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (VT.getSizeInBits() > 64) return false; 9135e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 9145e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (!TLI.isTypeLegal(IntVT)) 9155e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 9165e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 9175e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 918bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, OpReg, OpRegIsKill); 9195e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntReg == 0) 9205e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 9215e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 922a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, 923a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntReg, /*Kill=*/true, 9245e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman UINT64_C(1) << (VT.getSizeInBits()-1), 9255e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman IntVT.getSimpleVT()); 9265e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntResultReg == 0) 9275e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 9285e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 9295e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 930bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, IntResultReg, /*Kill=*/true); 9313d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (ResultReg == 0) 9323d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return false; 9333d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 9343d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman UpdateValueMap(I, ResultReg); 9353d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return true; 9363d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman} 9373d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 93840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 9392586b8f9366aed5a1efa44d3f18d095511601642Eli FriedmanFastISel::SelectExtractValue(const User *U) { 9402586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U); 941a4c920db7a3620f365144eac9aaad7ca23062caaEli Friedman if (!EVI) 9422586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9432586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 944482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // Make sure we only try to handle extracts with a legal result. But also 945482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // allow i1 because it's easy. 9462586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman EVT RealVT = TLI.getValueType(EVI->getType(), /*AllowUnknown=*/true); 9472586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (!RealVT.isSimple()) 9482586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9492586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman MVT VT = RealVT.getSimpleVT(); 950482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman if (!TLI.isTypeLegal(VT) && VT != MVT::i1) 9512586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9522586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9532586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const Value *Op0 = EVI->getOperand(0); 954db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AggTy = Op0->getType(); 9552586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9562586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the base result register. 9572586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman unsigned ResultReg; 9582586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0); 9592586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (I != FuncInfo.ValueMap.end()) 9602586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = I->second; 9610b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else if (isa<Instruction>(Op0)) 9622586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = FuncInfo.InitializeRegForValue(Op0); 9630b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else 9640b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman return false; // fast-isel can't handle aggregate constants at the moment 9652586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9662586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the actual result register, which is an offset from the base register. 967fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad unsigned VTIndex = ComputeLinearIndex(AggTy, EVI->getIndices()); 9682586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9692586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman SmallVector<EVT, 4> AggValueVTs; 9702586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ComputeValueVTs(TLI, AggTy, AggValueVTs); 9712586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9722586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman for (unsigned i = 0; i < VTIndex; i++) 9732586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg += TLI.getNumRegisters(FuncInfo.Fn->getContext(), AggValueVTs[i]); 9742586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9752586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman UpdateValueMap(EVI, ResultReg); 9762586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return true; 9772586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman} 9782586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9792586b8f9366aed5a1efa44d3f18d095511601642Eli Friedmanbool 98046510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectOperator(const User *I, unsigned Opcode) { 98140b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 982ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 983ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 984ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 985ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 986ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 987ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 988ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 9893d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman // FNeg is currently represented in LLVM IR as a special case of FSub. 9903d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (BinaryOperator::isFNeg(I)) 9913d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return SelectFNeg(I); 992ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 993ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 994ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 995ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 996ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 9973df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 9983df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 9993df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 10003df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 10013df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 10023df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 10033df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 10043df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 10053df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 10063df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 10073df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 10083df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 10093df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 10103df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 10113df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 10123df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 10133df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 10143df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 10153df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 10163df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 10173df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 10183df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 10193df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 10203df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 10213df24e667f04a7003342b534310919abc9c87418Dan Gohman 10223df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 10233df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 10243df24e667f04a7003342b534310919abc9c87418Dan Gohman 10253df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 102646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BranchInst *BI = cast<BranchInst>(I); 10273df24e667f04a7003342b534310919abc9c87418Dan Gohman 10283df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 102946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BasicBlock *LLVMSucc = BI->getSuccessor(0); 1030a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc]; 10313bf912593301152b65accb9d9c37a95172f1df5aStuart Hastings FastEmitBranch(MSucc, BI->getDebugLoc()); 10323df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 10339d5b41624003daf259b33fc953aa471049700353Owen Anderson } 10343df24e667f04a7003342b534310919abc9c87418Dan Gohman 10353df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 10363df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 10373df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 1038b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 1039b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1040087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 1041087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 1042087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 1043087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 10440586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 10450586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 1046a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I))) 10470586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 10480586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 10490586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 10500586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 1051bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 105233134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 105333134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 1054bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 10553df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 10563df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 10573df24e667f04a7003342b534310919abc9c87418Dan Gohman 10583df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 10593df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 10603df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 10613df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10623df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 10633df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 10643df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 10653df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10663df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 10673df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 10683df24e667f04a7003342b534310919abc9c87418Dan Gohman 10693df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 10703df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 1071e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 1072e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 10733df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 10743df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10753df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 10763df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10773df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 10783df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 10793df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 10803df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 10813df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1082d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 10832586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman case Instruction::ExtractValue: 10842586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return SelectExtractValue(I); 10852586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 1086ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman case Instruction::PHI: 1087ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman llvm_unreachable("FastISel shouldn't visit PHI nodes!"); 1088ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman 10893df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 10903df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 10913df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 10923df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1093b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1094b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1095d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob WilsonFastISel::FastISel(FunctionLoweringInfo &funcInfo, 1096d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson const TargetLibraryInfo *libInfo) 109784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman : FuncInfo(funcInfo), 1098a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MRI(FuncInfo.MF->getRegInfo()), 1099a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MFI(*FuncInfo.MF->getFrameInfo()), 1100a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MCP(*FuncInfo.MF->getConstantPool()), 1101a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman TM(FuncInfo.MF->getTarget()), 11023574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow TD(*TM.getDataLayout()), 110322bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 1104a7a0ed79012ea36f838239cf1d04959711aec2a9Dan Gohman TLI(*TM.getTargetLowering()), 1105d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson TRI(*TM.getRegisterInfo()), 1106d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibInfo(libInfo) { 1107bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 1108bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 1109e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 1110e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 1111092e5e75661fdd5d54a748fb00fab59d21031268Evan Chengbool FastISel::FastLowerArguments() { 1112092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return false; 1113092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng} 1114092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 1115825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 11167c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned) { 1117b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1118b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1119b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1120825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 1121a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1122a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/) { 1123b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1124b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1125b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1126bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckunsigned FastISel::FastEmit_rr(MVT, MVT, 1127a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1128a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1129a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/) { 1130b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1131b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1132b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 11337c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 113483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 113583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 113683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1137825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 113846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned, const ConstantFP * /*FPImm*/) { 113910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 114010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 114110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1142825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 1143a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1144a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 11450f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 1146d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 1147d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1148d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1149825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 1150a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1151a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 115246510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const ConstantFP * /*FPImm*/) { 115310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 115410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 115510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1156825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 11577c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, 1158a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1159a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/, 1160d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 116183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 116283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 116383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 116483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 116583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 116683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 116783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 11687c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 1169a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1170a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm, MVT ImmType) { 1171602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // If this is a multiply by a power of two, emit this as a shift left. 1172602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Opcode == ISD::MUL && isPowerOf2_64(Imm)) { 1173602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Opcode = ISD::SHL; 1174602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm = Log2_64(Imm); 1175090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner } else if (Opcode == ISD::UDIV && isPowerOf2_64(Imm)) { 1176090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner // div x, 8 -> srl x, 3 1177090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Opcode = ISD::SRL; 1178090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Imm = Log2_64(Imm); 1179602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner } 1180d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1181602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // Horrible hack (to be removed), check to make sure shift amounts are 1182602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // in-range. 1183602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if ((Opcode == ISD::SHL || Opcode == ISD::SRA || Opcode == ISD::SRL) && 1184602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm >= VT.getSizeInBits()) 1185602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return 0; 1186d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 118783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 1188a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Op0IsKill, Imm); 118983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 119083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 11910f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 1192b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman if (MaterialReg == 0) { 1193b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // This is a bit ugly/slow, but failing here means falling out of 1194b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // fast-isel, which would be very slow. 1195db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *ITy = IntegerType::get(FuncInfo.Fn->getContext(), 1196b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman VT.getSizeInBits()); 1197b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman MaterialReg = getRegForValue(ConstantInt::get(ITy, Imm)); 11987ae3bb83c278e991940d022b7b48d996da408abfChad Rosier assert (MaterialReg != 0 && "Unable to materialize imm."); 11997ae3bb83c278e991940d022b7b48d996da408abfChad Rosier if (MaterialReg == 0) return 0; 1200b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman } 1201a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_rr(VT, VT, Opcode, 1202a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 1203a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman MaterialReg, /*Kill=*/true); 1204d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1205d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1206d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 1207d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 120883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 120983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1210b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 121177ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 1212d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1213e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1214b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 121584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg); 1216b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1217b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1218b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1219b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 1220b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1221a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill) { 1222d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1223e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1224b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 12255960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 122684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 122784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 12285960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 122984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 123084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 1231e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1232e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12335960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 12345960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 1235b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1236b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1237b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1238b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 1239b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1240a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1241a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill) { 1242d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1243e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1244b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 12455960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 124684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1247a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1248a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 12495960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 125084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1251a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1252a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 1253e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1254e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12555960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1256b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1257b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1258d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1259d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Andersonunsigned FastISel::FastEmitInst_rrr(unsigned MachineInstOpcode, 1260d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson const TargetRegisterClass *RC, 1261d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op0, bool Op0IsKill, 1262d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op1, bool Op1IsKill, 1263d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op2, bool Op2IsKill) { 1264d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned ResultReg = createResultReg(RC); 1265e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1266d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1267d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson if (II.getNumDefs() >= 1) 1268d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1269d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1270d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1271d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1272d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson else { 1273d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1274d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1275d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1276d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1277d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1278d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1279d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson } 1280d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson return ResultReg; 1281d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson} 1282d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1283d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 1284d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1285a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1286a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1287d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1288e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1289d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12905960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 129184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1292a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1293a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 12945960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 129584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1296a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1297a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1298e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1299e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13005960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1301d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1302d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1303d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 13042ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Andersonunsigned FastISel::FastEmitInst_rii(unsigned MachineInstOpcode, 13052ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson const TargetRegisterClass *RC, 13062ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned Op0, bool Op0IsKill, 13072ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson uint64_t Imm1, uint64_t Imm2) { 13082ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned ResultReg = createResultReg(RC); 1309e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 13102ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 13112ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson if (II.getNumDefs() >= 1) 13122ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 13132ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 13142ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 13152ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 13162ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson else { 13172ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 13182ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 13192ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 13202ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 13212ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 13222ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 13232ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson } 13242ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson return ResultReg; 13252ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson} 13262ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 132710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 132810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 1329a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1330a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const ConstantFP *FPImm) { 133110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 1332e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 133310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 13345960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 133584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1336a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1337a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 13385960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 133984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1340a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1341a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 1342e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1343e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13445960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 134510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 134610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 134710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1348d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 1349d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1350a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1351a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill, 1352a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1353d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1354e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1355d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 13565960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 135784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1358a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1359a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1360a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 13615960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 136284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1363a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1364a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1365a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1366e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1367e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13685960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1369d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1370d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 13716d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 137268f25571e759c1fcf2da206109647259f49f7416Manman Renunsigned FastISel::FastEmitInst_rrii(unsigned MachineInstOpcode, 137368f25571e759c1fcf2da206109647259f49f7416Manman Ren const TargetRegisterClass *RC, 137468f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned Op0, bool Op0IsKill, 137568f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned Op1, bool Op1IsKill, 137668f25571e759c1fcf2da206109647259f49f7416Manman Ren uint64_t Imm1, uint64_t Imm2) { 137768f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned ResultReg = createResultReg(RC); 137868f25571e759c1fcf2da206109647259f49f7416Manman Ren const MCInstrDesc &II = TII.get(MachineInstOpcode); 137968f25571e759c1fcf2da206109647259f49f7416Manman Ren 138068f25571e759c1fcf2da206109647259f49f7416Manman Ren if (II.getNumDefs() >= 1) 138168f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 138268f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op0, Op0IsKill * RegState::Kill) 138368f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op1, Op1IsKill * RegState::Kill) 138468f25571e759c1fcf2da206109647259f49f7416Manman Ren .addImm(Imm1).addImm(Imm2); 138568f25571e759c1fcf2da206109647259f49f7416Manman Ren else { 138668f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 138768f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op0, Op0IsKill * RegState::Kill) 138868f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op1, Op1IsKill * RegState::Kill) 138968f25571e759c1fcf2da206109647259f49f7416Manman Ren .addImm(Imm1).addImm(Imm2); 139068f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 139168f25571e759c1fcf2da206109647259f49f7416Manman Ren ResultReg).addReg(II.ImplicitDefs[0]); 139268f25571e759c1fcf2da206109647259f49f7416Manman Ren } 139368f25571e759c1fcf2da206109647259f49f7416Manman Ren return ResultReg; 139468f25571e759c1fcf2da206109647259f49f7416Manman Ren} 139568f25571e759c1fcf2da206109647259f49f7416Manman Ren 13966d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 13976d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 13986d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 13996d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 1400e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1401bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 14025960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 140384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg).addImm(Imm); 14045960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 140584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm); 1406e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1407e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 14085960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 14096d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 1410b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 14118970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1412d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Andersonunsigned FastISel::FastEmitInst_ii(unsigned MachineInstOpcode, 1413d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson const TargetRegisterClass *RC, 1414d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson uint64_t Imm1, uint64_t Imm2) { 1415d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson unsigned ResultReg = createResultReg(RC); 1416e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1417d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1418d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson if (II.getNumDefs() >= 1) 1419d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1420d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson .addImm(Imm1).addImm(Imm2); 1421d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson else { 1422d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm1).addImm(Imm2); 1423d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1424d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1425d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson } 1426d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson return ResultReg; 1427d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson} 1428d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1429825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 1430a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1431a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint32_t Idx) { 1432536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 14330bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Op0) && 14340bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen "Cannot yet extract from physregs"); 1435ee0d5d4398fb855c6674da94d902ef45e944f375Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI.getRegClass(Op0); 1436ee0d5d4398fb855c6674da94d902ef45e944f375Jakob Stoklund Olesen MRI.constrainRegClass(Op0, TRI.getSubClassWithSubReg(RC, Idx)); 143784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, 143884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman DL, TII.get(TargetOpcode::COPY), ResultReg) 14390bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen .addReg(Op0, getKillRegState(Op0IsKill), Idx); 14408970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 14418970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 144214ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 144314ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 144414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 1445a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill) { 1446a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op0, Op0IsKill, 1); 144714ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1448f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1449f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 1450f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Emit code to ensure constants are copied into registers when needed. 1451f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Remember the virtual registers that need to be added to the Machine PHI 1452f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// nodes as input. We cannot just directly add them, because expansion 1453f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// might result in multiple MBB's for one BB. As such, the start of the 1454f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// BB might correspond to a different MBB than the end. 1455f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohmanbool FastISel::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) { 1456f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const TerminatorInst *TI = LLVMBB->getTerminator(); 1457f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1458f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled; 1459a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size(); 1460f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1461f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Check successor nodes' PHI nodes that expect a constant to be available 1462f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // from this block. 1463f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 1464f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const BasicBlock *SuccBB = TI->getSuccessor(succ); 1465f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!isa<PHINode>(SuccBB->begin())) continue; 1466a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 1467f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1468f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // If this terminator has multiple identical successors (common for 1469f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // switches), only handle each succ once. 1470f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!SuccsHandled.insert(SuccMBB)) continue; 1471f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1472f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 1473f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1474f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // At this point we know that there is a 1-1 correspondence between LLVM PHI 1475f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // nodes and Machine PHI nodes, but the incoming operands have not been 1476f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // emitted yet. 1477f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (BasicBlock::const_iterator I = SuccBB->begin(); 1478f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1479fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1480f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Ignore dead phi's. 1481f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (PN->use_empty()) continue; 1482f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1483f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Only handle legal types. Two interesting things to note here. First, 1484f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // by bailing out early, we may leave behind some dead instructions, 1485f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its 14867a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // own moves. Second, this check is necessary because FastISel doesn't 148789496d0eb73ab8771b27b3d9c1db6492d8eefc3aDan Gohman // use CreateRegs to create registers, so it always creates 1488f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // exactly one register for each non-void instruction. 1489f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true); 1490f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (VT == MVT::Other || !TLI.isTypeLegal(VT)) { 14912f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier // Handle integer promotions, though, because they're common and easy. 14922f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 1493f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT); 1494f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman else { 1495a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1496f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1497f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1498f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1499f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1500f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1501f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1502fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // Set the DebugLoc for the copy. Prefer the location of the operand 1503fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // if there is one; use the location of the PHI otherwise. 1504fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = PN->getDebugLoc(); 1505fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman if (const Instruction *Inst = dyn_cast<Instruction>(PHIOp)) 1506fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = Inst->getDebugLoc(); 1507fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1508f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman unsigned Reg = getRegForValue(PHIOp); 1509f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (Reg == 0) { 1510a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1511f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1512f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1513a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); 1514fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = DebugLoc(); 1515f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1516f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1517f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1518f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return true; 1519f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman} 152075299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 152175299e3a95c0cfcade8515c603e7802351a11beeEli Benderskybool FastISel::tryToFoldLoad(const LoadInst *LI, const Instruction *FoldInst) { 1522462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky assert(LI->hasOneUse() && 1523462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky "tryToFoldLoad expected a LoadInst with a single use"); 152475299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // We know that the load has a single use, but don't know what it is. If it 152575299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // isn't one of the folded instructions, then we can't succeed here. Handle 152675299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // this by scanning the single-use users of the load until we get to FoldInst. 152775299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky unsigned MaxUsers = 6; // Don't scan down huge single-use chains of instrs. 152875299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 152975299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky const Instruction *TheUser = LI->use_back(); 153075299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky while (TheUser != FoldInst && // Scan up until we find FoldInst. 153175299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // Stay in the right block. 153275299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky TheUser->getParent() == FoldInst->getParent() && 153375299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky --MaxUsers) { // Don't scan too far. 153475299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // If there are multiple or no uses of this instruction, then bail out. 153575299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky if (!TheUser->hasOneUse()) 153675299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky return false; 153775299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 153875299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky TheUser = TheUser->use_back(); 153975299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky } 154075299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 154175299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // If we didn't find the fold instruction, then we failed to collapse the 154275299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // sequence. 154375299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky if (TheUser != FoldInst) 154475299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky return false; 154575299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 154675299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // Don't try to fold volatile loads. Target has to deal with alignment 154775299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // constraints. 1548462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky if (LI->isVolatile()) 1549462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky return false; 155075299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 155175299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // Figure out which vreg this is going into. If there is no assigned vreg yet 155275299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // then there actually was no reference to it. Perhaps the load is referenced 155375299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // by a dead instruction. 155475299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky unsigned LoadReg = getRegForValue(LI); 155575299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky if (LoadReg == 0) 155675299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky return false; 155775299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 1558462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky // We can't fold if this vreg has no uses or more than one use. Multiple uses 1559462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky // may mean that the instruction got lowered to multiple MIs, or the use of 1560462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky // the loaded value ended up being multiple operands of the result. 1561462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky if (!MRI.hasOneUse(LoadReg)) 156275299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky return false; 156375299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 1564462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky MachineRegisterInfo::reg_iterator RI = MRI.reg_begin(LoadReg); 156575299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky MachineInstr *User = &*RI; 156675299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 156775299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // Set the insertion point properly. Folding the load can cause generation of 1568462123f66159a8c7ff34b87cb269955252be3ec0Eli Bendersky // other random instructions (like sign extends) for addressing modes; make 156975299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // sure they get inserted in a logical place before the new instruction. 157075299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky FuncInfo.InsertPt = User; 157175299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky FuncInfo.MBB = User->getParent(); 157275299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 157375299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky // Ask the target to try folding the load. 157475299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky return tryToFoldLoadIntoMI(User, RI.getOperandNo(), LI); 157575299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky} 157675299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 157775299e3a95c0cfcade8515c603e7802351a11beeEli Bendersky 1578