FastISel.cpp revision 2ce5bf188dfa4329eb246df6011dd1edde5a5979
13b172f1c018a093d0dae3105324d782103fcda6dDan Gohman//===-- FastISel.cpp - Implementation of the FastISel class ---------------===// 2b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 3b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// The LLVM Compiler Infrastructure 4b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 5b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// This file is distributed under the University of Illinois Open Source 6b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// License. See LICENSE.TXT for details. 7b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 8b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman//===----------------------------------------------------------------------===// 9b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 10b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// This file contains the implementation of the FastISel class. 11b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman// 125ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// "Fast" instruction selection is designed to emit very poor code quickly. 135ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// Also, it is not designed to be able to do much lowering, so most illegal 1444d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// types (e.g. i64 on 32-bit targets) and operations are not supported. It is 1544d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// also not intended to be able to do much optimization, except in a few cases 1644d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// where doing optimizations reduces overall compile time. For example, folding 1744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// constants into immediate fields is often done, because it's cheap and it 1844d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// reduces the number of instructions later phases have to examine. 195ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 205ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// "Fast" instruction selection is able to fail gracefully and transfer 215ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// control to the SelectionDAG selector for operations that it doesn't 2244d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// support. In many cases, this allows us to avoid duplicating a lot of 235ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// the complicated lowering logic that SelectionDAG currently has. 245ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 255ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// The intended use for "fast" instruction selection is "-O0" mode 265ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// compilation, where the quality of the generated code is irrelevant when 2744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// weighed against the speed at which the code can be generated. Also, 285ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// at -O0, the LLVM optimizers are not running, and this makes the 295ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// compile time of codegen a much higher portion of the overall compile 3044d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// time. Despite its limitations, "fast" instruction selection is able to 315ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// handle enough code on its own to provide noticeable overall speedups 325ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// in -O0 compiles. 335ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 345ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// Basic operations are supported in a target-independent way, by reading 355ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// the same instruction descriptions that the SelectionDAG selector reads, 365ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// and identifying simple arithmetic operations that can be directly selected 3744d2a983b76a2a923e34f3162c960443425cb296Chris Lattner// from simple operators. More complicated operations currently require 385ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// target-specific code. 395ec9efd61bc4214c787287409498e8b78f28c922Dan Gohman// 40b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman//===----------------------------------------------------------------------===// 41b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 4233134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/Function.h" 4333134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/GlobalVariable.h" 446f2766d59744bb3d48867f3151643eac7111e773Dan Gohman#include "llvm/Instructions.h" 4533134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/IntrinsicInst.h" 46b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/FastISel.h" 474c3fd9f92f89810d659973d2666ab729758de64aDan Gohman#include "llvm/CodeGen/FunctionLoweringInfo.h" 48b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineInstrBuilder.h" 4933134c4a75558288d663267c8991f6bd37a530afDan Gohman#include "llvm/CodeGen/MachineModuleInfo.h" 50b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/CodeGen/MachineRegisterInfo.h" 5183489bb7700c69b7a4a8da59365c42d3f5c8129bDevang Patel#include "llvm/Analysis/DebugInfo.h" 527fbcc98f20c062273bf16ce9832f40e5b8a205c6Dan Gohman#include "llvm/Analysis/Loads.h" 5383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetData.h" 54b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman#include "llvm/Target/TargetInstrInfo.h" 5583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng#include "llvm/Target/TargetLowering.h" 56bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman#include "llvm/Target/TargetMachine.h" 57ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman#include "llvm/Support/ErrorHandling.h" 58afeaae7a940ce16e7874af31f3e5e91d8ca89e19Devang Patel#include "llvm/Support/Debug.h" 59b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanusing namespace llvm; 60b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 6184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// startNewBlock - Set the current block to which generated machine 6284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// instructions will be appended, and clear the local CSE map. 6384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman/// 6484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::startNewBlock() { 6584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LocalValueMap.clear(); 6684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 6784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Start out as null, meaining no local-value instructions have 6884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // been emitted. 6984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = 0; 7084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 7184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Advance the last local value past any EH_LABEL instructions. 7284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator 7384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman I = FuncInfo.MBB->begin(), E = FuncInfo.MBB->end(); 7484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (I != E && I->getOpcode() == TargetOpcode::EH_LABEL) { 7584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = I; 7684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++I; 7784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 7884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 7984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 80a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanbool FastISel::hasTrivialKill(const Value *V) const { 817f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Don't consider constants or arguments to have trivial kills. 82a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const Instruction *I = dyn_cast<Instruction>(V); 837f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (!I) 847f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 857f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 867f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // No-op casts are trivially coalesced by fast-isel. 877f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (const CastInst *Cast = dyn_cast<CastInst>(I)) 887f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman if (Cast->isNoopCast(TD.getIntPtrType(Cast->getContext())) && 897f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !hasTrivialKill(Cast->getOperand(0))) 907f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return false; 917f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman 927f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // Only instructions with a single use in the same basic block are considered 937f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman // to have trivial kills. 947f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman return I->hasOneUse() && 957f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman !(I->getOpcode() == Instruction::BitCast || 967f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::PtrToInt || 977f0d69555caab5f5468ddf74b5840f59c4c6fd83Dan Gohman I->getOpcode() == Instruction::IntToPtr) && 9896f1d8ebdd33b3f9bdb3b1163f36072c68599f42Gabor Greif cast<Instruction>(*I->use_begin())->getParent() == I->getParent(); 99a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman} 100a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 10146510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::getRegForValue(const Value *V) { 102e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT RealVT = TLI.getValueType(V->getType(), /*AllowUnknown=*/true); 1034fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman // Don't handle non-simple values in FastISel. 1044fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman if (!RealVT.isSimple()) 1054fd552880c9f42f117bd79929ea0179f99bd6bb7Dan Gohman return 0; 106821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 107c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Ignore illegal types. We must do this before looking up the value 108c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // in ValueMap because Arguments are given virtual registers regardless 109c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // of whether FastISel can handle them. 110825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = RealVT.getSimpleVT(); 111821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman if (!TLI.isTypeLegal(VT)) { 112825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // Promote MVT::i1 to a legal type though, because it's common and easy. 113825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1) 11423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(V->getContext(), VT).getSimpleVT(); 115821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman else 116821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman return 0; 117821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman } 118821164875706dd28e48c6cc3cea5c8ffa6e658d1Dan Gohman 119c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Look up the value to see if we already have a register for it. We 120c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // cache values defined by Instructions across blocks, and other values 121c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // only locally. This is because Instructions already have the SSA 1225c9cf19d1e7d044e786f03331bc3f004966a69d2Dan Gohman // def-dominates-use requirement enforced. 123a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 12484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (I != FuncInfo.ValueMap.end()) { 12584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman unsigned Reg = I->second; 12684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return Reg; 12784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 128c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned Reg = LocalValueMap[V]; 129c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (Reg != 0) 130c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman return Reg; 131c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 13297c94b8fc630b55e17a37481910810639e28d086Dan Gohman // In bottom-up mode, just create the virtual register which will be used 13397c94b8fc630b55e17a37481910810639e28d086Dan Gohman // to hold the value. It will be materialized later. 13484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (isa<Instruction>(V) && 13584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman (!isa<AllocaInst>(V) || 13684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman !FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(V)))) 13784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return FuncInfo.InitializeRegForValue(V); 13884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 139a10b8494a50108482302f6f077d72fbc76d776edDan Gohman SavePoint SaveInsertPt = enterLocalValueArea(); 14084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 14184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Materialize the value in a register. Emit any instructions in the 14284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // local value area. 14384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman Reg = materializeRegForValue(V, VT); 14484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 14584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman leaveLocalValueArea(SaveInsertPt); 14697c94b8fc630b55e17a37481910810639e28d086Dan Gohman 14784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman return Reg; 1481fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman} 1491fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 15044a2c3476bd15e03f294bae1b50016851f214f8dEric Christopher/// materializeRegForValue - Helper for getRegForValue. This function is 1511fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// called when the value isn't already available in a register and must 1521fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman/// be materialized with new instructions. 1531fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohmanunsigned FastISel::materializeRegForValue(const Value *V, MVT VT) { 1541fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman unsigned Reg = 0; 1551fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman 15646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 1572ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (CI->getValue().getActiveBits() <= 64) 1582ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = FastEmit_i(VT, VT, ISD::Constant, CI->getZExtValue()); 1590586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman } else if (isa<AllocaInst>(V)) { 1602ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeAlloca(cast<AllocaInst>(V)); 161205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<ConstantPointerNull>(V)) { 1621e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // Translate this as an integer zero so that it can be 1631e9e8c3bd5ac018296bddb21a2acb8c643303b39Dan Gohman // local-CSE'd with actual integer zeros. 1641d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Reg = 1651d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson getRegForValue(Constant::getNullValue(TD.getIntPtrType(V->getContext()))); 16646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 1674183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Try to emit the constant directly. 168104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); 169ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 170ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!Reg) { 1714183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Try to emit the constant by using an integer constant with a cast. 172ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman const APFloat &Flt = CF->getValueAPF(); 173e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 174ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 175ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint64_t x[2]; 176ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 17723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 17823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 17923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 18023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (isExact) { 1812ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman APInt IntVal(IntBitWidth, 2, x); 182ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 183e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson unsigned IntegerReg = 184eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getRegForValue(ConstantInt::get(V->getContext(), IntVal)); 1852ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman if (IntegerReg != 0) 186a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Reg = FastEmit_r(IntVT.getSimpleVT(), VT, ISD::SINT_TO_FP, 187a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntegerReg, /*Kill=*/false); 1882ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman } 189ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 19046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const Operator *Op = dyn_cast<Operator>(V)) { 19120d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!SelectOperator(Op, Op->getOpcode())) 19220d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman if (!isa<Instruction>(Op) || 19320d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman !TargetSelectInstruction(cast<Instruction>(Op))) 19420d4be151b54feb18aa1e5cc04033a4aa64137aeDan Gohman return 0; 19537db6cdaea47d0637bdbe624f7b10ff8f82928adDan Gohman Reg = lookUpRegForValue(Op); 196205d92589bc8c59d4bba9ddf89e0eb3c4d548cdaDan Gohman } else if (isa<UndefValue>(V)) { 197104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman Reg = createResultReg(TLI.getRegClassFor(VT)); 19884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 19984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.get(TargetOpcode::IMPLICIT_DEF), Reg); 200ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 201bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 202dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // If target-independent code couldn't handle the value, give target-specific 203dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman // code a try. 2046e6074508c2f781c3e52dfe0e301cb1c7f395a91Owen Anderson if (!Reg && isa<Constant>(V)) 2052ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman Reg = TargetMaterializeConstant(cast<Constant>(V)); 206bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 2072ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // Don't cache constant materializations in the general ValueMap. 2082ff7fd146159d97abe94391a33b4385abb06bbb0Dan Gohman // To do so would require tracking what uses they dominate. 20984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (Reg != 0) { 210dceffe66b9e73ce372ea11c0fc6975504eb8c31dDan Gohman LocalValueMap[V] = Reg; 21184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = MRI.getVRegDef(Reg); 21284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } 213104e4ce1629ea84736691bd1ee7867bdf90e8a2eDan Gohman return Reg; 214ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman} 215ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 21646510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::lookUpRegForValue(const Value *V) { 21759fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // Look up the value to see if we already have a register for it. We 21859fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // cache values defined by Instructions across blocks, and other values 21959fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng // only locally. This is because Instructions already have the SSA 2201fdc614bee2a324fcc210d1e46d9b6fca3ca324bDan Gohman // def-dominates-use requirement enforced. 221a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V); 222a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (I != FuncInfo.ValueMap.end()) 2233193a689db3de8640d412ccd9482301647359a4eDan Gohman return I->second; 22459fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng return LocalValueMap[V]; 22559fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng} 22659fbc80f6b3b5c71dfb84149f589625f7ed510e3Evan Cheng 227cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// UpdateValueMap - Update the value map to include the new mapping for this 228cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// instruction, or insert an extra copy to get the result in a previous 229cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// determined register. 230cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// NOTE: This is only necessary because we might select a block that uses 231cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// a value before we select the block that defines the value. It might be 232cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson/// possible to fix this by selecting blocks in reverse postorder. 23346510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned FastISel::UpdateValueMap(const Value *I, unsigned Reg) { 23440b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman if (!isa<Instruction>(I)) { 23540b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman LocalValueMap[I] = Reg; 236c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return Reg; 237c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner } 238bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 239a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned &AssignedReg = FuncInfo.ValueMap[I]; 240c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner if (AssignedReg == 0) 24184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Use the new register. 242c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner AssignedReg = Reg; 24336e3946ac2f30a0bda66538ef2b974b1c8fbdc97Chris Lattner else if (Reg != AssignedReg) { 24484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Arrange for uses of AssignedReg to be replaced by uses of Reg. 24584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.RegFixups[AssignedReg] = Reg; 24684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 24784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman AssignedReg = Reg; 24840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman } 24984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 250c5040ab6065d5c569a1af0848b6e672b22b174b7Chris Lattner return AssignedReg; 251cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson} 252cc54e76cc67bbc9badc024ab29053602769bd255Owen Anderson 253a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanstd::pair<unsigned, bool> FastISel::getRegForGEPIndex(const Value *Idx) { 254c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman unsigned IdxN = getRegForValue(Idx); 255c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman if (IdxN == 0) 256c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 257a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(0, false); 258a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 259a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = hasTrivialKill(Idx); 260c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 261c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman // If the index is smaller or larger than intptr_t, truncate or extend it. 262766b5efd99c01e26f00f22d81b57d1385b3d2ab0Owen Anderson MVT PtrVT = TLI.getPointerTy(); 263e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false); 264a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman if (IdxVT.bitsLT(PtrVT)) { 265a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::SIGN_EXTEND, 266a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 267a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 268a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 269a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman else if (IdxVT.bitsGT(PtrVT)) { 270a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_r(IdxVT.getSimpleVT(), PtrVT, ISD::TRUNCATE, 271a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN, IdxNIsKill); 272a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 273a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman } 274a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return std::pair<unsigned, bool>(IdxN, IdxNIsKill); 275c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman} 276c8a1a3c426209e9c7b35e279e1578a89edc40af6Dan Gohman 27784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohmanvoid FastISel::recomputeInsertPt() { 27884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (getLastLocalValue()) { 27984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = getLastLocalValue(); 280c6e59b71f50c7c77bc448a936dba8e84d90911e8Dan Gohman FuncInfo.MBB = FuncInfo.InsertPt->getParent(); 28184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 28284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman } else 28384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt = FuncInfo.MBB->getFirstNonPHI(); 28484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 28584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Now skip past any EH_LABELs, which must remain at the beginning. 28684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman while (FuncInfo.InsertPt != FuncInfo.MBB->end() && 28784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.InsertPt->getOpcode() == TargetOpcode::EH_LABEL) 28884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman ++FuncInfo.InsertPt; 28984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 29084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 291a10b8494a50108482302f6f077d72fbc76d776edDan GohmanFastISel::SavePoint FastISel::enterLocalValueArea() { 29284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman MachineBasicBlock::iterator OldInsertPt = FuncInfo.InsertPt; 293163f78ea4016d594d921154d8df1c9d746fb0ea8Dan Gohman DebugLoc OldDL = DL; 29484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman recomputeInsertPt(); 295a10b8494a50108482302f6f077d72fbc76d776edDan Gohman DL = DebugLoc(); 296163f78ea4016d594d921154d8df1c9d746fb0ea8Dan Gohman SavePoint SP = { OldInsertPt, OldDL }; 297a10b8494a50108482302f6f077d72fbc76d776edDan Gohman return SP; 29884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 29984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 300a10b8494a50108482302f6f077d72fbc76d776edDan Gohmanvoid FastISel::leaveLocalValueArea(SavePoint OldInsertPt) { 30184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.InsertPt != FuncInfo.MBB->begin()) 30284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman LastLocalValue = llvm::prior(FuncInfo.InsertPt); 30384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 30484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman // Restore the previous insert position. 305a10b8494a50108482302f6f077d72fbc76d776edDan Gohman FuncInfo.InsertPt = OldInsertPt.InsertPt; 306a10b8494a50108482302f6f077d72fbc76d776edDan Gohman DL = OldInsertPt.DL; 30784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman} 30884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman 309bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// SelectBinaryOp - Select and emit code for a binary operator instruction, 310bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// which has an opcode which directly corresponds to the given ISD opcode. 311bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman/// 31246510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBinaryOp(const User *I, unsigned ISDOpcode) { 313e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true); 314825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::Other || !VT.isSimple()) 315d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled type. Halt "fast" selection and bail. 316d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return false; 317638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman 318b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // We only handle legal types. For example, on x86-32 the instruction 319b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // selector contains all of the 64-bit instructions from x86-64, 320b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // under the assumption that i64 won't be used if the target doesn't 321b71fea248fd7cf9ab2c5737997a3dc5682948dc4Dan Gohman // support it. 322638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman if (!TLI.isTypeLegal(VT)) { 323825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson // MVT::i1 is special. Allow AND, OR, or XOR because they 324638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman // don't require additional zeroing, which makes them easy. 325825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (VT == MVT::i1 && 3265dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman (ISDOpcode == ISD::AND || ISDOpcode == ISD::OR || 3275dd9c2e9aea7294c184609aff7f2fe82eaea4eb0Dan Gohman ISDOpcode == ISD::XOR)) 32823b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson VT = TLI.getTypeToTransformTo(I->getContext(), VT); 329638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman else 330638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman return false; 331638c6830c6d0d6871065d2b00178ee4aa7d4d044Dan Gohman } 332d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 3333df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 334d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op0 == 0) 335a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman // Unhandled operand. Halt "fast" selection and bail. 336a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman return false; 337a7f2dff98e68ed8b2ac32f953768c04f26b52beaDan Gohman 338a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 339a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 340d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Check if the second operand is a constant and handle it appropriately. 341d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) { 342ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_ri(VT.getSimpleVT(), VT.getSimpleVT(), 343a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, Op0, Op0IsKill, 344a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman CI->getZExtValue()); 345ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 346ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 3473df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 348ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 349ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 350d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman } 351d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 35210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Check if the second operand is a constant float. 35310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ConstantFP *CF = dyn_cast<ConstantFP>(I->getOperand(1))) { 354ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = FastEmit_rf(VT.getSimpleVT(), VT.getSimpleVT(), 355a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, Op0, Op0IsKill, CF); 356ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (ResultReg != 0) { 357ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // We successfully emitted code for the given LLVM Instruction. 3583df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 359ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 360ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 36110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 36210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 3633df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op1 = getRegForValue(I->getOperand(1)); 364d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (Op1 == 0) 365d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 366bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 367bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 368a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op1IsKill = hasTrivialKill(I->getOperand(1)); 369a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 370ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Now we have both operands in registers. Emit the instruction. 3710f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned ResultReg = FastEmit_rr(VT.getSimpleVT(), VT.getSimpleVT(), 372a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISDOpcode, 373a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 374a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op1, Op1IsKill); 375bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman if (ResultReg == 0) 376bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // Target-specific code wasn't able to find a machine opcode for 377bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman // the given ISD opcode and type. Halt "fast" selection and bail. 378bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return false; 379bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 3808014e865800cc911697a4c0c42f077df9fcc9805Dan Gohman // We successfully emitted code for the given LLVM Instruction. 3813df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 382bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman return true; 383bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 384bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 38546510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectGetElementPtr(const User *I) { 3863df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned N = getRegForValue(I->getOperand(0)); 38783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 38883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 38983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 39083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 391a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool NIsKill = hasTrivialKill(I->getOperand(0)); 392a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 39383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng const Type *Ty = I->getOperand(0)->getType(); 394825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT VT = TLI.getPointerTy(); 39546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman for (GetElementPtrInst::const_op_iterator OI = I->op_begin()+1, 39646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman E = I->op_end(); OI != E; ++OI) { 39746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Idx = *OI; 39883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 39983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 40083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (Field) { 40183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Offset 40283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng uint64_t Offs = TD.getStructLayout(StTy)->getElementOffset(Field); 40383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // FIXME: This can be optimized by combining the add with a 40483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // subsequent one. 405a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, Offs, VT); 40683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 40783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 40883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 409a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman NIsKill = true; 41083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 41183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = StTy->getElementType(Field); 41283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } else { 41383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng Ty = cast<SequentialType>(Ty)->getElementType(); 41483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 41583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // If this is a constant subscript, handle it quickly. 41646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 417e368b460a206fafa0d31d5d059b1779b94f7df8cDan Gohman if (CI->isZero()) continue; 418bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck uint64_t Offs = 419777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands TD.getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 420a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_ri_(VT, ISD::ADD, N, NIsKill, Offs, VT); 42183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 42283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 42383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 424a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman NIsKill = true; 42583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng continue; 42683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 427bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 42883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // N = N + Idx * ElementSize; 429777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t ElementSize = TD.getTypeAllocSize(Ty); 430a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman std::pair<unsigned, bool> Pair = getRegForGEPIndex(Idx); 431a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IdxN = Pair.first; 432a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool IdxNIsKill = Pair.second; 43383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (IdxN == 0) 43483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 43583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 43683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 43780bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (ElementSize != 1) { 438a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxN = FastEmit_ri_(VT, ISD::MUL, IdxN, IdxNIsKill, ElementSize, VT); 43980bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman if (IdxN == 0) 44080bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman // Unhandled operand. Halt "fast" selection and bail. 44180bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman return false; 442a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IdxNIsKill = true; 44380bc6e2243b7ae99da42bf2e61df4ebccf8d8821Dan Gohman } 444a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman N = FastEmit_rr(VT, VT, ISD::ADD, N, NIsKill, IdxN, IdxNIsKill); 44583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (N == 0) 44683785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // Unhandled operand. Halt "fast" selection and bail. 44783785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return false; 44883785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 44983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng } 45083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 45183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // We successfully emitted code for the given LLVM Instruction. 4523df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, N); 45383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return true; 454bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman} 455bdedd4477331b3b0d28d74658baf05f675f2d195Dan Gohman 45646510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCall(const User *I) { 45746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Function *F = cast<CallInst>(I)->getCalledFunction(); 45833134c4a75558288d663267c8991f6bd37a530afDan Gohman if (!F) return false; 45933134c4a75558288d663267c8991f6bd37a530afDan Gohman 4604183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // Handle selected intrinsic function calls. 46133134c4a75558288d663267c8991f6bd37a530afDan Gohman unsigned IID = F->getIntrinsicID(); 46233134c4a75558288d663267c8991f6bd37a530afDan Gohman switch (IID) { 46333134c4a75558288d663267c8991f6bd37a530afDan Gohman default: break; 46492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling case Intrinsic::dbg_declare: { 46546510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const DbgDeclareInst *DI = cast<DbgDeclareInst>(I); 46602f0dbd97a9bc01528aa12c2f260d928683ab411Devang Patel if (!DIVariable(DI->getVariable()).Verify() || 467a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman !FuncInfo.MF->getMMI().hasDebugInfo()) 4687e1e31f467d87c834d8baf673929865907901313Devang Patel return true; 46992c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling 47046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *Address = DI->getAddress(); 4716fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (!Address || isa<UndefValue>(Address) || isa<AllocaInst>(Address)) 472dc9185657593b5c1db86cb95a04a68fc09194993Dale Johannesen return true; 4736fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel 4746fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Reg = 0; 4756fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel unsigned Offset = 0; 4766fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (const Argument *Arg = dyn_cast<Argument>(Address)) { 4776fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (Arg->hasByValAttr()) { 4786fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel // Byval arguments' frame index is recorded during argument lowering. 4796fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel // Use this info directly. 4806fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel Offset = FuncInfo.getByValArgumentFrameIndex(Arg); 4816fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (Offset) 4826fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel Reg = TRI.getFrameRegister(*FuncInfo.MF); 483bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 4844bafda9618f9dfa9edc8da08bb3001ef2d1a9b68Devang Patel } 4856fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (!Reg) 4866fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel Reg = getRegForValue(Address); 487bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 4886fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel if (Reg) 489bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, 4906fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel TII.get(TargetOpcode::DBG_VALUE)) 4916fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addReg(Reg, RegState::Debug).addImm(Offset) 4926fe75aaaeb6b0587d402228ba291c729a13eb6d7Devang Patel .addMetadata(DI->getVariable()); 49333134c4a75558288d663267c8991f6bd37a530afDan Gohman return true; 49492c1e126473dfa93eeb4c9a124af4fedb40f0d5bBill Wendling } 49545df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen case Intrinsic::dbg_value: { 496343b42e428079363ab09828734b2debfd7dbdc9eDale Johannesen // This form of DBG_VALUE is target-independent. 49746510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const DbgValueInst *DI = cast<DbgValueInst>(I); 49845df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen const TargetInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE); 49946510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const Value *V = DI->getValue(); 50045df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen if (!V) { 50145df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // Currently the optimizer can produce this; insert an undef to 50245df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // help debugging. Probably the optimizer should not do this. 50384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 50484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(0U).addImm(DI->getOffset()) 50584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 50646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 50784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 50884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addImm(CI->getZExtValue()).addImm(DI->getOffset()) 50984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 51046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) { 51184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 51284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addFPImm(CF).addImm(DI->getOffset()) 51384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 51445df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else if (unsigned Reg = lookUpRegForValue(V)) { 51584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 51684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Reg, RegState::Debug).addImm(DI->getOffset()) 51784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addMetadata(DI->getVariable()); 51845df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } else { 51945df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // We can't yet handle anything else here because it would require 52045df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen // generating code, thus altering codegen because of debug info. 521afeaae7a940ce16e7874af31f3e5e91d8ca89e19Devang Patel DEBUG(dbgs() << "Dropping debug info for " << DI); 522bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck } 52345df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen return true; 52445df7616528e3d101c5b2938bd4d865321205d33Dale Johannesen } 525dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case Intrinsic::eh_exception: { 526e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = TLI.getValueType(I->getType()); 527dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EXCEPTIONADDR, VT)) { 528dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 529dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 53084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman assert(FuncInfo.MBB->isLandingPad() && 53184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman "Call to eh.exception not in landing pad!"); 532dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionAddressRegister(); 533dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman const TargetRegisterClass *RC = TLI.getRegClassFor(VT); 534dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned ResultReg = createResultReg(RC); 5355127f7991373d1c69e4d3241ec11913f4f44bb21Jakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 5365127f7991373d1c69e4d3241ec11913f4f44bb21Jakob Stoklund Olesen ResultReg).addReg(Reg); 537dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman UpdateValueMap(I, ResultReg); 538dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 539dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 540dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 541dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 542dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 543b01bbdcc1af27bd90b552bb1b62b48916e0d4be3Duncan Sands case Intrinsic::eh_selector: { 544e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = TLI.getValueType(I->getType()); 545dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman switch (TLI.getOperationAction(ISD::EHSELECTION, VT)) { 546dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman default: break; 547dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman case TargetLowering::Expand: { 54884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.MBB->isLandingPad()) 54984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman AddCatchInfo(*cast<CallInst>(I), &FuncInfo.MF->getMMI(), FuncInfo.MBB); 550ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner else { 551dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#ifndef NDEBUG 552a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.CatchInfoLost.insert(cast<CallInst>(I)); 553dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman#endif 554ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner // FIXME: Mark exception selector register as live in. Hack for PR1508. 555dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman unsigned Reg = TLI.getExceptionSelectorRegister(); 55684023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (Reg) FuncInfo.MBB->addLiveIn(Reg); 557dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 558ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner 559ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner unsigned Reg = TLI.getExceptionSelectorRegister(); 560ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner EVT SrcVT = TLI.getPointerTy(); 561ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner const TargetRegisterClass *RC = TLI.getRegClassFor(SrcVT); 562ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner unsigned ResultReg = createResultReg(RC); 5635127f7991373d1c69e4d3241ec11913f4f44bb21Jakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 5645127f7991373d1c69e4d3241ec11913f4f44bb21Jakob Stoklund Olesen ResultReg).addReg(Reg); 565ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner 566a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool ResultRegIsKill = hasTrivialKill(I); 567a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 568ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner // Cast the register to the type of the selector. 569ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner if (SrcVT.bitsGT(MVT::i32)) 570ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner ResultReg = FastEmit_r(SrcVT.getSimpleVT(), MVT::i32, ISD::TRUNCATE, 571a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ResultReg, ResultRegIsKill); 572ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner else if (SrcVT.bitsLT(MVT::i32)) 573ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner ResultReg = FastEmit_r(SrcVT.getSimpleVT(), MVT::i32, 574a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::SIGN_EXTEND, ResultReg, ResultRegIsKill); 575ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner if (ResultReg == 0) 576ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner // Unhandled operand. Halt "fast" selection and bail. 577ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner return false; 578ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner 579ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner UpdateValueMap(I, ResultReg); 580ed3a8067a60ecf2c215e77327a57904c3ebc3355Chris Lattner 581dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman return true; 582dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 583dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 584dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman break; 585dd5b58ad7be78be90390074f0df138778af5c895Dan Gohman } 58633134c4a75558288d663267c8991f6bd37a530afDan Gohman } 5874183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman 5884183e31978146ea529a87a2fc47b96aeb6cbe000Dan Gohman // An arbitrary call. Bail. 58933134c4a75558288d663267c8991f6bd37a530afDan Gohman return false; 59033134c4a75558288d663267c8991f6bd37a530afDan Gohman} 59133134c4a75558288d663267c8991f6bd37a530afDan Gohman 59246510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectCast(const User *I, unsigned Opcode) { 593e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 594e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 595bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 596825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 597825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple()) 598d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 599d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 600bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 601474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Check if the destination type is legal. Or as a special case, 602474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // it may be i1 if we're doing a truncate because that's 603474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 604474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(DstVT)) 605825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DstVT != MVT::i1 || Opcode != ISD::TRUNCATE) 606474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // Unhandled type. Halt "fast" selection and bail. 607474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman return false; 608474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 60991b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Check if the source operand is legal. Or as a special case, 61091b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // it may be i1 if we're doing zero-extension because that's 611474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // easy and somewhat common. 612474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman if (!TLI.isTypeLegal(SrcVT)) 613825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT != MVT::i1 || Opcode != ISD::ZERO_EXTEND) 61491b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman // Unhandled type. Halt "fast" selection and bail. 61591b6f97ce4273fee5516692e3f27cd76d67986fcDan Gohman return false; 616474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman 6173df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned InputReg = getRegForValue(I->getOperand(0)); 618d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!InputReg) 619d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled operand. Halt "fast" selection and bail. 620d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 62114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 622a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool InputRegIsKill = hasTrivialKill(I->getOperand(0)); 623a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 62414ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman // If the operand is i1, arrange for the high bits in the register to be zero. 625825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::i1) { 62623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson SrcVT = TLI.getTypeToTransformTo(I->getContext(), SrcVT); 627a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputReg = FastEmitZExtFromI1(SrcVT.getSimpleVT(), InputReg, InputRegIsKill); 62814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman if (!InputReg) 62914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman return false; 630a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputRegIsKill = true; 63114ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman } 632474d3b3f40e117a66946e9fb9d2016b4c05caef0Dan Gohman // If the result is i1, truncate to the target's type for i1 first. 633825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (DstVT == MVT::i1) 63423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson DstVT = TLI.getTypeToTransformTo(I->getContext(), DstVT); 63514ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 636d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson unsigned ResultReg = FastEmit_r(SrcVT.getSimpleVT(), 637d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson DstVT.getSimpleVT(), 638d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson Opcode, 639a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman InputReg, InputRegIsKill); 640d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson if (!ResultReg) 641d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 642bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 6433df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 644d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 645d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 646d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 64746510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanbool FastISel::SelectBitCast(const User *I) { 648ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // If the bitcast doesn't change the type, just use the operand value. 649ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (I->getType() == I->getOperand(0)->getType()) { 6503df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 651a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman if (Reg == 0) 652a318dabc0edbcc7a2b54d99b026a093361ec14fcDan Gohman return false; 6533df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 654ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman return true; 655ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 656ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman 657bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // Bitcasts of other values become reg-reg copies or BITCAST operators. 658e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 659e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 660bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 661825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson if (SrcVT == MVT::Other || !SrcVT.isSimple() || 662825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson DstVT == MVT::Other || !DstVT.isSimple() || 663d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson !TLI.isTypeLegal(SrcVT) || !TLI.isTypeLegal(DstVT)) 664d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson // Unhandled type. Halt "fast" selection and bail. 665d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 666bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 6673df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Op0 = getRegForValue(I->getOperand(0)); 668ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (Op0 == 0) 669ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // Unhandled operand. Halt "fast" selection and bail. 670d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 671a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 672a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool Op0IsKill = hasTrivialKill(I->getOperand(0)); 673bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 674ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman // First, try to perform the bitcast by inserting a reg-reg copy. 675ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman unsigned ResultReg = 0; 676ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (SrcVT.getSimpleVT() == DstVT.getSimpleVT()) { 677ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* SrcClass = TLI.getRegClassFor(SrcVT); 678ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman TargetRegisterClass* DstClass = TLI.getRegClassFor(DstVT); 679e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen // Don't attempt a cross-class copy. It will likely fail. 680e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen if (SrcClass == DstClass) { 681e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg = createResultReg(DstClass); 682e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 683e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen ResultReg).addReg(Op0); 684e7917bb207d5178dfb26066f839e4c295fd3a1ebJakob Stoklund Olesen } 685ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman } 686bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 687bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck // If the reg-reg copy failed, select a BITCAST opcode. 688ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 689ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman ResultReg = FastEmit_r(SrcVT.getSimpleVT(), DstVT.getSimpleVT(), 690bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, Op0, Op0IsKill); 691bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 692ad368ac2b5f303050e9aaa357e2b806fae38f81bDan Gohman if (!ResultReg) 693d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return false; 694bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 6953df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, ResultReg); 696d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson return true; 697d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson} 698d0533c9998d3baf41848ba559a9b2f2c65296d14Owen Anderson 6993df24e667f04a7003342b534310919abc9c87418Dan Gohmanbool 70046510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectInstruction(const Instruction *I) { 701e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // Just before the terminator instruction, insert instructions to 702e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman // feed PHI nodes in successor blocks. 703e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (isa<TerminatorInst>(I)) 704e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman if (!HandlePHINodesInSuccessorBlocks(I->getParent())) 705e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman return false; 706e8c92dd439581bec7e3516cbdbea74e2e60fe7f0Dan Gohman 7078ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = I->getDebugLoc(); 7088ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman 7096e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // First, try doing target-independent selection. 7108ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (SelectOperator(I, I->getOpcode())) { 7118ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 7126e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 7138ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 7146e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 7156e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman // Next, try calling the target to attempt to handle the instruction. 7168ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman if (TargetSelectInstruction(I)) { 7178ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 7186e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return true; 7198ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman } 7206e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman 7218ba3aa7f9c5048c31172788f98ad2b90ffad565aDan Gohman DL = DebugLoc(); 7226e3ff375474c4fd78feb0b8463eb273a23cb4404Dan Gohman return false; 72340b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman} 72440b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman 725d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// FastEmitBranch - Emit an unconditional branch to the given block, 726d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// unless it is the immediate (fall-through) successor, and update 727d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman/// the CFG. 728d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohmanvoid 7293bf912593301152b65accb9d9c37a95172f1df5aStuart HastingsFastISel::FastEmitBranch(MachineBasicBlock *MSucc, DebugLoc DL) { 73084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman if (FuncInfo.MBB->isLayoutSuccessor(MSucc)) { 731d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional fall-through case, which needs no instructions. 732d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } else { 733d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman // The unconditional branch case. 73484023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TII.InsertBranch(*FuncInfo.MBB, MSucc, NULL, 73584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman SmallVector<MachineOperand, 0>(), DL); 736d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman } 73784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman FuncInfo.MBB->addSuccessor(MSucc); 738d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman} 739d98d6203e429b2d7208b6687931e9079e85e95ecDan Gohman 7403d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// SelectFNeg - Emit an FNeg operation. 7413d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman/// 7423d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohmanbool 74346510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectFNeg(const User *I) { 7443d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman unsigned OpReg = getRegForValue(BinaryOperator::getFNegArgument(I)); 7453d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (OpReg == 0) return false; 7463d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 747a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman bool OpRegIsKill = hasTrivialKill(I); 748a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman 7494a215a13c3035a8818254b61267be77def4a2a37Dan Gohman // If the target has ISD::FNEG, use it. 7504a215a13c3035a8818254b61267be77def4a2a37Dan Gohman EVT VT = TLI.getValueType(I->getType()); 7514a215a13c3035a8818254b61267be77def4a2a37Dan Gohman unsigned ResultReg = FastEmit_r(VT.getSimpleVT(), VT.getSimpleVT(), 752a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::FNEG, OpReg, OpRegIsKill); 7534a215a13c3035a8818254b61267be77def4a2a37Dan Gohman if (ResultReg != 0) { 7544a215a13c3035a8818254b61267be77def4a2a37Dan Gohman UpdateValueMap(I, ResultReg); 7554a215a13c3035a8818254b61267be77def4a2a37Dan Gohman return true; 7564a215a13c3035a8818254b61267be77def4a2a37Dan Gohman } 7574a215a13c3035a8818254b61267be77def4a2a37Dan Gohman 7585e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // Bitcast the value to integer, twiddle the sign bit with xor, 7595e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman // and then bitcast it back to floating-point. 7603d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (VT.getSizeInBits() > 64) return false; 7615e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits()); 7625e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (!TLI.isTypeLegal(IntVT)) 7635e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 7645e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 7655e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman unsigned IntReg = FastEmit_r(VT.getSimpleVT(), IntVT.getSimpleVT(), 766bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, OpReg, OpRegIsKill); 7675e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntReg == 0) 7685e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 7695e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 770a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned IntResultReg = FastEmit_ri_(IntVT.getSimpleVT(), ISD::XOR, 771a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman IntReg, /*Kill=*/true, 7725e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman UINT64_C(1) << (VT.getSizeInBits()-1), 7735e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman IntVT.getSimpleVT()); 7745e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman if (IntResultReg == 0) 7755e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman return false; 7765e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman 7775e5abb77fe9eeb92a55f119fdb721bca4508094aDan Gohman ResultReg = FastEmit_r(IntVT.getSimpleVT(), VT.getSimpleVT(), 778bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck ISD::BITCAST, IntResultReg, /*Kill=*/true); 7793d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (ResultReg == 0) 7803d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return false; 7813d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 7823d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman UpdateValueMap(I, ResultReg); 7833d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return true; 7843d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman} 7853d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman 78640b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohmanbool 78746510a73e977273ec67747eb34cbdb43f815e451Dan GohmanFastISel::SelectOperator(const User *I, unsigned Opcode) { 78840b189e4e257924d90aaf63bf2e12bc7bbca961aDan Gohman switch (Opcode) { 789ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 790ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::ADD); 791ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 792ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FADD); 793ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: 794ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::SUB); 795ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 7963d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman // FNeg is currently represented in LLVM IR as a special case of FSub. 7973d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman if (BinaryOperator::isFNeg(I)) 7983d45a853db014fdddcdb79424e663dfed5eccbc7Dan Gohman return SelectFNeg(I); 799ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FSUB); 800ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 801ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::MUL); 802ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 803ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return SelectBinaryOp(I, ISD::FMUL); 8043df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SDiv: 8053df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SDIV); 8063df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::UDiv: 8073df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UDIV); 8083df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FDiv: 8093df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FDIV); 8103df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SRem: 8113df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SREM); 8123df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::URem: 8133df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::UREM); 8143df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FRem: 8153df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::FREM); 8163df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Shl: 8173df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SHL); 8183df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::LShr: 8193df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRL); 8203df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::AShr: 8213df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::SRA); 8223df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::And: 8233df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::AND); 8243df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Or: 8253df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::OR); 8263df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Xor: 8273df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBinaryOp(I, ISD::XOR); 8283df24e667f04a7003342b534310919abc9c87418Dan Gohman 8293df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::GetElementPtr: 8303df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectGetElementPtr(I); 8313df24e667f04a7003342b534310919abc9c87418Dan Gohman 8323df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Br: { 83346510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BranchInst *BI = cast<BranchInst>(I); 8343df24e667f04a7003342b534310919abc9c87418Dan Gohman 8353df24e667f04a7003342b534310919abc9c87418Dan Gohman if (BI->isUnconditional()) { 83646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const BasicBlock *LLVMSucc = BI->getSuccessor(0); 837a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc]; 8383bf912593301152b65accb9d9c37a95172f1df5aStuart Hastings FastEmitBranch(MSucc, BI->getDebugLoc()); 8393df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 8409d5b41624003daf259b33fc953aa471049700353Owen Anderson } 8413df24e667f04a7003342b534310919abc9c87418Dan Gohman 8423df24e667f04a7003342b534310919abc9c87418Dan Gohman // Conditional branches are not handed yet. 8433df24e667f04a7003342b534310919abc9c87418Dan Gohman // Halt "fast" selection and bail. 8443df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 845b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman } 846b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 847087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman case Instruction::Unreachable: 848087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman // Nothing to emit. 849087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman return true; 850087c8507e592bbbede1746f07bd44b28559e3684Dan Gohman 8510586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman case Instruction::Alloca: 8520586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // FunctionLowering has the static-sized case covered. 853a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I))) 8540586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return true; 8550586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman 8560586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman // Dynamic-sized alloca is not handled yet. 8570586d91bb3e516d5826826522d9a90ed6ef74d86Dan Gohman return false; 858bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 85933134c4a75558288d663267c8991f6bd37a530afDan Gohman case Instruction::Call: 86033134c4a75558288d663267c8991f6bd37a530afDan Gohman return SelectCall(I); 861bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 8623df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::BitCast: 8633df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectBitCast(I); 8643df24e667f04a7003342b534310919abc9c87418Dan Gohman 8653df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::FPToSI: 8663df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::FP_TO_SINT); 8673df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::ZExt: 8683df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 8693df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SExt: 8703df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SIGN_EXTEND); 8713df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::Trunc: 8723df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 8733df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::SIToFP: 8743df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::SINT_TO_FP); 8753df24e667f04a7003342b534310919abc9c87418Dan Gohman 8763df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::IntToPtr: // Deliberate fall-through. 8773df24e667f04a7003342b534310919abc9c87418Dan Gohman case Instruction::PtrToInt: { 878e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT SrcVT = TLI.getValueType(I->getOperand(0)->getType()); 879e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT DstVT = TLI.getValueType(I->getType()); 8803df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsGT(SrcVT)) 8813df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::ZERO_EXTEND); 8823df24e667f04a7003342b534310919abc9c87418Dan Gohman if (DstVT.bitsLT(SrcVT)) 8833df24e667f04a7003342b534310919abc9c87418Dan Gohman return SelectCast(I, ISD::TRUNCATE); 8843df24e667f04a7003342b534310919abc9c87418Dan Gohman unsigned Reg = getRegForValue(I->getOperand(0)); 8853df24e667f04a7003342b534310919abc9c87418Dan Gohman if (Reg == 0) return false; 8863df24e667f04a7003342b534310919abc9c87418Dan Gohman UpdateValueMap(I, Reg); 8873df24e667f04a7003342b534310919abc9c87418Dan Gohman return true; 8883df24e667f04a7003342b534310919abc9c87418Dan Gohman } 889d57dd5f4e6740520820bc0fca42a540e31c27a73Dan Gohman 890ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman case Instruction::PHI: 891ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman llvm_unreachable("FastISel shouldn't visit PHI nodes!"); 892ba5be5c07bb19dcf484e3aa40cd139dd07c10407Dan Gohman 8933df24e667f04a7003342b534310919abc9c87418Dan Gohman default: 8943df24e667f04a7003342b534310919abc9c87418Dan Gohman // Unhandled instruction. Halt "fast" selection and bail. 8953df24e667f04a7003342b534310919abc9c87418Dan Gohman return false; 8963df24e667f04a7003342b534310919abc9c87418Dan Gohman } 897b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 898b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 899a4160c3434b08288d1f79f1acbe453d1b9610b22Dan GohmanFastISel::FastISel(FunctionLoweringInfo &funcInfo) 90084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman : FuncInfo(funcInfo), 901a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MRI(FuncInfo.MF->getRegInfo()), 902a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MFI(*FuncInfo.MF->getFrameInfo()), 903a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MCP(*FuncInfo.MF->getConstantPool()), 904a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman TM(FuncInfo.MF->getTarget()), 90522bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TD(*TM.getTargetData()), 90622bb31103de3337f0bb74c7bee16d1817d4dca14Dan Gohman TII(*TM.getInstrInfo()), 907a7a0ed79012ea36f838239cf1d04959711aec2a9Dan Gohman TLI(*TM.getTargetLowering()), 90884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman TRI(*TM.getRegisterInfo()) { 909bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman} 910bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman 911e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan GohmanFastISel::~FastISel() {} 912e285a74f7cf9dd3ccf4fe758576cf83301f8a43eDan Gohman 913825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_(MVT, MVT, 9147c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned) { 915b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 916b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 917b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 918825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_r(MVT, MVT, 919a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 920a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/) { 921b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 922b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 923b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 924bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peckunsigned FastISel::FastEmit_rr(MVT, MVT, 925a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 926a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 927a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/) { 928b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return 0; 929b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 930b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 9317c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_i(MVT, MVT, unsigned, uint64_t /*Imm*/) { 93283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 93383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 93483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 935825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_f(MVT, MVT, 93646510a73e977273ec67747eb34cbdb43f815e451Dan Gohman unsigned, const ConstantFP * /*FPImm*/) { 93710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 93810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 93910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 940825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_ri(MVT, MVT, 941a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 942a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 9430f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson uint64_t /*Imm*/) { 944d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 945d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 946d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 947825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rf(MVT, MVT, 948a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned, 949a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 95046510a73e977273ec67747eb34cbdb43f815e451Dan Gohman const ConstantFP * /*FPImm*/) { 95110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 95210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 95310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 954825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmit_rri(MVT, MVT, 9557c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohman unsigned, 956a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op0*/, bool /*Op0IsKill*/, 957a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned /*Op1*/, bool /*Op1IsKill*/, 958d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman uint64_t /*Imm*/) { 95983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return 0; 96083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 96183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 96283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries 96383785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// to emit an instruction with an immediate operand using FastEmit_ri. 96483785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// If that fails, it materializes the immediate into a register and try 96583785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng/// FastEmit_rr instead. 9667c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_ri_(MVT VT, unsigned Opcode, 967a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 968a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm, MVT ImmType) { 96983785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng // First check if immediate type is legal. If not, we can't use the ri form. 970a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned ResultReg = FastEmit_ri(VT, VT, Opcode, Op0, Op0IsKill, Imm); 97183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng if (ResultReg != 0) 97283785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng return ResultReg; 9730f84e4e31009eecf2dfcbe6113b65d0919f30254Owen Anderson unsigned MaterialReg = FastEmit_i(ImmType, ImmType, ISD::Constant, Imm); 974d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman if (MaterialReg == 0) 975d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return 0; 976a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_rr(VT, VT, Opcode, 977a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 978a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman MaterialReg, /*Kill=*/true); 979d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 980d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 98110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf_ - This method is a wrapper of FastEmit_ri. It first tries 98210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// to emit an instruction with a floating-point immediate operand using 98310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// FastEmit_rf. If that fails, it materializes the immediate into a register 98410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman/// and try FastEmit_rr instead. 9857c3ecb6838ef7a2ca306c0f3cd68022f0855ae71Dan Gohmanunsigned FastISel::FastEmit_rf_(MVT VT, unsigned Opcode, 986a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 987a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const ConstantFP *FPImm, MVT ImmType) { 98810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // First check if immediate type is legal. If not, we can't use the rf form. 989a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned ResultReg = FastEmit_rf(VT, VT, Opcode, Op0, Op0IsKill, FPImm); 99010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (ResultReg != 0) 99110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 99210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 99310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman // Materialize the constant in a register. 99410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned MaterialReg = FastEmit_f(ImmType, ImmType, ISD::ConstantFP, FPImm); 99510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) { 99696a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // If the target doesn't have a way to directly enter a floating-point 99796a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // value into a register, use an alternate approach. 99896a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // TODO: The current approach only supports floating-point constants 99996a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // that can be constructed by conversion from integer values. This should 100096a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // be replaced by code that creates a load from a constant-pool entry, 100196a9999d79345fa7bc7e2f2a3f28edef4c69e6b5Dan Gohman // which will require some target-specific work. 100210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const APFloat &Flt = FPImm->getValueAPF(); 1003e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT IntVT = TLI.getPointerTy(); 100410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 100510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint64_t x[2]; 100610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman uint32_t IntBitWidth = IntVT.getSizeInBits(); 100723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool isExact; 100823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen (void) Flt.convertToInteger(x, IntBitWidth, /*isSigned=*/true, 100923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &isExact); 101023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (!isExact) 101110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 101210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman APInt IntVal(IntBitWidth, 2, x); 101310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 101410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned IntegerReg = FastEmit_i(IntVT.getSimpleVT(), IntVT.getSimpleVT(), 101510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman ISD::Constant, IntVal.getZExtValue()); 101610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (IntegerReg == 0) 101710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 101810df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman MaterialReg = FastEmit_r(IntVT.getSimpleVT(), VT, 1019a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman ISD::SINT_TO_FP, IntegerReg, /*Kill=*/true); 102010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman if (MaterialReg == 0) 102110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return 0; 102210df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman } 1023a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_rr(VT, VT, Opcode, 1024a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman Op0, Op0IsKill, 1025a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman MaterialReg, /*Kill=*/true); 102610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 102710df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1028d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::createResultReg(const TargetRegisterClass* RC) { 1029d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return MRI.createVirtualRegister(RC); 103083785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng} 103183785c80968165b30fcdd111ceb2c28d38bcff86Evan Cheng 1032b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_(unsigned MachineInstOpcode, 103377ad79689d755c49146f534107421cb3d9703fedDan Gohman const TargetRegisterClass* RC) { 1034d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1035bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 1036b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 103784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg); 1038b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1039b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1040b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1041b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_r(unsigned MachineInstOpcode, 1042b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1043a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill) { 1044d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1045bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 1046b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 10475960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 104884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 104984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 10505960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 105184023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 105284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill); 1053e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1054e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 10555960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 10565960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng 1057b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1058b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1059b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 1060b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohmanunsigned FastISel::FastEmitInst_rr(unsigned MachineInstOpcode, 1061b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman const TargetRegisterClass *RC, 1062a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1063a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill) { 1064d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1065bb466331e7e50d03497ce40ee344870236fd9c32Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 1066b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman 10675960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 106884023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1069a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1070a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 10715960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 107284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1073a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1074a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill); 1075e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1076e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 10775960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1078b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman return ResultReg; 1079b0cf29c5cfff797284b3660dc233e135feb65d9aDan Gohman} 1080d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 1081d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_ri(unsigned MachineInstOpcode, 1082d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1083a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1084a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1085d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1086d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 1087d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 10885960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 108984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1090a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1091a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 10925960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 109384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1094a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1095a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1096e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1097e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 10985960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1099d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1100d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 1101d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 11022ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Andersonunsigned FastISel::FastEmitInst_rii(unsigned MachineInstOpcode, 11032ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson const TargetRegisterClass *RC, 11042ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned Op0, bool Op0IsKill, 11052ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson uint64_t Imm1, uint64_t Imm2) { 11062ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson unsigned ResultReg = createResultReg(RC); 11072ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson const TargetInstrDesc &II = TII.get(MachineInstOpcode); 11082ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 11092ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson if (II.getNumDefs() >= 1) 11102ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 11112ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 11122ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 11132ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 11142ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson else { 11152ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 11162ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addReg(Op0, Op0IsKill * RegState::Kill) 11172ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm1) 11182ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson .addImm(Imm2); 11192ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 11202ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson ResultReg).addReg(II.ImplicitDefs[0]); 11212ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson } 11222ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson return ResultReg; 11232ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson} 11242ce5bf188dfa4329eb246df6011dd1edde5a5979Owen Anderson 112510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohmanunsigned FastISel::FastEmitInst_rf(unsigned MachineInstOpcode, 112610df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetRegisterClass *RC, 1127a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1128a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman const ConstantFP *FPImm) { 112910df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman unsigned ResultReg = createResultReg(RC); 113010df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 113110df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 11325960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 113384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1134a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1135a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 11365960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 113784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1138a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1139a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addFPImm(FPImm); 1140e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1141e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 11425960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 114310df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman return ResultReg; 114410df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman} 114510df0fa73e396bbc93a8940e8b53827390c54d10Dan Gohman 1146d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohmanunsigned FastISel::FastEmitInst_rri(unsigned MachineInstOpcode, 1147d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetRegisterClass *RC, 1148a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1149a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op1, bool Op1IsKill, 1150a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint64_t Imm) { 1151d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman unsigned ResultReg = createResultReg(RC); 1152d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman const TargetInstrDesc &II = TII.get(MachineInstOpcode); 1153d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman 11545960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 115584023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg) 1156a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1157a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1158a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 11595960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 116084023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II) 1161a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op0, Op0IsKill * RegState::Kill) 1162a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addReg(Op1, Op1IsKill * RegState::Kill) 1163a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman .addImm(Imm); 1164e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1165e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 11665960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 1167d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman return ResultReg; 1168d5fe57d2f980c6bd1a61450f99c254a76d0f1683Dan Gohman} 11696d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson 11706d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Andersonunsigned FastISel::FastEmitInst_i(unsigned MachineInstOpcode, 11716d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetRegisterClass *RC, 11726d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson uint64_t Imm) { 11736d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson unsigned ResultReg = createResultReg(RC); 11746d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson const TargetInstrDesc &II = TII.get(MachineInstOpcode); 1175bf17cfa3f904e488e898ac2e3af706fd1a892f08Wesley Peck 11765960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng if (II.getNumDefs() >= 1) 117784023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II, ResultReg).addImm(Imm); 11785960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng else { 117984023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, II).addImm(Imm); 1180e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), 1181e797e0c8644a649d162fb339b148f5db10447d4eJakob Stoklund Olesen ResultReg).addReg(II.ImplicitDefs[0]); 11825960e4eb68be6b3bca6369f6a95d7de5ed8a9eadEvan Cheng } 11836d0c25ec3a7ca822e68f73a4481eee43eb5c9485Owen Anderson return ResultReg; 1184b41aec54767a825ac54c8822e787700bb08a3460Evan Cheng} 11858970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson 1186825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Andersonunsigned FastISel::FastEmitInst_extractsubreg(MVT RetVT, 1187a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman unsigned Op0, bool Op0IsKill, 1188a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman uint32_t Idx) { 1189536ab130ec95cbb7bf30530251dafa7dfecc8471Evan Cheng unsigned ResultReg = createResultReg(TLI.getRegClassFor(RetVT)); 11900bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen assert(TargetRegisterInfo::isVirtualRegister(Op0) && 11910bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen "Cannot yet extract from physregs"); 119284023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, 119384023e0fbefc406a4c611d3d64a10df5d3a97dd7Dan Gohman DL, TII.get(TargetOpcode::COPY), ResultReg) 11940bc25f40402f48ba42fc45403f635b20d90fabb3Jakob Stoklund Olesen .addReg(Op0, getKillRegState(Op0IsKill), Idx); 11958970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson return ResultReg; 11968970f00deff00ffce1f35cf00883357e1582daa1Owen Anderson} 119714ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman 119814ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// FastEmitZExtFromI1 - Emit MachineInstrs to compute the value of Op 119914ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman/// with all but the least significant bit set to zero. 1200a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohmanunsigned FastISel::FastEmitZExtFromI1(MVT VT, unsigned Op0, bool Op0IsKill) { 1201a6cb641f48df20f6f79018569b519e5a32e897a2Dan Gohman return FastEmit_ri(VT, VT, ISD::AND, Op0, Op0IsKill, 1); 120214ea1ec2324cb595f2e035bbf54ddcd483f17c11Dan Gohman} 1203f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1204f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// HandlePHINodesInSuccessorBlocks - Handle PHI nodes in successor blocks. 1205f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Emit code to ensure constants are copied into registers when needed. 1206f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// Remember the virtual registers that need to be added to the Machine PHI 1207f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// nodes as input. We cannot just directly add them, because expansion 1208f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// might result in multiple MBB's for one BB. As such, the start of the 1209f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman/// BB might correspond to a different MBB than the end. 1210f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohmanbool FastISel::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) { 1211f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const TerminatorInst *TI = LLVMBB->getTerminator(); 1212f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1213f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled; 1214a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman unsigned OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size(); 1215f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1216f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Check successor nodes' PHI nodes that expect a constant to be available 1217f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // from this block. 1218f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 1219f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const BasicBlock *SuccBB = TI->getSuccessor(succ); 1220f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!isa<PHINode>(SuccBB->begin())) continue; 1221a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 1222f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1223f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // If this terminator has multiple identical successors (common for 1224f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // switches), only handle each succ once. 1225f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (!SuccsHandled.insert(SuccMBB)) continue; 1226f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1227f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 1228f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1229f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // At this point we know that there is a 1-1 correspondence between LLVM PHI 1230f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // nodes and Machine PHI nodes, but the incoming operands have not been 1231f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // emitted yet. 1232f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman for (BasicBlock::const_iterator I = SuccBB->begin(); 1233f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const PHINode *PN = dyn_cast<PHINode>(I); ++I) { 1234fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1235f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Ignore dead phi's. 1236f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (PN->use_empty()) continue; 1237f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1238f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Only handle legal types. Two interesting things to note here. First, 1239f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // by bailing out early, we may leave behind some dead instructions, 1240f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // since SelectionDAG's HandlePHINodesInSuccessorBlocks will insert its 1241f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // own moves. Second, this check is necessary becuase FastISel doesn't 124289496d0eb73ab8771b27b3d9c1db6492d8eefc3aDan Gohman // use CreateRegs to create registers, so it always creates 1243f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // exactly one register for each non-void instruction. 1244f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman EVT VT = TLI.getValueType(PN->getType(), /*AllowUnknown=*/true); 1245f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (VT == MVT::Other || !TLI.isTypeLegal(VT)) { 1246f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman // Promote MVT::i1. 1247f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (VT == MVT::i1) 1248f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman VT = TLI.getTypeToTransformTo(LLVMBB->getContext(), VT); 1249f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman else { 1250a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1251f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1252f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1253f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1254f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1255f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1256f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1257fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // Set the DebugLoc for the copy. Prefer the location of the operand 1258fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman // if there is one; use the location of the PHI otherwise. 1259fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = PN->getDebugLoc(); 1260fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman if (const Instruction *Inst = dyn_cast<Instruction>(PHIOp)) 1261fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = Inst->getDebugLoc(); 1262fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman 1263f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman unsigned Reg = getRegForValue(PHIOp); 1264f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman if (Reg == 0) { 1265a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.resize(OrigNumPHINodesToUpdate); 1266f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return false; 1267f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1268a4160c3434b08288d1f79f1acbe453d1b9610b22Dan Gohman FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg)); 1269fb95f89e8ebd0b71408472e2544e2b8d6d4738e5Dan Gohman DL = DebugLoc(); 1270f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1271f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman } 1272f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman 1273f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman return true; 1274f81eca0ab908fdcf98ae0efaa75acccc8ba40dc2Dan Gohman} 1275