13b172f1c018a093d0dae3105324d782103fcda6dDan Gohman//===-- FastISel.cpp - Implementation of the FastISel class ---------------===// 2b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 3b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// The LLVM Compiler Infrastructure 4b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 5b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// This file is distributed under the University of Illinois Open Source 6b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// License. See LICENSE.TXT for details. 7b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 8b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman//===----------------------------------------------------------------------===// 9b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 10b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// This file contains the implementation of the FastISel class. 11b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 125ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// "Fast" instruction selection is designed to emit very poor code quickly. 135ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// Also, it is not designed to be able to do much lowering, so most illegal 1444d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// types (e.g. i64 on 32-bit targets) and operations are not supported. It is 1544d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// also not intended to be able to do much optimization, except in a few cases 1644d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// where doing optimizations reduces overall compile time. For example, folding 1744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// constants into immediate fields is often done, because it's cheap and it 1844d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// reduces the number of instructions later phases have to examine. 195ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 205ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// "Fast" instruction selection is able to fail gracefully and transfer 215ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// control to the SelectionDAG selector for operations that it doesn't 2244d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// support. In many cases, this allows us to avoid duplicating a lot of 235ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// the complicated lowering logic that SelectionDAG currently has. 245ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 255ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// The intended use for "fast" instruction selection is "-O0" mode 265ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// compilation, where the quality of the generated code is irrelevant when 2744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// weighed against the speed at which the code can be generated. Also, 285ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// at -O0, the LLVM optimizers are not running, and this makes the 295ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// compile time of codegen a much higher portion of the overall compile 3044d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// time. Despite its limitations, "fast" instruction selection is able to 315ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// handle enough code on its own to provide noticeable overall speedups 325ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// in -O0 compiles. 335ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 345ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// Basic operations are supported in a target-independent way, by reading 355ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// the same instruction descriptions that the SelectionDAG selector reads, 365ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// and identifying simple arithmetic operations that can be directly selected 3744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// from simple operators. More complicated operations currently require 385ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// target-specific code. 395ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 40b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman//===----------------------------------------------------------------------===// 41b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 42053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier#define DEBUG_TYPE "isel" 43b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/FastISel.h" 44d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 45d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Analysis/Loads.h" 46d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/Analysis.h" 474c3fd9f92f89810d659973d2666ab729758de64aDan Gohman#include "llvm/CodeGen/FunctionLoweringInfo.h" 48b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineInstrBuilder.h" 4933134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/CodeGen/MachineModuleInfo.h" 50b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineRegisterInfo.h" 51d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/DebugInfo.h" 520b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 530b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 540b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalVariable.h" 550b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 560b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/IntrinsicInst.h" 570b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 58d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Debug.h" 59d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/ErrorHandling.h" 60b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 61d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson#include "llvm/Target/TargetLibraryInfo.h" 6283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 63bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 64b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 65b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 66aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessIndependent, "Number of insts selected by " 67aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-independent selector"); 68aa5656c6b9161608005cf8dc85027c160a925e58Chad RosierSTATISTIC(NumFastIselSuccessTarget, "Number of insts selected by " 69aa5656c6b9161608005cf8dc85027c160a925e58Chad Rosier "target-specific selector"); 70ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad RosierSTATISTIC(NumFastIselDead, "Number of dead insts removed on failure"); 71053e69ad5704a8e0e5f50d8b18f8917377ffacfbChad Rosier 7284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// startNewBlock - Set the current block to which generated machine 7384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// instructions will be appended, and clear the local CSE map. 7484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// 7584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::startNewBlock() { 7684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LocalValueMap.clear(); 7784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 7874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = 0; 7984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 8074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Advance the emit start point past any EH_LABEL instructions. 8184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator 8284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman I = FuncInfo.MBB->begin(), E = FuncInfo.MBB->end(); 8384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (I != E && I->getOpcode() == TargetOpcode::EH_LABEL) { 8474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin EmitStartPt = I; 8584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++I; 8684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 8774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 8874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin} 8974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 90092e5e75661fdd5d54a748fb00fab59d21031268Evan Chengbool FastISel::LowerArguments() { 91092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (!FuncInfo.CanLowerReturn) 92092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng // Fallback to SDISel argument lowering code to deal with sret pointer 93092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng // parameter. 94092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return false; 95092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 96092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (!FastLowerArguments()) 97092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return false; 98092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 99092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng // Enter non-dead arguments into ValueMap for uses in non-entry BBs. 100092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng for (Function::const_arg_iterator I = FuncInfo.Fn->arg_begin(), 101092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng E = FuncInfo.Fn->arg_end(); I != E; ++I) { 102092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (!I->use_empty()) { 103092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng DenseMap<const Value *, unsigned>::iterator VI = LocalValueMap.find(I); 104092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng assert(VI != LocalValueMap.end() && "Missed an argument?"); 105092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng FuncInfo.ValueMap[I] = VI->second; 106092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng } 107092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng } 108092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return true; 109092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng} 110092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 11174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasinvoid FastISel::flushLocalValueMap() { 11274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LocalValueMap.clear(); 11374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin LastLocalValue = EmitStartPt; 11474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin recomputeInsertPt(); 11584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 11684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 117a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanbool FastISel::hasTrivialKill(const Value *V) const { 1187f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Don't consider constants or arguments to have trivial kills. 119a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const Instruction *I = dyn_cast<Instruction>(V); 1207f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (!I) 1217f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1227f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 1237f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // No-op casts are trivially coalesced by fast-isel. 1247f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (const CastInst *Cast = dyn_cast<CastInst>(I)) 125ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) && 126ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth !hasTrivialKill(Cast->getOperand(0))) 1277f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 1287f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 12922b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier // GEPs with all zero indices are trivially coalesced by fast-isel. 13022b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) 13122b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier if (GEP->hasAllZeroIndices() && !hasTrivialKill(GEP->getOperand(0))) 13222b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier return false; 13322b34cce4d270f787d4c991baee596a9e3b7f836Chad Rosier 1347f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Only instructions with a single use in the same basic block are considered 1357f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // to have trivial kills. 1367f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return I->hasOneUse() && 1377f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !(I->getOpcode() == Instruction::BitCast || 1387f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::PtrToInt || 1397f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::IntToPtr) && 14096f1d8ebdd33b3f9bdb3b1163f36072c68599f42Gabor Greif cast<Instruction>(*I->use_begin())->getParent() == I->getParent(); 141a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman} 142a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 14346510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::getRegForValue(const Value *V) { 144e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 1454fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 1464fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 1474fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 148821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 149c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 150c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 151c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 152825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 153821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 15476927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Handle integer promotions, though, because they're common and easy. 15576927d7303046058c627691bd45d6bff608f49f4Eli Friedman if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 15623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 157821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 158821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 159821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 160821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 1614e27027562d6843364e0ab744f97958b6abca08dEric Christopher // Look up the value to see if we already have a register for it. 1624e27027562d6843364e0ab744f97958b6abca08dEric Christopher unsigned Reg = lookUpRegForValue(V); 163c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 164c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 165c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 16697c94b8fc630b55e17a37481910810639e28d086Dan Gohman // In bottom-up mode, just create the virtual register which will be used 16797c94b8fc630b55e17a37481910810639e28d086Dan Gohman // to hold the value. It will be materialized later. 16884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (isa<Instruction>(V) && 16984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman (!isa<AllocaInst>(V) || 17084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(V)))) 17184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return FuncInfo.InitializeRegForValue(V); 17284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 17376ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher SavePoint SaveInsertPt = enterLocalValueArea(); 17484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 17584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Materialize the value in a register. Emit any instructions in the 17684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // local value area. 17784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Reg = materializeRegForValue(V, VT); 17884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 17976ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher leaveLocalValueArea(SaveInsertPt); 18097c94b8fc630b55e17a37481910810639e28d086Dan Gohman 18184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return Reg; 1821fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman} 1831fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 18444a2c3476bd15e03f294bae1b50016851f214f8dEric Christopher/// materializeRegForValue - Helper for getRegForValue. This function is 1851fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// called when the value isn't already available in a register and must 1861fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// be materialized with new instructions. 1871fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohmanunsigned FastISel::materializeRegForValue(const Value *V, MVT VT) { 1881fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman unsigned Reg = 0; 1891fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 19046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 1912ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 1922ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 1930586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 1942ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 195205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 1961e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 1971e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 1981d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 199ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 20046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 201bd1253809bc1b2455793a64d2801db3d6317b08eEli Friedman if (CF->isNullValue()) { 2022790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = TargetMaterializeFloatZero(CF); 2032790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } else { 2042790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman // Try to emit the constant directly. 2052790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 2062790ba8e5a7bb6e00fdac9997d840598fb60271cEli Friedman } 207ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 208ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 2094183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Try to emit the constant by using an integer constant with a cast. 210ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 211e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 212ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 213ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 214ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 21523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 21623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 217c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher APFloat::rmTowardZero, &isExact); 21823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 2193ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin APInt IntVal(IntBitWidth, x); 220ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 221e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 222eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 2232ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 224a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, 225a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntegerReg, /*Kill=*/false); 2262ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 227ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 22846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const Operator *Op = dyn_cast<Operator>(V)) { 22920d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!SelectOperator(Op, Op->getOpcode())) 23020d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!isa<Instruction>(Op) || 23120d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman !TargetSelectInstruction(cast<Instruction>(Op))) 23220d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman return 0; 23337db6cdaea47d0637bdbe624f7b10ff8f82928adDan Gohman Reg = lookUpRegForValue(Op); 234205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 235104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 23684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 23784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.get(TargetOpcode::IMPLICIT_DEF), Reg); 238ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 239bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 240dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 241dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 2426e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 2432ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 244bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2452ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 2462ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 24784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (Reg != 0) { 248dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 24984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = MRI.getVRegDef(Reg); 25084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 251104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 252ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 253ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 25446510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::lookUpRegForValue(const Value *V) { 25559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 25659fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 25759fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 2581fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman // def-dominates-use requirement enforced. 259a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 260a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (I != FuncInfo.ValueMap.end()) 2613193a689db3de8640d412ccd9482301647359a4eDan Gohman return I->second; 26276ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher return LocalValueMap[V]; 26359fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 26459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 265cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 266cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 267cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 268cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 269cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 270cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 271482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedmanvoid FastISel::UpdateValueMap(const Value *I, unsigned Reg, unsigned NumRegs) { 27240b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 27340b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 274482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman return; 275c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 276bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 277a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned &AssignedReg = FuncInfo.ValueMap[I]; 278c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 27984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Use the new register. 280c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 28136e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 28284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Arrange for uses of AssignedReg to be replaced by uses of Reg. 283482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman for (unsigned i = 0; i < NumRegs; i++) 284482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman FuncInfo.RegFixups[AssignedReg+i] = Reg+i; 28584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 28684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman AssignedReg = Reg; 28740b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 288cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 289cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 290a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanstd::pair<unsigned, bool> FastISel::getRegForGEPIndex(const Value *Idx) { 291c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 292c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 293c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 294a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(0, false); 295a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 296a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = hasTrivialKill(Idx); 297c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 298c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 299766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 300e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 301a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman if (IdxVT.bitsLT(PtrVT)) { 302a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, 303a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 304a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 305a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 306a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman else if (IdxVT.bitsGT(PtrVT)) { 307a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, 308a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 309a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 310a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 311a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(IdxN, IdxNIsKill); 312c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 313c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 31484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::recomputeInsertPt() { 31584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (getLastLocalValue()) { 31684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = getLastLocalValue(); 317c6e59b71f50c7c77bc448a936dba8e84d90911e8Dan Gohman FuncInfo.MBB = FuncInfo.InsertPt->getParent(); 31884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 31984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } else 32084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = FuncInfo.MBB->getFirstNonPHI(); 32184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 32284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Now skip past any EH_LABELs, which must remain at the beginning. 32384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (FuncInfo.InsertPt != FuncInfo.MBB->end() && 32484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt->getOpcode() == TargetOpcode::EH_LABEL) 32584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 32684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 32784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 328ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosiervoid FastISel::removeDeadCode(MachineBasicBlock::iterator I, 329ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator E) { 330ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier assert (I && E && std::distance(I, E) > 0 && "Invalid iterator!"); 331ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier while (I != E) { 332ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineInstr *Dead = &*I; 333ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier ++I; 334ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier Dead->eraseFromParent(); 335fa785cb22d50c657eb08c762d627cd6aa96982f3Jan Wen Voung ++NumFastIselDead; 336ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 337ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 338ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier} 339ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 34076ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric ChristopherFastISel::SavePoint FastISel::enterLocalValueArea() { 34184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt; 34276ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DebugLoc OldDL = DL; 34384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman recomputeInsertPt(); 34476ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DL = DebugLoc(); 34576ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher SavePoint SP = { OldInsertPt, OldDL }; 34676ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher return SP; 34784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 34884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 34976ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christophervoid FastISel::leaveLocalValueArea(SavePoint OldInsertPt) { 35084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.InsertPt != FuncInfo.MBB->begin()) 35184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = llvm::prior(FuncInfo.InsertPt); 35284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 35384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Restore the previous insert position. 35476ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher FuncInfo.InsertPt = OldInsertPt.InsertPt; 35576ad43c6e1619ed4c087b8ccb2cd573eb9d7093eEric Christopher DL = OldInsertPt.DL; 35684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 35784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 358bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 359bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 360bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 36146510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBinaryOp(const User *I, unsigned ISDOpcode) { 362e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 363825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::Other || !VT.isSimple()) 364d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 365d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 366638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 367b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 368b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 369b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 370b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 371638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 372825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 373638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 374825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 3755dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 3765dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 37723b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), VT); 378638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 379638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 380638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 381d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 382fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // Check if the first operand is a constant, and handle it as "ri". At -O0, 383fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner // we don't have anything that canonicalizes operand order. 384fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(0))) 385fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (isa<Instruction>(I) && cast<Instruction>(I)->isCommutative()) { 386fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner unsigned Op1 = getRegForValue(I->getOperand(1)); 387fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner if (Op1 == 0) return false; 388fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner 389fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 390d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 391602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op1, 392602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op1IsKill, CI->getZExtValue(), 393602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner VT.getSimpleVT()); 394602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 395d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 396602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 397602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 398602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 399fff65b354f9895f5add84d99e0f62176f5d3f0f6Chris Lattner } 400d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 401d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 4023df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 403602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Op0 == 0) // Unhandled operand. Halt "fast" selection and bail. 404a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 405a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 406a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 407a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 408d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 409d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 410602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner uint64_t Imm = CI->getZExtValue(); 411d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 412f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner // Transform "sdiv exact X, 8" -> "sra X, 3". 413f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner if (ISDOpcode == ISD::SDIV && isa<BinaryOperator>(I) && 414f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner cast<BinaryOperator>(I)->isExact() && 415f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner isPowerOf2_64(Imm)) { 416f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner Imm = Log2_64(Imm); 417f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner ISDOpcode = ISD::SRA; 418f051c1a29dd040b4b5ca0c5696d47a9058f87481Chris Lattner } 419d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 420544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier // Transform "urem x, pow2" -> "and x, pow2-1". 421544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier if (ISDOpcode == ISD::UREM && isa<BinaryOperator>(I) && 422544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier isPowerOf2_64(Imm)) { 423544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier --Imm; 424544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier ISDOpcode = ISD::AND; 425544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier } 426544b9b426f0dfa1beef6dc3640607dee3ca1160eChad Rosier 427602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op0, 428602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Op0IsKill, Imm, VT.getSimpleVT()); 429602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (ResultReg == 0) return false; 430d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 431602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // We successfully emitted code for the given LLVM Instruction. 432602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner UpdateValueMap(I, ResultReg); 433602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return true; 434d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 435d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 43610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 43710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 438ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 439a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, Op0, Op0IsKill, CF); 440ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 441ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 4423df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 443ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 444ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 44510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 44610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 4473df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 448d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 449d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 450bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 451bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 452a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 453a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 454ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 4550f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 456a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, 457a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 458a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op1, Op1IsKill); 459bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 460bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 461bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 462bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 463bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 4648014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 4653df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 466bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 467bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 468bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 46946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectGetElementPtr(const User *I) { 4703df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 47183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 47283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 47383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 47483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 475a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool NIsKill = hasTrivialKill(I->getOperand(0)); 476a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 477478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Keep a running tab of the total offset to coalesce multiple N = N + Offset 478478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // into a single N = N + TotalOffset. 479478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t TotalOffs = 0; 480478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // FIXME: What's a good SWAG number for MaxOffs? 481478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier uint64_t MaxOffs = 2048; 482db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I->getOperand(0)->getType(); 483825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 48446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman for (GetElementPtrInst::const_op_iterator OI = I->op_begin()+1, 48546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman E = I->op_end(); OI != E; ++OI) { 48646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Idx = *OI; 487db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *StTy = dyn_cast<StructType>(Ty)) { 48883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 48983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 49083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 491478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs += TD.getStructLayout(StTy)->getElementOffset(Field); 492478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 493478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 494478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 495478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 496478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 497478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 498478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 499478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 50083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 50183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 50283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 50383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 50483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 50583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 50646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 507e368b460a206fafa0d31d5d059b1779b94f7df8cDan Gohman if (CI->isZero()) continue; 508478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // N = N + Offset 5096016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier TotalOffs += 510777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 511478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs >= MaxOffs) { 512478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 513478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 514478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 515478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 516478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier NIsKill = true; 517478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 518478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 519478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier continue; 520478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 521478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 522478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 52383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 52483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 52583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 526a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman NIsKill = true; 527478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier TotalOffs = 0; 52883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 529bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 53083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 531777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 532a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman std::pair<unsigned, bool> Pair = getRegForGEPIndex(Idx); 533a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IdxN = Pair.first; 534a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = Pair.second; 53583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 53683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 53783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 53883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 53980bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 540a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, IdxNIsKill, ElementSize, VT); 54180bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 54280bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 54380bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 544a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 54580bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 546a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_rr(VT, VT, ISD::ADD, N, NIsKill, IdxN, IdxNIsKill); 54783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 54883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 54983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 55083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 55183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 552478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (TotalOffs) { 553478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 554478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier if (N == 0) 555478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier // Unhandled operand. Halt "fast" selection and bail. 556478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier return false; 557478b06c9801f0b75c5216ce0886ac3d630d4fc7bChad Rosier } 55883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 55983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 5603df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 56183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 562bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 563bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 56446510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCall(const User *I) { 565a61e73bda5125c28e48b52e573d115370838596bDan Gohman const CallInst *Call = cast<CallInst>(I); 566a61e73bda5125c28e48b52e573d115370838596bDan Gohman 567a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Handle simple inline asms. 5689e15d658c99c3f0717cb83cc2bd2aa29abdbcdbbDan Gohman if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledValue())) { 569a61e73bda5125c28e48b52e573d115370838596bDan Gohman // Don't attempt to handle constraints. 570a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (!IA->getConstraintString().empty()) 571a61e73bda5125c28e48b52e573d115370838596bDan Gohman return false; 572a61e73bda5125c28e48b52e573d115370838596bDan Gohman 573a61e73bda5125c28e48b52e573d115370838596bDan Gohman unsigned ExtraInfo = 0; 574a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->hasSideEffects()) 575a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_HasSideEffects; 576a61e73bda5125c28e48b52e573d115370838596bDan Gohman if (IA->isAlignStack()) 577a61e73bda5125c28e48b52e573d115370838596bDan Gohman ExtraInfo |= InlineAsm::Extra_IsAlignStack; 578a61e73bda5125c28e48b52e573d115370838596bDan Gohman 579a61e73bda5125c28e48b52e573d115370838596bDan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 580a61e73bda5125c28e48b52e573d115370838596bDan Gohman TII.get(TargetOpcode::INLINEASM)) 581a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addExternalSymbol(IA->getAsmString().c_str()) 582a61e73bda5125c28e48b52e573d115370838596bDan Gohman .addImm(ExtraInfo); 583a61e73bda5125c28e48b52e573d115370838596bDan Gohman return true; 584a61e73bda5125c28e48b52e573d115370838596bDan Gohman } 585a61e73bda5125c28e48b52e573d115370838596bDan Gohman 586c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer MachineModuleInfo &MMI = FuncInfo.MF->getMMI(); 587c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer ComputeUsesVAFloatArgument(*Call, &MMI); 588c9c137b463b953fbf8942f655d67f6dc1a0f7965Michael J. Spencer 589a61e73bda5125c28e48b52e573d115370838596bDan Gohman const Function *F = Call->getCalledFunction(); 59033134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 59133134c4a75558288d663267c8991f6bd37a530afDan Gohman 5924183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Handle selected intrinsic function calls. 593832e4943598d821687cec79f512803c1ca03cff7Chris Lattner switch (F->getIntrinsicID()) { 59433134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 595aefd36bdda0dac496b8acabb25f0de29b370ebcaChad Rosier // At -O0 we don't care about the lifetime intrinsics. 5969b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_start: 5979b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher case Intrinsic::lifetime_end: 598fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier // The donothing intrinsic does, well, nothing. 599fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier case Intrinsic::donothing: 6009b5d6b860c7264e1dd8c5b757dfb4458dccdc27eEric Christopher return true; 601fd065bbed1d731b49b1b4a5c4c050ce461be80b4Chad Rosier 60292c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 603a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgDeclareInst *DI = cast<DbgDeclareInst>(Call); 60402f0dbd97a9bc01528aa12c2f260d928683ab411Devang Patel if (!DIVariable(DI->getVariable()).Verify() || 605bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher !FuncInfo.MF->getMMI().hasDebugInfo()) { 606bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 6077e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 608bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 60992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 61046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Address = DI->getAddress(); 611ccaea7dc0bbc75e5d4ee92fb8cc6af0f928d056fEric Christopher if (!Address || isa<UndefValue>(Address)) { 612bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 613dc9185657593b5c1db86cb95a04a68fc09194993Dale Johannesen return true; 614bb54d21495ba5ce60931bc872e3e3df67386cb97Eric Christopher } 6156fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel 6166fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Reg = 0; 6176fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Offset = 0; 6186fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (const Argument *Arg = dyn_cast<Argument>(Address)) { 6199aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel // Some arguments' frame index is recorded during argument lowering. 6209aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel Offset = FuncInfo.getArgumentFrameIndex(Arg); 6219aee335c23bec4f6d1b2cab3bca76231d7b0d556Devang Patel if (Offset) 622c415af225d9546a66ac9f7368a973e0be25b438dEric Christopher Reg = TRI.getFrameRegister(*FuncInfo.MF); 6234bafda9618f9dfa9edc8da08bb3001ef2d1a9b68Devang Patel } 6246fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (!Reg) 6258c5293c9556317143505c085cf428e11962e1273Eric Christopher Reg = lookUpRegForValue(Address); 6268c5293c9556317143505c085cf428e11962e1273Eric Christopher 62784364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we have a VLA that has a "use" in a metadata node that's then used 62884364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // here but it has no other uses, then we have a problem. E.g., 62984364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 63084364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // int foo (const int *x) { 63184364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // char a[*x]; 63284364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // return 0; 63384364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // } 63484364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // 63584364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // If we assign 'a' a vreg and fast isel later on has to use the selection 63684364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // DAG isel, it will want to copy the value to the vreg. However, there are 63784364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling // no uses, which goes counter to what selection DAG isel expects. 63884364a4e23e8ba2fe9332da99bcab31acc173381Bill Wendling if (!Reg && !Address->use_empty() && isa<Instruction>(Address) && 6398c5293c9556317143505c085cf428e11962e1273Eric Christopher (!isa<AllocaInst>(Address) || 6408c5293c9556317143505c085cf428e11962e1273Eric Christopher !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(Address)))) 6418c5293c9556317143505c085cf428e11962e1273Eric Christopher Reg = FuncInfo.InitializeRegForValue(Address); 642bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 6436fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (Reg) 644bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 6456fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel TII.get(TargetOpcode::DBG_VALUE)) 6466fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addReg(Reg, RegState::Debug).addImm(Offset) 6476fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addMetadata(DI->getVariable()); 6484476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher else 6494476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // We can't yet handle anything else here because it would require 6504476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher // generating code, thus altering codegen because of debug info. 6514476bae1b42bdc7d2c87c0524148d6ad9224357bEric Christopher DEBUG(dbgs() << "Dropping debug info for " << DI); 65233134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 65392c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 65445df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen case Intrinsic::dbg_value: { 655343b42e428079363ab09828734b2debfd7dbdc9eDale Johannesen // This form of DBG_VALUE is target-independent. 656a61e73bda5125c28e48b52e573d115370838596bDan Gohman const DbgValueInst *DI = cast<DbgValueInst>(Call); 657e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE); 65846510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *V = DI->getValue(); 65945df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen if (!V) { 66045df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // Currently the optimizer can produce this; insert an undef to 66145df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // help debugging. Probably the optimizer should not do this. 66284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 66384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(0U).addImm(DI->getOffset()) 66484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 66546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 6668594d429e02c688d428036f8563f09572da3fbffDevang Patel if (CI->getBitWidth() > 64) 6678594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6688594d429e02c688d428036f8563f09572da3fbffDevang Patel .addCImm(CI).addImm(DI->getOffset()) 6698594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 6706016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier else 6718594d429e02c688d428036f8563f09572da3fbffDevang Patel BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 6728594d429e02c688d428036f8563f09572da3fbffDevang Patel .addImm(CI->getZExtValue()).addImm(DI->getOffset()) 6738594d429e02c688d428036f8563f09572da3fbffDevang Patel .addMetadata(DI->getVariable()); 67446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 67584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 67684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addFPImm(CF).addImm(DI->getOffset()) 67784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 67845df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else if (unsigned Reg = lookUpRegForValue(V)) { 67984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 68084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Reg, RegState::Debug).addImm(DI->getOffset()) 68184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 68245df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else { 68345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // We can't yet handle anything else here because it would require 68445df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // generating code, thus altering codegen because of debug info. 685afeaae7a940ce16e7874af31f3e5e91d8ca89e19Devang Patel DEBUG(dbgs() << "Dropping debug info for " << DI); 686bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 68745df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen return true; 68845df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } 689d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman case Intrinsic::objectsize: { 690d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman ConstantInt *CI = cast<ConstantInt>(Call->getArgOperand(1)); 691d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned long long Res = CI->isZero() ? -1ULL : 0; 692d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman Constant *ResCI = ConstantInt::get(Call->getType(), Res); 693d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman unsigned ResultReg = getRegForValue(ResCI); 694d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman if (ResultReg == 0) 695d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return false; 696d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman UpdateValueMap(Call, ResultReg); 697d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman return true; 698d0118a2371f35faa6af97e67be69e1debc615c42Eli Friedman } 69933947b4391458ed3ba2d7e7c741968325cbffa1dChad Rosier case Intrinsic::expect: { 7004fde76db466a749200af555b0f400af873111767Chad Rosier unsigned ResultReg = getRegForValue(Call->getArgOperand(0)); 70133cdfe9f1943418604be5c800800394ae809fc4cNick Lewycky if (ResultReg == 0) 70233cdfe9f1943418604be5c800800394ae809fc4cNick Lewycky return false; 7034fde76db466a749200af555b0f400af873111767Chad Rosier UpdateValueMap(Call, ResultReg); 7044fde76db466a749200af555b0f400af873111767Chad Rosier return true; 70533947b4391458ed3ba2d7e7c741968325cbffa1dChad Rosier } 70633134c4a75558288d663267c8991f6bd37a530afDan Gohman } 7074183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman 70874af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // Usually, it does not make sense to initialize a value, 70974af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // make an unrelated function call and use the value, because 71074af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // it tends to be spilled on the stack. So, we move the pointer 71174af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // to the last local value to the beginning of the block, so that 71274af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // all the values which have already been materialized, 71374af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // appear after the call. It also makes sense to skip intrinsics 71474af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin // since they tend to be inlined. 715b704ffbb46cae716dc51bd8e6ba425c0a4949a47Pete Cooper if (!isa<IntrinsicInst>(Call)) 71674af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin flushLocalValueMap(); 71774af88a6661ad5185924bf39164fb4aa144d32cfIvan Krasin 7184183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // An arbitrary call. Bail. 71933134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 72033134c4a75558288d663267c8991f6bd37a530afDan Gohman} 72133134c4a75558288d663267c8991f6bd37a530afDan Gohman 72246510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCast(const User *I, unsigned Opcode) { 723e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 724e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 725bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 726825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 727825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 728d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 729d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 730bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 73176927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the destination type is legal. 732474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 73376927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 734474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 73576927d7303046058c627691bd45d6bff608f49f4Eli Friedman // Check if the source operand is legal. 736474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 73776927d7303046058c627691bd45d6bff608f49f4Eli Friedman return false; 738474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 7393df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 740d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 741d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 742d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 74314ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 744a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool InputRegIsKill = hasTrivialKill(I->getOperand(0)); 745a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 746d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 747d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 748d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 749a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputReg, InputRegIsKill); 750d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 751d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 752bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7533df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 754d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 755d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 756d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 75746510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBitCast(const User *I) { 758ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 759ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 7603df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 761a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 762a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 7633df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 764ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 765ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 766ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 767bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Bitcasts of other values become reg-reg copies or BITCAST operators. 7683d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund EVT SrcEVT = TLI.getValueType(I->getOperand(0)->getType()); 7693d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund EVT DstEVT = TLI.getValueType(I->getType()); 7703d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund if (SrcEVT == MVT::Other || DstEVT == MVT::Other || 7713d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund !TLI.isTypeLegal(SrcEVT) || !TLI.isTypeLegal(DstEVT)) 772d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 773d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 774bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 7753d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund MVT SrcVT = SrcEVT.getSimpleVT(); 7763d170e64ca1af491e2aa58f882f93b8e8111eef8Patrik Hagglund MVT DstVT = DstEVT.getSimpleVT(); 7773df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 778ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 779ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 780d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 781a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 782a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 783bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 784ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 785ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 786a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund if (SrcVT == DstVT) { 78744d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 78844d23825d61d530b8d562329ec8fc2d4f843bb8dCraig Topper const TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 789e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen // Don't attempt a cross-class copy. It will likely fail. 790e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen if (SrcClass == DstClass) { 791e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg = createResultReg(DstClass); 792e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 793e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg).addReg(Op0); 794e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen } 795ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 796bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 797bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If the reg-reg copy failed, select a BITCAST opcode. 798ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 799a61b17c18a67f1b3faef2f2108379c4337ce9bb7Patrik Hagglund ResultReg = FastEmit_r(SrcVT, DstVT, ISD::BITCAST, Op0, Op0IsKill); 800bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 801ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 802d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 803bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 8043df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 805d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 806d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 807d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 8083df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 80946510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectInstruction(const Instruction *I) { 810e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // Just before the terminator instruction, insert instructions to 811e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // feed PHI nodes in successor blocks. 812e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (isa<TerminatorInst>(I)) 813e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (!HandlePHINodesInSuccessorBlocks(I->getParent())) 814e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman return false; 815e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman 8168ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = I->getDebugLoc(); 8178ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman 818ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier MachineBasicBlock::iterator SavedInsertPt = FuncInfo.InsertPt; 819ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier 820982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson // As a special case, don't handle calls to builtin library functions that 821982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson // may be translated directly to target instructions. 822d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson if (const CallInst *Call = dyn_cast<CallInst>(I)) { 823d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson const Function *F = Call->getCalledFunction(); 824d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibFunc::Func Func; 825d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson if (F && !F->hasLocalLinkage() && F->hasName() && 826d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibInfo->getLibFunc(F->getName(), Func) && 827982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson LibInfo->hasOptimizedCodeGen(Func)) 828d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson return false; 829d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson } 830d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson 8316e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // First, try doing target-independent selection. 8327dbd34b199be8d053240a67cc1e81a04096af1c2Michael Ilseman if (SelectOperator(I, I->getOpcode())) { 833fa785cb22d50c657eb08c762d627cd6aa96982f3Jan Wen Voung ++NumFastIselSuccessIndependent; 8348ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8356e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8368ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 8376016a4a1627726b7419e1c95c6c3e67138100d23Chad Rosier // Remove dead code. However, ignore call instructions since we've flushed 838ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // the local value map and recomputed the insert point. 839ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (!isa<CallInst>(I)) { 840ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 841ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 842ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 843ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier } 8446e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8456e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // Next, try calling the target to attempt to handle the instruction. 846ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier SavedInsertPt = FuncInfo.InsertPt; 8478ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (TargetSelectInstruction(I)) { 848fa785cb22d50c657eb08c762d627cd6aa96982f3Jan Wen Voung ++NumFastIselSuccessTarget; 8498ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8506e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 8518ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 852ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier // Check for dead code and remove as necessary. 853ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier recomputeInsertPt(); 854ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier if (SavedInsertPt != FuncInfo.InsertPt) 855ae6f2cb1fc520aa56777dab1e7603aee9429f6ddChad Rosier removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 8566e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 8578ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 8586e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return false; 85940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 86040b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 861d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 862d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 863d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 864d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 8653bf912593301152b65accb9d9c37a95172f1df5aStuart HastingsFastISel::FastEmitBranch(MachineBasicBlock *MSucc, DebugLoc DL) { 86618112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher 867092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng if (FuncInfo.MBB->getBasicBlock()->size() > 1 && 868092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng FuncInfo.MBB->isLayoutSuccessor(MSucc)) { 86918112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // For more accurate line information if this is the only instruction 87018112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // in the block then emit it, otherwise we have the unconditional 87118112d83e7d54597bcd5870fb411c7997e02bc1eEric Christopher // fall-through case, which needs no instructions. 872d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 873d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 87484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.InsertBranch(*FuncInfo.MBB, MSucc, NULL, 87584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVector<MachineOperand, 0>(), DL); 876d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 87784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.MBB->addSuccessor(MSucc); 878d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 879d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 8803d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// SelectFNeg - Emit an FNeg operation. 8813d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// 8823d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohmanbool 88346510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectFNeg(const User *I) { 8843d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 8853d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (OpReg == 0) return false; 8863d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 887a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool OpRegIsKill = hasTrivialKill(I); 888a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 8894a215a13c3035a8818254b61267be77def4a2a37Dan Gohman // If the target has ISD::FNEG, use it. 8904a215a13c3035a8818254b61267be77def4a2a37Dan Gohman EVT VT = TLI.getValueType(I->getType()); 8914a215a13c3035a8818254b61267be77def4a2a37Dan Gohman unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 892a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::FNEG, OpReg, OpRegIsKill); 8934a215a13c3035a8818254b61267be77def4a2a37Dan Gohman if (ResultReg != 0) { 8944a215a13c3035a8818254b61267be77def4a2a37Dan Gohman UpdateValueMap(I, ResultReg); 8954a215a13c3035a8818254b61267be77def4a2a37Dan Gohman return true; 8964a215a13c3035a8818254b61267be77def4a2a37Dan Gohman } 8974a215a13c3035a8818254b61267be77def4a2a37Dan Gohman 8985e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // Bitcast the value to integer, twiddle the sign bit with xor, 8995e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // and then bitcast it back to floating-point. 9003d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (VT.getSizeInBits() > 64) return false; 9015e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 9025e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (!TLI.isTypeLegal(IntVT)) 9035e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 9045e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 9055e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 906bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, OpReg, OpRegIsKill); 9075e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntReg == 0) 9085e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 9095e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 910a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, 911a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntReg, /*Kill=*/true, 9125e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman UINT64_C(1) << (VT.getSizeInBits()-1), 9135e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman IntVT.getSimpleVT()); 9145e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntResultReg == 0) 9155e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 9165e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 9175e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 918bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, IntResultReg, /*Kill=*/true); 9193d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (ResultReg == 0) 9203d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return false; 9213d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 9223d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman UpdateValueMap(I, ResultReg); 9233d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return true; 9243d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman} 9253d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 92640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 9272586b8f9366aed5a1efa44d3f18d095511601642Eli FriedmanFastISel::SelectExtractValue(const User *U) { 9282586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U); 929a4c920db7a3620f365144eac9aaad7ca23062caaEli Friedman if (!EVI) 9302586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9312586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 932482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // Make sure we only try to handle extracts with a legal result. But also 933482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman // allow i1 because it's easy. 9342586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman EVT RealVT = TLI.getValueType(EVI->getType(), /*AllowUnknown=*/true); 9352586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (!RealVT.isSimple()) 9362586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9372586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman MVT VT = RealVT.getSimpleVT(); 938482feb33b2bba677d47bab859d9e1e95d67016bdEli Friedman if (!TLI.isTypeLegal(VT) && VT != MVT::i1) 9392586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return false; 9402586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9412586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman const Value *Op0 = EVI->getOperand(0); 942db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AggTy = Op0->getType(); 9432586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9442586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the base result register. 9452586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman unsigned ResultReg; 9462586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0); 9472586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman if (I != FuncInfo.ValueMap.end()) 9482586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = I->second; 9490b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else if (isa<Instruction>(Op0)) 9502586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg = FuncInfo.InitializeRegForValue(Op0); 9510b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman else 9520b4d96baecf3fe6af0fd45ba815bacf91a017f97Eli Friedman return false; // fast-isel can't handle aggregate constants at the moment 9532586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9542586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman // Get the actual result register, which is an offset from the base register. 955fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad unsigned VTIndex = ComputeLinearIndex(AggTy, EVI->getIndices()); 9562586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9572586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman SmallVector<EVT, 4> AggValueVTs; 9582586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ComputeValueVTs(TLI, AggTy, AggValueVTs); 9592586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9602586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman for (unsigned i = 0; i < VTIndex; i++) 9612586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman ResultReg += TLI.getNumRegisters(FuncInfo.Fn->getContext(), AggValueVTs[i]); 9622586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9632586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman UpdateValueMap(EVI, ResultReg); 9642586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return true; 9652586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman} 9662586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 9672586b8f9366aed5a1efa44d3f18d095511601642Eli Friedmanbool 96846510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectOperator(const User *I, unsigned Opcode) { 96940b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 970ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 971ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 972ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 973ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 974ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 975ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 976ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 9773d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman // FNeg is currently represented in LLVM IR as a special case of FSub. 9783d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (BinaryOperator::isFNeg(I)) 9793d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return SelectFNeg(I); 980ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 981ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 982ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 983ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 984ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 9853df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 9863df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 9873df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 9883df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 9893df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 9903df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 9913df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 9923df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 9933df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 9943df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 9953df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 9963df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 9973df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 9983df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 9993df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 10003df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 10013df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 10023df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 10033df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 10043df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 10053df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 10063df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 10073df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 10083df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 10093df24e667f04a7003342b534310919abc9c87418Dan Gohman 10103df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 10113df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 10123df24e667f04a7003342b534310919abc9c87418Dan Gohman 10133df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 101446510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BranchInst *BI = cast<BranchInst>(I); 10153df24e667f04a7003342b534310919abc9c87418Dan Gohman 10163df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 101746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BasicBlock *LLVMSucc = BI->getSuccessor(0); 1018a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc]; 10193bf912593301152b65accb9d9c37a95172f1df5aStuart Hastings FastEmitBranch(MSucc, BI->getDebugLoc()); 10203df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 10219d5b41624003daf259b33fc953aa471049700353Owen Anderson } 10223df24e667f04a7003342b534310919abc9c87418Dan Gohman 10233df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 10243df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 10253df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 1026b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 1027b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1028087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 1029087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 1030087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 1031087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 10320586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 10330586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 1034a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I))) 10350586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 10360586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 10370586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 10380586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 1039bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 104033134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 104133134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 1042bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 10433df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 10443df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 10453df24e667f04a7003342b534310919abc9c87418Dan Gohman 10463df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 10473df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 10483df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 10493df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10503df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 10513df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 10523df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 10533df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10543df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 10553df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 10563df24e667f04a7003342b534310919abc9c87418Dan Gohman 10573df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 10583df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 1059e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 1060e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 10613df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 10623df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 10633df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 10643df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 10653df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 10663df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 10673df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 10683df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 10693df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1070d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 10712586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman case Instruction::ExtractValue: 10722586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman return SelectExtractValue(I); 10732586b8f9366aed5a1efa44d3f18d095511601642Eli Friedman 1074ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman case Instruction::PHI: 1075ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman llvm_unreachable("FastISel shouldn't visit PHI nodes!"); 1076ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman 10773df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 10783df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 10793df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 10803df24e667f04a7003342b534310919abc9c87418Dan Gohman } 1081b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1082b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1083d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob WilsonFastISel::FastISel(FunctionLoweringInfo &funcInfo, 1084d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson const TargetLibraryInfo *libInfo) 108584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman : FuncInfo(funcInfo), 1086a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MRI(FuncInfo.MF->getRegInfo()), 1087a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MFI(*FuncInfo.MF->getFrameInfo()), 1088a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MCP(*FuncInfo.MF->getConstantPool()), 1089a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman TM(FuncInfo.MF->getTarget()), 10903574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow TD(*TM.getDataLayout()), 109122bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 1092a7a0ed79012ea36f838239cf1d04959711aec2a9Dan Gohman TLI(*TM.getTargetLowering()), 1093d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson TRI(*TM.getRegisterInfo()), 1094d49edb7ab098fa0c82f59efbcf1b4eb2958f8dc3Bob Wilson LibInfo(libInfo) { 1095bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 1096bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 1097e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 1098e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 1099092e5e75661fdd5d54a748fb00fab59d21031268Evan Chengbool FastISel::FastLowerArguments() { 1100092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng return false; 1101092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng} 1102092e5e75661fdd5d54a748fb00fab59d21031268Evan Cheng 1103825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 11047c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned) { 1105b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1106b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1107b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1108825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 1109a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1110a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/) { 1111b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1112b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1113b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1114bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckunsigned FastISel::FastEmit_rr(MVT, MVT, 1115a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1116a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1117a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/) { 1118b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 1119b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1120b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 11217c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 112283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 112383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 112483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1125825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 112646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned, const ConstantFP * /*FPImm*/) { 112710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 112810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 112910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1130825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 1131a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1132a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 11330f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 1134d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 1135d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1136d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1137825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 1138a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 1139a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 114046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const ConstantFP * /*FPImm*/) { 114110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 114210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 114310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1144825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 11457c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, 1146a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 1147a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/, 1148d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 114983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 115083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 115183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 115283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 115383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 115483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 115583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 11567c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 1157a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1158a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm, MVT ImmType) { 1159602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // If this is a multiply by a power of two, emit this as a shift left. 1160602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if (Opcode == ISD::MUL && isPowerOf2_64(Imm)) { 1161602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Opcode = ISD::SHL; 1162602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm = Log2_64(Imm); 1163090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner } else if (Opcode == ISD::UDIV && isPowerOf2_64(Imm)) { 1164090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner // div x, 8 -> srl x, 3 1165090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Opcode = ISD::SRL; 1166090ca9108b35a60e8b97b67987d00cf47a383dbaChris Lattner Imm = Log2_64(Imm); 1167602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner } 1168d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1169602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // Horrible hack (to be removed), check to make sure shift amounts are 1170602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner // in-range. 1171602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner if ((Opcode == ISD::SHL || Opcode == ISD::SRA || Opcode == ISD::SRL) && 1172602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner Imm >= VT.getSizeInBits()) 1173602fc0681726155942907debee1fe0b8b44ffc1bChris Lattner return 0; 1174d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 117583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 1176a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Op0IsKill, Imm); 117783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 117883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 11790f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 1180b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman if (MaterialReg == 0) { 1181b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // This is a bit ugly/slow, but failing here means falling out of 1182b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman // fast-isel, which would be very slow. 1183db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *ITy = IntegerType::get(FuncInfo.Fn->getContext(), 1184b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman VT.getSizeInBits()); 1185b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman MaterialReg = getRegForValue(ConstantInt::get(ITy, Imm)); 1186b2b03fc2fa87cb5604dd8ec2e8476d051186cdb3Eli Friedman } 1187a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_rr(VT, VT, Opcode, 1188a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 1189a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman MaterialReg, /*Kill=*/true); 1190d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1191d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1192d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 1193d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 119483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 119583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1196b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 119777ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 1198d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1199e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1200b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 120184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg); 1202b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1203b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1204b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1205b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 1206b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1207a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill) { 1208d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1209e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1210b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 12115960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 121284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 121384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 12145960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 121584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 121684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 1217e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1218e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12195960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 12205960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 1221b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1222b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1223b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1224b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 1225b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1226a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1227a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill) { 1228d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1229e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1230b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 12315960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 123284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1233a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1234a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 12355960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 123684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1237a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1238a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 1239e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1240e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12415960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1242b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1243b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1244d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1245d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Andersonunsigned FastISel::FastEmitInst_rrr(unsigned MachineInstOpcode, 1246d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson const TargetRegisterClass *RC, 1247d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op0, bool Op0IsKill, 1248d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op1, bool Op1IsKill, 1249d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned Op2, bool Op2IsKill) { 1250d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson unsigned ResultReg = createResultReg(RC); 1251e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1252d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1253d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson if (II.getNumDefs() >= 1) 1254d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1255d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1256d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1257d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1258d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson else { 1259d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1260d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 1261d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op1, Op1IsKill * RegState::Kill) 1262d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson .addReg(Op2, Op2IsKill * RegState::Kill); 1263d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1264d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1265d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson } 1266d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson return ResultReg; 1267d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson} 1268d71867a8f4b1ab6ab8cc8f5b1a732184ec5bad1bOwen Anderson 1269d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 1270d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1271a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1272a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1273d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1274e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1275d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12765960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 127784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1278a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1279a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 12805960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 128184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1282a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1283a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1284e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1285e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 12865960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1287d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1288d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1289d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 12902ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Andersonunsigned FastISel::FastEmitInst_rii(unsigned MachineInstOpcode, 12912ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson const TargetRegisterClass *RC, 12922ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned Op0, bool Op0IsKill, 12932ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson uint64_t Imm1, uint64_t Imm2) { 12942ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned ResultReg = createResultReg(RC); 1295e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 12962ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 12972ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson if (II.getNumDefs() >= 1) 12982ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 12992ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 13002ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 13012ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 13022ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson else { 13032ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 13042ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 13052ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 13062ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 13072ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 13082ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 13092ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson } 13102ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson return ResultReg; 13112ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson} 13122ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 131310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 131410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 1315a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1316a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const ConstantFP *FPImm) { 131710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 1318e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 131910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 13205960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 132184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1322a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1323a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 13245960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 132584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1326a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1327a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 1328e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1329e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13305960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 133110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 133210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 133310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1334d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 1335d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1336a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1337a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill, 1338a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1339d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1340e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1341d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 13425960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 134384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1344a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1345a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1346a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 13475960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 134884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1349a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1350a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1351a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1352e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1353e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13545960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1355d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1356d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 13576d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 135868f25571e759c1fcf2da206109647259f49f7416Manman Renunsigned FastISel::FastEmitInst_rrii(unsigned MachineInstOpcode, 135968f25571e759c1fcf2da206109647259f49f7416Manman Ren const TargetRegisterClass *RC, 136068f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned Op0, bool Op0IsKill, 136168f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned Op1, bool Op1IsKill, 136268f25571e759c1fcf2da206109647259f49f7416Manman Ren uint64_t Imm1, uint64_t Imm2) { 136368f25571e759c1fcf2da206109647259f49f7416Manman Ren unsigned ResultReg = createResultReg(RC); 136468f25571e759c1fcf2da206109647259f49f7416Manman Ren const MCInstrDesc &II = TII.get(MachineInstOpcode); 136568f25571e759c1fcf2da206109647259f49f7416Manman Ren 136668f25571e759c1fcf2da206109647259f49f7416Manman Ren if (II.getNumDefs() >= 1) 136768f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 136868f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op0, Op0IsKill * RegState::Kill) 136968f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op1, Op1IsKill * RegState::Kill) 137068f25571e759c1fcf2da206109647259f49f7416Manman Ren .addImm(Imm1).addImm(Imm2); 137168f25571e759c1fcf2da206109647259f49f7416Manman Ren else { 137268f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 137368f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op0, Op0IsKill * RegState::Kill) 137468f25571e759c1fcf2da206109647259f49f7416Manman Ren .addReg(Op1, Op1IsKill * RegState::Kill) 137568f25571e759c1fcf2da206109647259f49f7416Manman Ren .addImm(Imm1).addImm(Imm2); 137668f25571e759c1fcf2da206109647259f49f7416Manman Ren BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 137768f25571e759c1fcf2da206109647259f49f7416Manman Ren ResultReg).addReg(II.ImplicitDefs[0]); 137868f25571e759c1fcf2da206109647259f49f7416Manman Ren } 137968f25571e759c1fcf2da206109647259f49f7416Manman Ren return ResultReg; 138068f25571e759c1fcf2da206109647259f49f7416Manman Ren} 138168f25571e759c1fcf2da206109647259f49f7416Manman Ren 13826d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 13836d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 13846d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 13856d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 1386e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1387bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 13885960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 138984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg).addImm(Imm); 13905960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 139184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm); 1392e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1393e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 13945960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 13956d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 1396b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 13978970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1398d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Andersonunsigned FastISel::FastEmitInst_ii(unsigned MachineInstOpcode, 1399d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson const TargetRegisterClass *RC, 1400d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson uint64_t Imm1, uint64_t Imm2) { 1401d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson unsigned ResultReg = createResultReg(RC); 1402e837dead3c8dc3445ef6a0e2322179c57e264a13Evan Cheng const MCInstrDesc &II = TII.get(MachineInstOpcode); 1403d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1404d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson if (II.getNumDefs() >= 1) 1405d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1406d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson .addImm(Imm1).addImm(Imm2); 1407d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson else { 1408d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm1).addImm(Imm2); 1409d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1410d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 1411d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson } 1412d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson return ResultReg; 1413d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson} 1414d74ea775af55782e3b0d5b10fa7602f8822a2f72Owen Anderson 1415825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 1416a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1417a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint32_t Idx) { 1418536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 14190bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Op0) && 14200bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen "Cannot yet extract from physregs"); 1421ee0d5d4398fb855c6674da94d902ef45e944f375Jakob Stoklund Olesen const TargetRegisterClass *RC = MRI.getRegClass(Op0); 1422ee0d5d4398fb855c6674da94d902ef45e944f375Jakob Stoklund Olesen MRI.constrainRegClass(Op0, TRI.getSubClassWithSubReg(RC, Idx)); 142384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, 142484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman DL, TII.get(TargetOpcode::COPY), ResultReg) 14250bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen .addReg(Op0, getKillRegState(Op0IsKill), Idx); 14268970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 14278970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 142814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 142914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 143014ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 1431a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill) { 1432a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op0, Op0IsKill, 1); 143314ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1434f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1435f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 1436f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Emit code to ensure constants are copied into registers when needed. 1437f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Remember the virtual registers that need to be added to the Machine PHI 1438f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// nodes as input. We cannot just directly add them, because expansion 1439f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// might result in multiple MBB's for one BB. As such, the start of the 1440f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// BB might correspond to a different MBB than the end. 1441f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohmanbool FastISel::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) { 1442f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const TerminatorInst *TI = LLVMBB->getTerminator(); 1443f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1444f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled; 1445a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size(); 1446f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1447f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Check successor nodes' PHI nodes that expect a constant to be available 1448f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // from this block. 1449f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 1450f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const BasicBlock *SuccBB = TI->getSuccessor(succ); 1451f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!isa<PHINode>(SuccBB->begin())) continue; 1452a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 1453f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1454f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // If this terminator has multiple identical successors (common for 1455f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // switches), only handle each succ once. 1456f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!SuccsHandled.insert(SuccMBB)) continue; 1457f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1458f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 1459f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1460f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // At this point we know that there is a 1-1 correspondence between LLVM PHI 1461f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // nodes and Machine PHI nodes, but the incoming operands have not been 1462f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // emitted yet. 1463f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (BasicBlock::const_iterator I = SuccBB->begin(); 1464f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1465fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1466f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Ignore dead phi's. 1467f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (PN->use_empty()) continue; 1468f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1469f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Only handle legal types. Two interesting things to note here. First, 1470f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // by bailing out early, we may leave behind some dead instructions, 1471f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its 14727a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // own moves. Second, this check is necessary because FastISel doesn't 147389496d0eb73ab8771b27b3d9c1db6492d8eefc3aDan Gohman // use CreateRegs to create registers, so it always creates 1474f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // exactly one register for each non-void instruction. 1475f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true); 1476f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (VT == MVT::Other || !TLI.isTypeLegal(VT)) { 14772f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier // Handle integer promotions, though, because they're common and easy. 14782f2d1d7ec0a0178c76c29a13ab39d3f33d9b097bChad Rosier if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 1479f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT); 1480f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman else { 1481a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1482f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1483f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1484f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1485f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1486f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1487f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1488fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // Set the DebugLoc for the copy. Prefer the location of the operand 1489fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // if there is one; use the location of the PHI otherwise. 1490fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = PN->getDebugLoc(); 1491fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman if (const Instruction *Inst = dyn_cast<Instruction>(PHIOp)) 1492fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = Inst->getDebugLoc(); 1493fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1494f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman unsigned Reg = getRegForValue(PHIOp); 1495f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (Reg == 0) { 1496a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1497f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1498f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1499a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); 1500fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = DebugLoc(); 1501f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1502f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1503f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1504f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return true; 1505f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman} 1506