FastISel.cpp revision 3574eca1b02600bac4e625297f4ecf745f4c4f32
1f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//===-- FastISel.cpp - Implementation of the FastISel class ---------------===// 2f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 3f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// The LLVM Compiler Infrastructure 4f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 5f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// This file is distributed under the University of Illinois Open Source 6f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// License. See LICENSE.TXT for details. 7f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 8f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//===----------------------------------------------------------------------===// 9f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 10f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// This file contains the implementation of the FastISel class. 11f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 12f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// "Fast" instruction selection is designed to emit very poor code quickly. 13f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// Also, it is not designed to be able to do much lowering, so most illegal 14f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// types (e.g. i64 on 32-bit targets) and operations are not supported. It is 15f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// also not intended to be able to do much optimization, except in a few cases 16f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// where doing optimizations reduces overall compile time. For example, folding 17f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// constants into immediate fields is often done, because it's cheap and it 18f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// reduces the number of instructions later phases have to examine. 19f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 20f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// "Fast" instruction selection is able to fail gracefully and transfer 21f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// control to the SelectionDAG selector for operations that it doesn't 22f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// support. In many cases, this allows us to avoid duplicating a lot of 23f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// the complicated lowering logic that SelectionDAG currently has. 24f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 25f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// The intended use for "fast" instruction selection is "-O0" mode 26f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// compilation, where the quality of the generated code is irrelevant when 27f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// weighed against the speed at which the code can be generated. Also, 28f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// at -O0, the LLVM optimizers are not running, and this makes the 29f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// compile time of codegen a much higher portion of the overall compile 30f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// time. Despite its limitations, "fast" instruction selection is able to 31f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// handle enough code on its own to provide noticeable overall speedups 32f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// in -O0 compiles. 33f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 34f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// Basic operations are supported in a target-independent way, by reading 35f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// the same instruction descriptions that the SelectionDAG selector reads, 36f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// and identifying simple arithmetic operations that can be directly selected 37f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// from simple operators. More complicated operations currently require 38f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// target-specific code. 39f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// 40f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//===----------------------------------------------------------------------===// 41f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 42f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#define DEBUG_TYPE "isel" 43f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/DebugInfo.h" 44f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Function.h" 45f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/GlobalVariable.h" 46f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Instructions.h" 47f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/IntrinsicInst.h" 48f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Operator.h" 49f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/CodeGen/Analysis.h" 50f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/CodeGen/FastISel.h" 51f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/CodeGen/FunctionLoweringInfo.h" 52c1a4ab9c313d8a3d12007f2dbef7b5a6fa4ac2efSteve Block#include "llvm/CodeGen/MachineInstrBuilder.h" 53f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/CodeGen/MachineModuleInfo.h" 54f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/CodeGen/MachineRegisterInfo.h" 55f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Analysis/Loads.h" 56f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/DataLayout.h" 57c1a4ab9c313d8a3d12007f2dbef7b5a6fa4ac2efSteve Block#include "llvm/Target/TargetInstrInfo.h" 58f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Target/TargetLibraryInfo.h" 59f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Target/TargetLowering.h" 60f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Target/TargetMachine.h" 61f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Support/ErrorHandling.h" 62f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/Support/Debug.h" 63f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "llvm/ADT/Statistic.h" 64f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectusing namespace llvm; 65f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 66f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectSTATISTIC(NumFastIselSuccessIndependent, "Number of insts selected by " 67f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "target-independent selector"); 68f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectSTATISTIC(NumFastIselSuccessTarget, "Number of insts selected by " 69f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "target-specific selector"); 70f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectSTATISTIC(NumFastIselDead, "Number of dead insts removed on failure"); 71f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 72f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// startNewBlock - Set the current block to which generated machine 73f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// instructions will be appended, and clear the local CSE map. 74f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// 75f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid FastISel::startNewBlock() { 76f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LocalValueMap.clear(); 77f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 78f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EmitStartPt = 0; 79f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 80f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Advance the emit start point past any EH_LABEL instructions. 81f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MachineBasicBlock::iterator 82f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project I = FuncInfo.MBB->begin(), E = FuncInfo.MBB->end(); 83f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project while (I != E && I->getOpcode() == TargetOpcode::EH_LABEL) { 84f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EmitStartPt = I; 85f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ++I; 86f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 87f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LastLocalValue = EmitStartPt; 88f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 89f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 90f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid FastISel::flushLocalValueMap() { 91f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LocalValueMap.clear(); 92f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LastLocalValue = EmitStartPt; 93f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project recomputeInsertPt(); 94f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 95f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 96f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool FastISel::hasTrivialKill(const Value *V) const { 97f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Don't consider constants or arguments to have trivial kills. 98f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const Instruction *I = dyn_cast<Instruction>(V); 99f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!I) 100f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 101f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // No-op casts are trivially coalesced by fast-isel. 10357ea16e87e319bf71176dd8e8d12abe84f13d2e6Andy McFadden if (const CastInst *Cast = dyn_cast<CastInst>(I)) 104f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) && 105f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project !hasTrivialKill(Cast->getOperand(0))) 106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 108f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // GEPs with all zero indices are trivially coalesced by fast-isel. 109f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) 110e8e1ddccd616e8226b7cc1e4e9fdb327429249e8Steve Block if (GEP->hasAllZeroIndices() && !hasTrivialKill(GEP->getOperand(0))) 111f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 113f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Only instructions with a single use in the same basic block are considered 114f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // to have trivial kills. 115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return I->hasOneUse() && 116f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project !(I->getOpcode() == Instruction::BitCast || 117f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project I->getOpcode() == Instruction::PtrToInt || 118f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project I->getOpcode() == Instruction::IntToPtr) && 119f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project cast<Instruction>(*I->use_begin())->getParent() == I->getParent(); 120f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 121f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::getRegForValue(const Value *V) { 123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 124f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Don't handle non-simple values in FastISel. 125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!RealVT.isSimple()) 126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 127f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 128f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Ignore illegal types. We must do this before looking up the value 129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // in ValueMap because Arguments are given virtual registers regardless 130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // of whether FastISel can handle them. 131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MVT VT = RealVT.getSimpleVT(); 132f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!TLI.isTypeLegal(VT)) { 133f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Handle integer promotions, though, because they're common and easy. 134d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 135d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 136f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 137f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 138f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 139f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Look up the value to see if we already have a register for it. 141f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Reg = lookUpRegForValue(V); 142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Reg != 0) 143f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return Reg; 144f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 145f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // In bottom-up mode, just create the virtual register which will be used 146f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // to hold the value. It will be materialized later. 147f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (isa<Instruction>(V) && 148f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (!isa<AllocaInst>(V) || 14960fc806b679a3655c228b4093058c59941a49cfeDan Bornstein !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(V)))) 150f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return FuncInfo.InitializeRegForValue(V); 151f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 152d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro SavePoint SaveInsertPt = enterLocalValueArea(); 153d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro 154f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Materialize the value in a register. Emit any instructions in the 155f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // local value area. 156f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = materializeRegForValue(V, VT); 157f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 158f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project leaveLocalValueArea(SaveInsertPt); 159d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro 160d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro return Reg; 161f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 162f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 163f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// materializeRegForValue - Helper for getRegForValue. This function is 164f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// called when the value isn't already available in a register and must 16560fc806b679a3655c228b4093058c59941a49cfeDan Bornstein/// be materialized with new instructions. 166364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayesunsigned FastISel::materializeRegForValue(const Value *V, MVT VT) { 167f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Reg = 0; 168f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 169f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 170f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (CI->getValue().getActiveBits() <= 64) 171f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 172f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (isa<AllocaInst>(V)) { 173f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 174f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (isa<ConstantPointerNull>(V)) { 175f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Translate this as an integer zero so that it can be 176f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // local-CSE'd with actual integer zeros. 177f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = 178f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 179f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 180f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (CF->isNullValue()) { 181f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = TargetMaterializeFloatZero(CF); 182f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Try to emit the constant directly. 184f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 185f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 186f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 18703aa70ae413c6c5fb2ee4424afd30608bfb465eeBarry Hayes if (!Reg) { 188f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Try to emit the constant by using an integer constant with a cast. 189f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const APFloat &Flt = CF->getValueAPF(); 190f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT IntVT = TLI.getPointerTy(); 191f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 192f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t x[2]; 193f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint32_t IntBitWidth = IntVT.getSizeInBits(); 194f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool isExact; 195f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 196f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project APFloat::rmTowardZero, &isExact); 197f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (isExact) { 198f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project APInt IntVal(IntBitWidth, x); 199f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 200f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned IntegerReg = 201f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IntegerReg != 0) 203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, 204f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IntegerReg, /*Kill=*/false); 205f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 206056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro } 207f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (const Operator *Op = dyn_cast<Operator>(V)) { 208f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!SelectOperator(Op, Op->getOpcode())) 209056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro if (!isa<Instruction>(Op) || 210f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project !TargetSelectInstruction(cast<Instruction>(Op))) 211f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 212f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = lookUpRegForValue(Op); 213f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (isa<UndefValue>(V)) { 214f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = createResultReg(TLI.getRegClassFor(VT)); 215f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 216f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TII.get(TargetOpcode::IMPLICIT_DEF), Reg); 217f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 218f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 219f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // If target-independent code couldn't handle the value, give target-specific 220f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // code a try. 221f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!Reg && isa<Constant>(V)) 222f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = TargetMaterializeConstant(cast<Constant>(V)); 223f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 224f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Don't cache constant materializations in the general ValueMap. 225f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // To do so would require tracking what uses they dominate. 226f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Reg != 0) { 227f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LocalValueMap[V] = Reg; 228f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LastLocalValue = MRI.getVRegDef(Reg); 229b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes } 230f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return Reg; 231f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 232f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 233f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::lookUpRegForValue(const Value *V) { 234f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Look up the value to see if we already have a register for it. We 235f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // cache values defined by Instructions across blocks, and other values 236f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // only locally. This is because Instructions already have the SSA 237f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // def-dominates-use requirement enforced. 238f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 239f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (I != FuncInfo.ValueMap.end()) 240f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return I->second; 241f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return LocalValueMap[V]; 242f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 24381f3ebe03cd33c9003641084bece0604ee68bf88Barry Hayes 244f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// UpdateValueMap - Update the value map to include the new mapping for this 245f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// instruction, or insert an extra copy to get the result in a previous 246f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// determined register. 247f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// NOTE: This is only necessary because we might select a block that uses 248b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes/// a value before we select the block that defines the value. It might be 249f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// possible to fix this by selecting blocks in reverse postorder. 250f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid FastISel::UpdateValueMap(const Value *I, unsigned Reg, unsigned NumRegs) { 251f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!isa<Instruction>(I)) { 252b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes LocalValueMap[I] = Reg; 253f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 254062bf509a77fce9dfcb7e7b2e401cf2a124d83d5Steve Block } 255f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 256f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned &AssignedReg = FuncInfo.ValueMap[I]; 257f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (AssignedReg == 0) 258f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Use the new register. 259f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project AssignedReg = Reg; 260f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else if (Reg != AssignedReg) { 261f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Arrange for uses of AssignedReg to be replaced by uses of Reg. 262f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (unsigned i = 0; i < NumRegs; i++) 263f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project FuncInfo.RegFixups[AssignedReg+i] = Reg+i; 264f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 265f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project AssignedReg = Reg; 266f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 267f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 268f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 269f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstd::pair<unsigned, bool> FastISel::getRegForGEPIndex(const Value *Idx) { 270f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned IdxN = getRegForValue(Idx); 271f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IdxN == 0) 272f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 273f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return std::pair<unsigned, bool>(0, false); 274f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 275f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool IdxNIsKill = hasTrivialKill(Idx); 276f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 277f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // If the index is smaller or larger than intptr_t, truncate or extend it. 278f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MVT PtrVT = TLI.getPointerTy(); 279f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 280d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (IdxVT.bitsLT(PtrVT)) { 281f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, 282f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxN, IdxNIsKill); 283f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxNIsKill = true; 284f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 285d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro else if (IdxVT.bitsGT(PtrVT)) { 286a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, 287f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxN, IdxNIsKill); 288f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxNIsKill = true; 289d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro } 290a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro return std::pair<unsigned, bool>(IdxN, IdxNIsKill); 291f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 292f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 293f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid FastISel::recomputeInsertPt() { 294f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (getLastLocalValue()) { 295f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project FuncInfo.InsertPt = getLastLocalValue(); 296d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro FuncInfo.MBB = FuncInfo.InsertPt->getParent(); 297d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro ++FuncInfo.InsertPt; 298f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else 299f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project FuncInfo.InsertPt = FuncInfo.MBB->getFirstNonPHI(); 300f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 301f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Now skip past any EH_LABELs, which must remain at the beginning. 302364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes while (FuncInfo.InsertPt != FuncInfo.MBB->end() && 303d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro FuncInfo.InsertPt->getOpcode() == TargetOpcode::EH_LABEL) 304f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ++FuncInfo.InsertPt; 305a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro} 306f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 307a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapirovoid FastISel::removeDeadCode(MachineBasicBlock::iterator I, 308364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes MachineBasicBlock::iterator E) { 309f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert (I && E && std::distance(I, E) > 0 && "Invalid iterator!"); 310364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes while (I != E) { 311364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes MachineInstr *Dead = &*I; 312364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes ++I; 313364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes Dead->eraseFromParent(); 314f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ++NumFastIselDead; 315f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 316d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro recomputeInsertPt(); 317f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 318a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro 319f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFastISel::SavePoint FastISel::enterLocalValueArea() { 320a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt; 321364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes DebugLoc OldDL = DL; 322f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project recomputeInsertPt(); 323364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes DL = DebugLoc(); 324364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes SavePoint SP = { OldInsertPt, OldDL }; 325364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes return SP; 326364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes} 327f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 328f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid FastISel::leaveLocalValueArea(SavePoint OldInsertPt) { 329f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (FuncInfo.InsertPt != FuncInfo.MBB->begin()) 330364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes LastLocalValue = llvm::prior(FuncInfo.InsertPt); 331364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes 332f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Restore the previous insert position. 333f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project FuncInfo.InsertPt = OldInsertPt.InsertPt; 334f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DL = OldInsertPt.DL; 335f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 336f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 337f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// SelectBinaryOp - Select and emit code for a binary operator instruction, 338f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// which has an opcode which directly corresponds to the given ISD opcode. 339f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// 340f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool FastISel::SelectBinaryOp(const User *I, unsigned ISDOpcode) { 341f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 342f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (VT == MVT::Other || !VT.isSimple()) 343f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled type. Halt "fast" selection and bail. 344f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 345f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 346f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We only handle legal types. For example, on x86-32 the instruction 347f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // selector contains all of the 64-bit instructions from x86-64, 348f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // under the assumption that i64 won't be used if the target doesn't 349f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // support it. 350f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!TLI.isTypeLegal(VT)) { 351f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // MVT::i1 is special. Allow AND, OR, or XOR because they 352f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // don't require additional zeroing, which makes them easy. 353f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (VT == MVT::i1 && 354f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 355f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISDOpcode == ISD::XOR)) 356f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project VT = TLI.getTypeToTransformTo(I->getContext(), VT); 357f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 358f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 359f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 360f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 361f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Check if the first operand is a constant, and handle it as "ri". At -O0, 362f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // we don't have anything that canonicalizes operand order. 363f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(0))) 364f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (isa<Instruction>(I) && cast<Instruction>(I)->isCommutative()) { 365f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op1 = getRegForValue(I->getOperand(1)); 366f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Op1 == 0) return false; 367f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 368f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 369f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 370f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op1, 371f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Op1IsKill, CI->getZExtValue(), 372f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project VT.getSimpleVT()); 373f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg == 0) return false; 374f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 375f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We successfully emitted code for the given LLVM Instruction. 376f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, ResultReg); 377f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 378f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 379f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 380f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 381f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0 = getRegForValue(I->getOperand(0)); 382f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Op0 == 0) // Unhandled operand. Halt "fast" selection and bail. 383f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 384f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 385f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 386f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 387f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Check if the second operand is a constant and handle it appropriately. 388f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 389f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t Imm = CI->getZExtValue(); 390f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 391f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Transform "sdiv exact X, 8" -> "sra X, 3". 392f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ISDOpcode == ISD::SDIV && isa<BinaryOperator>(I) && 393f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project cast<BinaryOperator>(I)->isExact() && 394f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project isPowerOf2_64(Imm)) { 395f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Imm = Log2_64(Imm); 396f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISDOpcode = ISD::SRA; 397b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes } 398f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 399f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Transform "urem x, pow2" -> "and x, pow2-1". 400f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ISDOpcode == ISD::UREM && isa<BinaryOperator>(I) && 401f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project isPowerOf2_64(Imm)) { 402f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project --Imm; 403f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISDOpcode = ISD::AND; 404f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 405f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 406f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = FastEmit_ri_(VT.getSimpleVT(), ISDOpcode, Op0, 407f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Op0IsKill, Imm, VT.getSimpleVT()); 408f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg == 0) return false; 409f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 410f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We successfully emitted code for the given LLVM Instruction. 411f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, ResultReg); 412f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 413f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 414f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 415f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Check if the second operand is a constant float. 416f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 417f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 418f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISDOpcode, Op0, Op0IsKill, CF); 419f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg != 0) { 420f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We successfully emitted code for the given LLVM Instruction. 421f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, ResultReg); 422f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 423f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 424f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 425f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 426f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op1 = getRegForValue(I->getOperand(1)); 427f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Op1 == 0) 428f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 429b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes return false; 430f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 431f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 432f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 433b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes // Now we have both operands in registers. Emit the instruction. 434f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 435062bf509a77fce9dfcb7e7b2e401cf2a124d83d5Steve Block ISDOpcode, 436f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Op0, Op0IsKill, 437f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Op1, Op1IsKill); 438f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg == 0) 439f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Target-specific code wasn't able to find a machine opcode for 440f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // the given ISD opcode and type. Halt "fast" selection and bail. 441f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 442f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 443f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We successfully emitted code for the given LLVM Instruction. 444f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, ResultReg); 445f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 446f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 447f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 448f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool FastISel::SelectGetElementPtr(const User *I) { 449f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned N = getRegForValue(I->getOperand(0)); 450f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (N == 0) 451f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 452f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 453f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 454f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool NIsKill = hasTrivialKill(I->getOperand(0)); 455f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 456f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Keep a running tab of the total offset to coalesce multiple N = N + Offset 457f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // into a single N = N + TotalOffset. 458f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t TotalOffs = 0; 459f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // FIXME: What's a good SWAG number for MaxOffs? 460f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t MaxOffs = 2048; 461f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Type *Ty = I->getOperand(0)->getType(); 462f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MVT VT = TLI.getPointerTy(); 463f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (GetElementPtrInst::const_op_iterator OI = I->op_begin()+1, 464f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project E = I->op_end(); OI != E; ++OI) { 465f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const Value *Idx = *OI; 466f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (StructType *StTy = dyn_cast<StructType>(Ty)) { 467f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 468f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Field) { 469f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // N = N + Offset 470f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TotalOffs += TD.getStructLayout(StTy)->getElementOffset(Field); 471d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (TotalOffs >= MaxOffs) { 472d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 473d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (N == 0) 474f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 475f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 476f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project NIsKill = true; 477f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TotalOffs = 0; 478f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 479f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 480f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Ty = StTy->getElementType(Field); 481f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 482f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Ty = cast<SequentialType>(Ty)->getElementType(); 483f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 484d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro // If this is a constant subscript, handle it quickly. 485d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 486d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (CI->isZero()) continue; 487f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // N = N + Offset 488f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TotalOffs += 489f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 490f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (TotalOffs >= MaxOffs) { 491f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 492d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (N == 0) 493d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro // Unhandled operand. Halt "fast" selection and bail. 494d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro return false; 495f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project NIsKill = true; 496f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TotalOffs = 0; 497f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 498d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro continue; 499d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro } 500d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (TotalOffs) { 501d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 502d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (N == 0) 503d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro // Unhandled operand. Halt "fast" selection and bail. 504d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro return false; 505d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro NIsKill = true; 506f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TotalOffs = 0; 507f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 508f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 509d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro // N = N + Idx * ElementSize; 510f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t ElementSize = TD.getTypeAllocSize(Ty); 511f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project std::pair<unsigned, bool> Pair = getRegForGEPIndex(Idx); 512d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro unsigned IdxN = Pair.first; 513f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool IdxNIsKill = Pair.second; 514f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IdxN == 0) 515f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 516f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 517f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 518f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ElementSize != 1) { 519f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, IdxNIsKill, ElementSize, VT); 520f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IdxN == 0) 521f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 522f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 523f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IdxNIsKill = true; 524f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 525f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project N = FastEmit_rr(VT, VT, ISD::ADD, N, NIsKill, IdxN, IdxNIsKill); 526f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (N == 0) 527f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 528f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 529f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 530f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 531f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (TotalOffs) { 532f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, TotalOffs, VT); 533f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (N == 0) 534f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled operand. Halt "fast" selection and bail. 535f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 536f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 537b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes 538f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We successfully emitted code for the given LLVM Instruction. 539f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, N); 540e8e1ddccd616e8226b7cc1e4e9fdb327429249e8Steve Block return true; 5416f3c21fb026d9489e5046416bcd5a84fa8e4615bDan Bornstein} 542f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 543f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool FastISel::SelectCall(const User *I) { 544f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const CallInst *Call = cast<CallInst>(I); 545f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 546f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Handle simple inline asms. 547f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledValue())) { 548f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Don't attempt to handle constraints. 549f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!IA->getConstraintString().empty()) 550f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 551f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 552f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ExtraInfo = 0; 553f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IA->hasSideEffects()) 554f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExtraInfo |= InlineAsm::Extra_HasSideEffects; 555f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IA->isAlignStack()) 556f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExtraInfo |= InlineAsm::Extra_IsAlignStack; 557f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 558f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 559f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TII.get(TargetOpcode::INLINEASM)) 560f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addExternalSymbol(IA->getAsmString().c_str()) 561f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(ExtraInfo); 562f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 563f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 564f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 565f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MachineModuleInfo &MMI = FuncInfo.MF->getMMI(); 566f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ComputeUsesVAFloatArgument(*Call, &MMI); 567f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 568f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const Function *F = Call->getCalledFunction(); 569f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!F) return false; 570f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 571f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Handle selected intrinsic function calls. 572f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project switch (F->getIntrinsicID()) { 573f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project default: break; 574f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // At -O0 we don't care about the lifetime intrinsics. 575f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Intrinsic::lifetime_start: 576f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Intrinsic::lifetime_end: 57781f3ebe03cd33c9003641084bece0604ee68bf88Barry Hayes // The donothing intrinsic does, well, nothing. 578f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Intrinsic::donothing: 579f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 580f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 581f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Intrinsic::dbg_declare: { 582b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes const DbgDeclareInst *DI = cast<DbgDeclareInst>(Call); 583f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!DIVariable(DI->getVariable()).Verify() || 584f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project !FuncInfo.MF->getMMI().hasDebugInfo()) { 585f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 586f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 587b4d5cf78d4731ffc6211d07a0d69c92c559ba792Elliott Hughes } 588f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 589062bf509a77fce9dfcb7e7b2e401cf2a124d83d5Steve Block const Value *Address = DI->getAddress(); 590f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!Address || isa<UndefValue>(Address)) { 591f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n"); 592f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 593f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 594f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 595f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Reg = 0; 596f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Offset = 0; 597f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (const Argument *Arg = dyn_cast<Argument>(Address)) { 598f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Some arguments' frame index is recorded during argument lowering. 599f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Offset = FuncInfo.getArgumentFrameIndex(Arg); 600f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Offset) 601f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = TRI.getFrameRegister(*FuncInfo.MF); 602f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 603f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!Reg) 604f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = lookUpRegForValue(Address); 605f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 606f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // If we have a VLA that has a "use" in a metadata node that's then used 607f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // here but it has no other uses, then we have a problem. E.g., 608f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // 609f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // int foo (const int *x) { 610f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // char a[*x]; 611f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // return 0; 612f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // } 613f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // 614f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // If we assign 'a' a vreg and fast isel later on has to use the selection 615f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // DAG isel, it will want to copy the value to the vreg. However, there are 616f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // no uses, which goes counter to what selection DAG isel expects. 617f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!Reg && !Address->use_empty() && isa<Instruction>(Address) && 618f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (!isa<AllocaInst>(Address) || 619f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(Address)))) 620f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Reg = FuncInfo.InitializeRegForValue(Address); 621f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 622f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Reg) 623f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 624f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TII.get(TargetOpcode::DBG_VALUE)) 625d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro .addReg(Reg, RegState::Debug).addImm(Offset) 626d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro .addMetadata(DI->getVariable()); 627d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro else 628f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // We can't yet handle anything else here because it would require 629f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // generating code, thus altering codegen because of debug info. 630f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DEBUG(dbgs() << "Dropping debug info for " << DI); 631f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 632f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 633f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Intrinsic::dbg_value: { 634f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // This form of DBG_VALUE is target-independent. 635d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro const DbgValueInst *DI = cast<DbgValueInst>(Call); 636d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE); 637f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const Value *V = DI->getValue(); 638f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!V) { 639f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Currently the optimizer can produce this; insert an undef to 640f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // help debugging. Probably the optimizer should not do this. 641f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 642f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(0U).addImm(DI->getOffset()) 643f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addMetadata(DI->getVariable()); 644d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 645d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro if (CI->getBitWidth() > 64) 646f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 647f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addCImm(CI).addImm(DI->getOffset()) 648f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addMetadata(DI->getVariable()); 649f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 650f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 651f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(CI->getZExtValue()).addImm(DI->getOffset()) 652f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addMetadata(DI->getVariable()); 653364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 654d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 655f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addFPImm(CF).addImm(DI->getOffset()) 656f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addMetadata(DI->getVariable()); 657f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (unsigned Reg = lookUpRegForValue(V)) { 658f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 659f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Reg, RegState::Debug).addImm(DI->getOffset()) 660f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addMetadata(DI->getVariable()); 661364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes } else { 662364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes // We can't yet handle anything else here because it would require 663f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // generating code, thus altering codegen because of debug info. 664f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DEBUG(dbgs() << "Dropping debug info for " << DI); 665f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 666f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 667d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro } 668f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Intrinsic::objectsize: { 669f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ConstantInt *CI = cast<ConstantInt>(Call->getArgOperand(1)); 670f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned long long Res = CI->isZero() ? -1ULL : 0; 671f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Constant *ResCI = ConstantInt::get(Call->getType(), Res); 672f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = getRegForValue(ResCI); 673f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg == 0) 674364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes return false; 675364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes UpdateValueMap(Call, ResultReg); 676f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 677f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 678f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 679f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 680364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes // Usually, it does not make sense to initialize a value, 681f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // make an unrelated function call and use the value, because 682f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // it tends to be spilled on the stack. So, we move the pointer 683f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // to the last local value to the beginning of the block, so that 684f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // all the values which have already been materialized, 685f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // appear after the call. It also makes sense to skip intrinsics 686f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // since they tend to be inlined. 687f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!isa<IntrinsicInst>(F)) 688f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project flushLocalValueMap(); 689f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 690f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // An arbitrary call. Bail. 6913c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 6923c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson} 6933c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 6943c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilsonbool FastISel::SelectCast(const User *I, unsigned Opcode) { 6953c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 6963c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson EVT DstVT = TLI.getValueType(I->getType()); 6973c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 698056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro if (SrcVT == MVT::Other || !SrcVT.isSimple() || 699056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro DstVT == MVT::Other || !DstVT.isSimple()) 700056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro // Unhandled type. Halt "fast" selection and bail. 7013c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7023c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7033c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // Check if the destination type is legal. 7043c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (!TLI.isTypeLegal(DstVT)) 7053c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 706056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro 707056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro // Check if the source operand is legal. 708056a24a06b2d166c8e8f380488253964db6d7dcdCarl Shapiro if (!TLI.isTypeLegal(SrcVT)) 7093c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7103c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7113c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson unsigned InputReg = getRegForValue(I->getOperand(0)); 7123c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (!InputReg) 7133c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // Unhandled operand. Halt "fast" selection and bail. 7143c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 71546bc4670d5ff653c3f132a2493efcbe434643b32Dan Bornstein 7163c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson bool InputRegIsKill = hasTrivialKill(I->getOperand(0)); 7173c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7183c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 7193c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson DstVT.getSimpleVT(), 7203c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson Opcode, 7213c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson InputReg, InputRegIsKill); 7223c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (!ResultReg) 7233c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7243c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 72546bc4670d5ff653c3f132a2493efcbe434643b32Dan Bornstein UpdateValueMap(I, ResultReg); 72646bc4670d5ff653c3f132a2493efcbe434643b32Dan Bornstein return true; 7273c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson} 7283c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7293c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilsonbool FastISel::SelectBitCast(const User *I) { 7303c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // If the bitcast doesn't change the type, just use the operand value. 7313c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (I->getType() == I->getOperand(0)->getType()) { 7323c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson unsigned Reg = getRegForValue(I->getOperand(0)); 7333c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (Reg == 0) 7343c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7353c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson UpdateValueMap(I, Reg); 7363c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return true; 7373c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson } 7383c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7393c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // Bitcasts of other values become reg-reg copies or BITCAST operators. 7403c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 7413c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson EVT DstVT = TLI.getValueType(I->getType()); 7423c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7433c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 7443c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson DstVT == MVT::Other || !DstVT.isSimple() || 7453c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 7463c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // Unhandled type. Halt "fast" selection and bail. 7473c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7483c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7493c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson unsigned Op0 = getRegForValue(I->getOperand(0)); 7503c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (Op0 == 0) 7513c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // Unhandled operand. Halt "fast" selection and bail. 7523c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7533c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7543c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 7553c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7563c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // First, try to perform the bitcast by inserting a reg-reg copy. 7573c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson unsigned ResultReg = 0; 7583c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) { 7593c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson const TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 7603c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson const TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 7613c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // Don't attempt a cross-class copy. It will likely fail. 7623c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (SrcClass == DstClass) { 7633c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson ResultReg = createResultReg(DstClass); 7643c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 7653c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson ResultReg).addReg(Op0); 7663c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson } 7673c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson } 76846bc4670d5ff653c3f132a2493efcbe434643b32Dan Bornstein 7693c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson // If the reg-reg copy failed, select a BITCAST opcode. 7703c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (!ResultReg) 77146bc4670d5ff653c3f132a2493efcbe434643b32Dan Bornstein ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), 7723c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson ISD::BITCAST, Op0, Op0IsKill); 7733c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7743c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson if (!ResultReg) 7753c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return false; 7763c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson 7773c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson UpdateValueMap(I, ResultReg); 7783c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson return true; 7793c6f4c012e0a314dc9f9f540b9374dbf530d03b0Jesse Wilson} 780b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson 781b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilsonbool 782b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse WilsonFastISel::SelectInstruction(const Instruction *I) { 783b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // Just before the terminator instruction, insert instructions to 784b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // feed PHI nodes in successor blocks. 785b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson if (isa<TerminatorInst>(I)) 786b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson if (!HandlePHINodesInSuccessorBlocks(I->getParent())) 787b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson return false; 788b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson 789b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson DL = I->getDebugLoc(); 790b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson 791b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson MachineBasicBlock::iterator SavedInsertPt = FuncInfo.InsertPt; 792a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro 793b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // As a special case, don't handle calls to builtin library functions that 794b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // may be translated directly to target instructions. 795b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson if (const CallInst *Call = dyn_cast<CallInst>(I)) { 796b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson const Function *F = Call->getCalledFunction(); 797b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson LibFunc::Func Func; 798b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson if (F && !F->hasLocalLinkage() && F->hasName() && 799b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson LibInfo->getLibFunc(F->getName(), Func) && 800a7323974309c3b81cfe342db635d0bf30f36ff62Carl Shapiro LibInfo->hasOptimizedCodeGen(Func)) 801b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson return false; 802b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson } 803b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson 804b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // First, try doing target-independent selection. 805b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson if (SelectOperator(I, I->getOpcode())) { 806b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson ++NumFastIselSuccessIndependent; 807b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson DL = DebugLoc(); 808b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson return true; 809b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson } 810b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // Remove dead code. However, ignore call instructions since we've flushed 811b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson // the local value map and recomputed the insert point. 812b8b838ff463efcf8cac28df159ed06fe4bdb089fJesse Wilson if (!isa<CallInst>(I)) { 813f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project recomputeInsertPt(); 814f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (SavedInsertPt != FuncInfo.InsertPt) 815f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 816f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 817f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 818f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Next, try calling the target to attempt to handle the instruction. 819f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project SavedInsertPt = FuncInfo.InsertPt; 820f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (TargetSelectInstruction(I)) { 821f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ++NumFastIselSuccessTarget; 822f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DL = DebugLoc(); 823f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 824d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro } 825d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro // Check for dead code and remove as necessary. 826d52d4b1e08009c57f1fdc6e13b90cb8948a60102Carl Shapiro recomputeInsertPt(); 827f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (SavedInsertPt != FuncInfo.InsertPt) 828f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project removeDeadCode(FuncInfo.InsertPt, SavedInsertPt); 829f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 830f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project DL = DebugLoc(); 831f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 832f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 833364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes 834364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes/// FastEmitBranch - Emit an unconditional branch to the given block, 835364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes/// unless it is the immediate (fall-through) successor, and update 836f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// the CFG. 837f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid 838f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFastISel::FastEmitBranch(MachineBasicBlock *MSucc, DebugLoc DL) { 839f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 840f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (FuncInfo.MBB->getBasicBlock()->size() > 1 && FuncInfo.MBB->isLayoutSuccessor(MSucc)) { 841f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // For more accurate line information if this is the only instruction 842f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // in the block then emit it, otherwise we have the unconditional 843f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // fall-through case, which needs no instructions. 844f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 845f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // The unconditional branch case. 846f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TII.InsertBranch(*FuncInfo.MBB, MSucc, NULL, 847f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project SmallVector<MachineOperand, 0>(), DL); 848f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 849f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project FuncInfo.MBB->addSuccessor(MSucc); 850f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 851f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 852f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// SelectFNeg - Emit an FNeg operation. 853f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// 8547cc095f8e3ec52ba94d91e1d327354f61236496aCarl Shapirobool 855f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFastISel::SelectFNeg(const User *I) { 856f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 857f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (OpReg == 0) return false; 858f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 859f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool OpRegIsKill = hasTrivialKill(I); 860f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 861f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // If the target has ISD::FNEG, use it. 862f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT VT = TLI.getValueType(I->getType()); 863f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 864f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISD::FNEG, OpReg, OpRegIsKill); 865f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg != 0) { 866f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, ResultReg); 867f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 868f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 869f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 870f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Bitcast the value to integer, twiddle the sign bit with xor, 871f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // and then bitcast it back to floating-point. 872f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (VT.getSizeInBits() > 64) return false; 873f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 874f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!TLI.isTypeLegal(IntVT)) 875f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 876f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 877f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 878f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISD::BITCAST, OpReg, OpRegIsKill); 879f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IntReg == 0) 880f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 881f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 882f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, 883f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IntReg, /*Kill=*/true, 884f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UINT64_C(1) << (VT.getSizeInBits()-1), 885f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IntVT.getSimpleVT()); 886f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (IntResultReg == 0) 887f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 888f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 889f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 890f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ISD::BITCAST, IntResultReg, /*Kill=*/true); 891f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg == 0) 892f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 893f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 894a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein UpdateValueMap(I, ResultReg); 895a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return true; 896f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 897f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 898f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool 899f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFastISel::SelectExtractValue(const User *U) { 900f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U); 901f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!EVI) 902a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return false; 903a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 904f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Make sure we only try to handle extracts with a legal result. But also 905a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // allow i1 because it's easy. 906a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein EVT RealVT = TLI.getValueType(EVI->getType(), /*AllowUnknown=*/true); 907d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham if (!RealVT.isSimple()) 908d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham return false; 909d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham MVT VT = RealVT.getSimpleVT(); 910a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein if (!TLI.isTypeLegal(VT) && VT != MVT::i1) 911a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return false; 912a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 913a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein const Value *Op0 = EVI->getOperand(0); 914a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein Type *AggTy = Op0->getType(); 915a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 916a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // Get the base result register. 917a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein unsigned ResultReg; 918a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0); 919a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein if (I != FuncInfo.ValueMap.end()) 920a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein ResultReg = I->second; 921a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein else if (isa<Instruction>(Op0)) 922a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein ResultReg = FuncInfo.InitializeRegForValue(Op0); 923a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein else 924a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return false; // fast-isel can't handle aggregate constants at the moment 925a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 926a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // Get the actual result register, which is an offset from the base register. 927a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein unsigned VTIndex = ComputeLinearIndex(AggTy, EVI->getIndices()); 928a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 929a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein SmallVector<EVT, 4> AggValueVTs; 930a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein ComputeValueVTs(TLI, AggTy, AggValueVTs); 931a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 932a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein for (unsigned i = 0; i < VTIndex; i++) 933a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein ResultReg += TLI.getNumRegisters(FuncInfo.Fn->getContext(), AggValueVTs[i]); 934a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 935a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein UpdateValueMap(EVI, ResultReg); 936a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return true; 937a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein} 938a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 939a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornsteinbool 940a9c49df6714b3a37b7a7d0522932e622be2b35acDan BornsteinFastISel::SelectOperator(const User *I, unsigned Opcode) { 941a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein switch (Opcode) { 942a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Add: 943a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::ADD); 944a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::FAdd: 945a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::FADD); 946a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Sub: 947a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::SUB); 948a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::FSub: 949a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // FNeg is currently represented in LLVM IR as a special case of FSub. 950a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein if (BinaryOperator::isFNeg(I)) 951a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectFNeg(I); 952a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::FSUB); 953a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Mul: 954a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::MUL); 955a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::FMul: 956a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::FMUL); 957a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::SDiv: 958a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::SDIV); 959a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::UDiv: 960a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::UDIV); 961a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::FDiv: 962a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::FDIV); 963a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::SRem: 964a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::SREM); 965a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::URem: 966a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::UREM); 967a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::FRem: 968a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::FREM); 969a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Shl: 970a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::SHL); 971a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::LShr: 972a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::SRL); 973a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::AShr: 974a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::SRA); 975a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::And: 976a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::AND); 977a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Or: 978a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::OR); 979a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Xor: 980a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectBinaryOp(I, ISD::XOR); 981a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 982a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::GetElementPtr: 983a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectGetElementPtr(I); 984a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 985a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Br: { 986a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein const BranchInst *BI = cast<BranchInst>(I); 987d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham 988a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein if (BI->isUnconditional()) { 989a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein const BasicBlock *LLVMSucc = BI->getSuccessor(0); 990a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc]; 991d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham FastEmitBranch(MSucc, BI->getDebugLoc()); 992d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham return true; 993d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham } 994d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham 995d3b112e1f9f8563e82f1c3d23dcb424a5f2189a7Raghu Gandham // Conditional branches are not handed yet. 996a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // Halt "fast" selection and bail. 997a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return false; 998a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein } 99992c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block 1000a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Unreachable: 1001a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // Nothing to emit. 1002a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return true; 1003a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 1004a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein case Instruction::Alloca: 1005a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein // FunctionLowering has the static-sized case covered. 1006a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I))) 1007a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return true; 1008f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1009f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Dynamic-sized alloca is not handled yet. 1010f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1011f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1012f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::Call: 1013f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCall(I); 1014f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1015f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::BitCast: 1016f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectBitCast(I); 1017f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1018f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::FPToSI: 1019f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCast(I, ISD::FP_TO_SINT); 1020f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::ZExt: 1021f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCast(I, ISD::ZERO_EXTEND); 1022f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::SExt: 1023f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCast(I, ISD::SIGN_EXTEND); 1024f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::Trunc: 1025f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCast(I, ISD::TRUNCATE); 1026f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::SIToFP: 1027a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return SelectCast(I, ISD::SINT_TO_FP); 102860fc806b679a3655c228b4093058c59941a49cfeDan Bornstein 10297cc095f8e3ec52ba94d91e1d327354f61236496aCarl Shapiro case Instruction::IntToPtr: // Deliberate fall-through. 1030f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::PtrToInt: { 1031f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 1032f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project EVT DstVT = TLI.getValueType(I->getType()); 1033f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (DstVT.bitsGT(SrcVT)) 1034f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCast(I, ISD::ZERO_EXTEND); 1035f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (DstVT.bitsLT(SrcVT)) 1036f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return SelectCast(I, ISD::TRUNCATE); 1037f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Reg = getRegForValue(I->getOperand(0)); 1038f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Reg == 0) return false; 1039f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project UpdateValueMap(I, Reg); 10407cc095f8e3ec52ba94d91e1d327354f61236496aCarl Shapiro return true; 1041f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1042f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1043f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::ExtractValue: 104460fc806b679a3655c228b4093058c59941a49cfeDan Bornstein return SelectExtractValue(I); 10457cc095f8e3ec52ba94d91e1d327354f61236496aCarl Shapiro 1046f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case Instruction::PHI: 1047f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project llvm_unreachable("FastISel shouldn't visit PHI nodes!"); 1048f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1049f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project default: 1050f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Unhandled instruction. Halt "fast" selection and bail. 1051f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1052f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1053f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1054f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1055f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFastISel::FastISel(FunctionLoweringInfo &funcInfo, 1056f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetLibraryInfo *libInfo) 1057f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project : FuncInfo(funcInfo), 1058f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MRI(FuncInfo.MF->getRegInfo()), 1059f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MFI(*FuncInfo.MF->getFrameInfo()), 1060f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MCP(*FuncInfo.MF->getConstantPool()), 1061f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TM(FuncInfo.MF->getTarget()), 1062f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TD(*TM.getDataLayout()), 1063c4ae06fe78cffa815225f9bcd26c19e6714db572Andy McFadden TII(*TM.getInstrInfo()), 1064f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TLI(*TM.getTargetLowering()), 1065f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project TRI(*TM.getRegisterInfo()), 1066f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LibInfo(libInfo) { 1067f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1068f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1069f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFastISel::~FastISel() {} 1070f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1071f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_(MVT, MVT, 1072f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned) { 1073f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1074fc75f3ed87b55d625b6054e18645da5cbdba31c6Carl Shapiro} 1075f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1076f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_r(MVT, MVT, 1077f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned, 1078a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein unsigned /*Op0*/, bool /*Op0IsKill*/) { 1079a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein return 0; 1080f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1081a9c49df6714b3a37b7a7d0522932e622be2b35acDan Bornstein 1082f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_rr(MVT, MVT, 1083f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned, 1084f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned /*Op0*/, bool /*Op0IsKill*/, 1085e8e1ddccd616e8226b7cc1e4e9fdb327429249e8Steve Block unsigned /*Op1*/, bool /*Op1IsKill*/) { 1086f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1087f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1088f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1089f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 1090f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1091f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1092f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1093f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_f(MVT, MVT, 1094f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned, const ConstantFP * /*FPImm*/) { 1095f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1096f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1097f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1098f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_ri(MVT, MVT, 1099f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned, 1100f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned /*Op0*/, bool /*Op0IsKill*/, 1101f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t /*Imm*/) { 1102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1103f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1104f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1105f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_rf(MVT, MVT, 1106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned, 1107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned /*Op0*/, bool /*Op0IsKill*/, 1108f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const ConstantFP * /*FPImm*/) { 1109f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1110f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1111f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmit_rri(MVT, MVT, 1113f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned, 1114f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned /*Op0*/, bool /*Op0IsKill*/, 1115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned /*Op1*/, bool /*Op1IsKill*/, 1116c4ae06fe78cffa815225f9bcd26c19e6714db572Andy McFadden uint64_t /*Imm*/) { 1117f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1118f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1119f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1120f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 1121f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// to emit an instruction with an immediate operand using FastEmit_ri. 1122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// If that fails, it materializes the immediate into a register and try 1123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/// FastEmit_rr instead. 1124062bf509a77fce9dfcb7e7b2e401cf2a124d83d5Steve Blockunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 1125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0, bool Op0IsKill, 1126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t Imm, MVT ImmType) { 1127f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // If this is a multiply by a power of two, emit this as a shift left. 1128f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (Opcode == ISD::MUL && isPowerOf2_64(Imm)) { 1129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Opcode = ISD::SHL; 1130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Imm = Log2_64(Imm); 1131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (Opcode == ISD::UDIV && isPowerOf2_64(Imm)) { 1132f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // div x, 8 -> srl x, 3 1133f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Opcode = ISD::SRL; 1134f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Imm = Log2_64(Imm); 1135f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1136f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1137f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // Horrible hack (to be removed), check to make sure shift amounts are 1138f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // in-range. 1139f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if ((Opcode == ISD::SHL || Opcode == ISD::SRA || Opcode == ISD::SRL) && 1140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Imm >= VT.getSizeInBits()) 1141f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return 0; 1142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1143f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // First check if immediate type is legal. If not, we can't use the ri form. 114492c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Op0IsKill, Imm); 1145f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ResultReg != 0) 1146f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1147f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 1148f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (MaterialReg == 0) { 1149f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // This is a bit ugly/slow, but failing here means falling out of 1150f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // fast-isel, which would be very slow. 1151f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project IntegerType *ITy = IntegerType::get(FuncInfo.Fn->getContext(), 1152f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project VT.getSizeInBits()); 1153f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MaterialReg = getRegForValue(ConstantInt::get(ITy, Imm)); 1154f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1155f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return FastEmit_rr(VT, VT, Opcode, 1156f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Op0, Op0IsKill, 1157f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MaterialReg, /*Kill=*/true); 1158f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1159f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1160f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 1161f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return MRI.createVirtualRegister(RC); 1162f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1163f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1164f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 1165f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetRegisterClass* RC) { 1166f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = createResultReg(RC); 1167f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const MCInstrDesc &II = TII.get(MachineInstOpcode); 1168f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1169f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg); 1170f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1171f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1172f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1173f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 1174f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetRegisterClass *RC, 1175f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0, bool Op0IsKill) { 1176f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = createResultReg(RC); 1177f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const MCInstrDesc &II = TII.get(MachineInstOpcode); 1178f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1179f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (II.getNumDefs() >= 1) 1180c1a4ab9c313d8a3d12007f2dbef7b5a6fa4ac2efSteve Block BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1181f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill); 1182d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein else { 1183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1184f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill); 1185f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1186f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ResultReg).addReg(II.ImplicitDefs[0]); 1187f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1188f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1189f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1190f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1191f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1192f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 1193f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetRegisterClass *RC, 1194f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0, bool Op0IsKill, 1195f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op1, bool Op1IsKill) { 1196f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = createResultReg(RC); 1197f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const MCInstrDesc &II = TII.get(MachineInstOpcode); 1198f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1199f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (II.getNumDefs() >= 1) 1200f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1201f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op1, Op1IsKill * RegState::Kill); 1203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else { 1204f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1205f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1206f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op1, Op1IsKill * RegState::Kill); 1207f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1208f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ResultReg).addReg(II.ImplicitDefs[0]); 1209f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1210f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1211f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1212f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1213f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmitInst_rrr(unsigned MachineInstOpcode, 1214f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetRegisterClass *RC, 1215f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0, bool Op0IsKill, 1216f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op1, bool Op1IsKill, 1217f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op2, bool Op2IsKill) { 1218f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = createResultReg(RC); 1219f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const MCInstrDesc &II = TII.get(MachineInstOpcode); 1220f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1221f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (II.getNumDefs() >= 1) 1222f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1223f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1224f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op1, Op1IsKill * RegState::Kill) 1225f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op2, Op2IsKill * RegState::Kill); 1226f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else { 1227f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1228f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1229f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op1, Op1IsKill * RegState::Kill) 1230f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op2, Op2IsKill * RegState::Kill); 1231f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1232f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ResultReg).addReg(II.ImplicitDefs[0]); 1233f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1234f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1235f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1236f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1237f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 1238f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetRegisterClass *RC, 1239f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0, bool Op0IsKill, 1240f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t Imm) { 1241f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = createResultReg(RC); 1242f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const MCInstrDesc &II = TII.get(MachineInstOpcode); 1243f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1244f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (II.getNumDefs() >= 1) 1245f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1246f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1247f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(Imm); 1248f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else { 1249f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1250f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1251f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(Imm); 1252f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1253f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ResultReg).addReg(II.ImplicitDefs[0]); 1254f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1255f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1256f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1257f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1258f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectunsigned FastISel::FastEmitInst_rii(unsigned MachineInstOpcode, 1259f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const TargetRegisterClass *RC, 1260f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned Op0, bool Op0IsKill, 1261f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project uint64_t Imm1, uint64_t Imm2) { 1262f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unsigned ResultReg = createResultReg(RC); 1263f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const MCInstrDesc &II = TII.get(MachineInstOpcode); 1264f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1265f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (II.getNumDefs() >= 1) 1266f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1267f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1268f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(Imm1) 1269f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(Imm2); 1270f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else { 1271f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1272f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addReg(Op0, Op0IsKill * RegState::Kill) 1273f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(Imm1) 1274f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project .addImm(Imm2); 1275f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1276f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ResultReg).addReg(II.ImplicitDefs[0]); 1277f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1278f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ResultReg; 1279} 1280 1281unsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 1282 const TargetRegisterClass *RC, 1283 unsigned Op0, bool Op0IsKill, 1284 const ConstantFP *FPImm) { 1285 unsigned ResultReg = createResultReg(RC); 1286 const MCInstrDesc &II = TII.get(MachineInstOpcode); 1287 1288 if (II.getNumDefs() >= 1) 1289 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1290 .addReg(Op0, Op0IsKill * RegState::Kill) 1291 .addFPImm(FPImm); 1292 else { 1293 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1294 .addReg(Op0, Op0IsKill * RegState::Kill) 1295 .addFPImm(FPImm); 1296 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1297 ResultReg).addReg(II.ImplicitDefs[0]); 1298 } 1299 return ResultReg; 1300} 1301 1302unsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 1303 const TargetRegisterClass *RC, 1304 unsigned Op0, bool Op0IsKill, 1305 unsigned Op1, bool Op1IsKill, 1306 uint64_t Imm) { 1307 unsigned ResultReg = createResultReg(RC); 1308 const MCInstrDesc &II = TII.get(MachineInstOpcode); 1309 1310 if (II.getNumDefs() >= 1) 1311 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1312 .addReg(Op0, Op0IsKill * RegState::Kill) 1313 .addReg(Op1, Op1IsKill * RegState::Kill) 1314 .addImm(Imm); 1315 else { 1316 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1317 .addReg(Op0, Op0IsKill * RegState::Kill) 1318 .addReg(Op1, Op1IsKill * RegState::Kill) 1319 .addImm(Imm); 1320 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1321 ResultReg).addReg(II.ImplicitDefs[0]); 1322 } 1323 return ResultReg; 1324} 1325 1326unsigned FastISel::FastEmitInst_rrii(unsigned MachineInstOpcode, 1327 const TargetRegisterClass *RC, 1328 unsigned Op0, bool Op0IsKill, 1329 unsigned Op1, bool Op1IsKill, 1330 uint64_t Imm1, uint64_t Imm2) { 1331 unsigned ResultReg = createResultReg(RC); 1332 const MCInstrDesc &II = TII.get(MachineInstOpcode); 1333 1334 if (II.getNumDefs() >= 1) 1335 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1336 .addReg(Op0, Op0IsKill * RegState::Kill) 1337 .addReg(Op1, Op1IsKill * RegState::Kill) 1338 .addImm(Imm1).addImm(Imm2); 1339 else { 1340 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1341 .addReg(Op0, Op0IsKill * RegState::Kill) 1342 .addReg(Op1, Op1IsKill * RegState::Kill) 1343 .addImm(Imm1).addImm(Imm2); 1344 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1345 ResultReg).addReg(II.ImplicitDefs[0]); 1346 } 1347 return ResultReg; 1348} 1349 1350unsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 1351 const TargetRegisterClass *RC, 1352 uint64_t Imm) { 1353 unsigned ResultReg = createResultReg(RC); 1354 const MCInstrDesc &II = TII.get(MachineInstOpcode); 1355 1356 if (II.getNumDefs() >= 1) 1357 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg).addImm(Imm); 1358 else { 1359 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm); 1360 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1361 ResultReg).addReg(II.ImplicitDefs[0]); 1362 } 1363 return ResultReg; 1364} 1365 1366unsigned FastISel::FastEmitInst_ii(unsigned MachineInstOpcode, 1367 const TargetRegisterClass *RC, 1368 uint64_t Imm1, uint64_t Imm2) { 1369 unsigned ResultReg = createResultReg(RC); 1370 const MCInstrDesc &II = TII.get(MachineInstOpcode); 1371 1372 if (II.getNumDefs() >= 1) 1373 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1374 .addImm(Imm1).addImm(Imm2); 1375 else { 1376 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm1).addImm(Imm2); 1377 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1378 ResultReg).addReg(II.ImplicitDefs[0]); 1379 } 1380 return ResultReg; 1381} 1382 1383unsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 1384 unsigned Op0, bool Op0IsKill, 1385 uint32_t Idx) { 1386 unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 1387 assert(TargetRegisterInfo::isVirtualRegister(Op0) && 1388 "Cannot yet extract from physregs"); 1389 const TargetRegisterClass *RC = MRI.getRegClass(Op0); 1390 MRI.constrainRegClass(Op0, TRI.getSubClassWithSubReg(RC, Idx)); 1391 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, 1392 DL, TII.get(TargetOpcode::COPY), ResultReg) 1393 .addReg(Op0, getKillRegState(Op0IsKill), Idx); 1394 return ResultReg; 1395} 1396 1397/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 1398/// with all but the least significant bit set to zero. 1399unsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill) { 1400 return FastEmit_ri(VT, VT, ISD::AND, Op0, Op0IsKill, 1); 1401} 1402 1403/// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 1404/// Emit code to ensure constants are copied into registers when needed. 1405/// Remember the virtual registers that need to be added to the Machine PHI 1406/// nodes as input. We cannot just directly add them, because expansion 1407/// might result in multiple MBB's for one BB. As such, the start of the 1408/// BB might correspond to a different MBB than the end. 1409bool FastISel::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) { 1410 const TerminatorInst *TI = LLVMBB->getTerminator(); 1411 1412 SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled; 1413 unsigned OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size(); 1414 1415 // Check successor nodes' PHI nodes that expect a constant to be available 1416 // from this block. 1417 for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 1418 const BasicBlock *SuccBB = TI->getSuccessor(succ); 1419 if (!isa<PHINode>(SuccBB->begin())) continue; 1420 MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 1421 1422 // If this terminator has multiple identical successors (common for 1423 // switches), only handle each succ once. 1424 if (!SuccsHandled.insert(SuccMBB)) continue; 1425 1426 MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 1427 1428 // At this point we know that there is a 1-1 correspondence between LLVM PHI 1429 // nodes and Machine PHI nodes, but the incoming operands have not been 1430 // emitted yet. 1431 for (BasicBlock::const_iterator I = SuccBB->begin(); 1432 const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1433 1434 // Ignore dead phi's. 1435 if (PN->use_empty()) continue; 1436 1437 // Only handle legal types. Two interesting things to note here. First, 1438 // by bailing out early, we may leave behind some dead instructions, 1439 // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its 1440 // own moves. Second, this check is necessary because FastISel doesn't 1441 // use CreateRegs to create registers, so it always creates 1442 // exactly one register for each non-void instruction. 1443 EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true); 1444 if (VT == MVT::Other || !TLI.isTypeLegal(VT)) { 1445 // Handle integer promotions, though, because they're common and easy. 1446 if (VT == MVT::i1 || VT == MVT::i8 || VT == MVT::i16) 1447 VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT); 1448 else { 1449 FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1450 return false; 1451 } 1452 } 1453 1454 const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1455 1456 // Set the DebugLoc for the copy. Prefer the location of the operand 1457 // if there is one; use the location of the PHI otherwise. 1458 DL = PN->getDebugLoc(); 1459 if (const Instruction *Inst = dyn_cast<Instruction>(PHIOp)) 1460 DL = Inst->getDebugLoc(); 1461 1462 unsigned Reg = getRegForValue(PHIOp); 1463 if (Reg == 0) { 1464 FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1465 return false; 1466 } 1467 FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); 1468 DL = DebugLoc(); 1469 } 1470 } 1471 1472 return true; 1473} 1474