SelectionDAGISel.cpp revision 4ef3b817fee7ea5be7219e00ab8e15976bfe279f
11c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 31c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// The LLVM Compiler Infrastructure 41c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 51c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This file was developed by the LLVM research group and is distributed under 61c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 81c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 91c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This implements the SelectionDAGISel class. 111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define DEBUG_TYPE "isel" 151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 16adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Constants.h" 181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 22b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner#include "llvm/CodeGen/IntrinsicLowering.h" 231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 28fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 34495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 357944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#include "llvm/Support/CommandLine.h" 367c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 42da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 437944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 447944d9d9957db1efe085d9df3ea89826f50029b7Chris LattnerViewDAGs("view-isel-dags", cl::Hidden, 457944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner cl::desc("Pop up a window to show isel dags as they are selected")); 467944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 47a639a43602cd64087a9730632fbf6f7cf7d88276Chris Lattnerstatic const bool ViewDAGs = 0; 487944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 497944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 54f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 55f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 79edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned CreateRegForValue(const Value *V) { 811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // The common case is that we will only create one register for this 831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // value. If we have that case, create and return the virtual register. 841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NV = TLI.getNumElements(VT); 85fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner if (NV == 1) { 86fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner // If we are promoting this value, pick the next largest supported type. 8798e5c0e5e4c5be1b531d287d0a1373a62fe562e2Chris Lattner return MakeReg(TLI.getTypeToTransformTo(VT)); 88fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner } 89edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this value is represented with multiple target registers, make sure 911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // to create enough consequtive registers of the right (smaller) type. 921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NT = VT-1; // Find the type to use. 931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner --NT; 95edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1; i != NV; ++i) 981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MakeReg((MVT::ValueType)NT); 991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R; 1001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 101edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 1111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// PHI nodes or outside of the basic block that defines it. 1121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 1131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 1141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 1151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 1161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI)) 1171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 1181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 1191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 121bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 122bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// entry block, return true. 123bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 124bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 125bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 126bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (cast<Instruction>(*UI)->getParent() != Entry) 127bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 128bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 129bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 130bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 132edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 1331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 1341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 135bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 136bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 13716ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 13816ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 139bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 140bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 1411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 142bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 143bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 144bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 1452aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 1461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 1481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) { 1491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 1501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 151ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 152ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 153ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 154a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 155a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // If the alignment of the value is smaller than the size of the value, 156a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // and if the size of the value is particularly small (<= 8 bytes), 157a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // round up to the size of the value for potentially better performance. 158a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // 159a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // FIXME: This could be made better with a preferred alignment hook in 160a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // TargetData. It serves primarily to 8-byte align doubles for X86. 161a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner if (Align < TySize && TySize <= 8) Align = TySize; 1622dfa8192abaad8a3c29132dba50e8b85218e918cChris Lattner TySize *= CUI->getValue(); // Get total allocated size. 163d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 165f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 1661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1682aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 1692aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 1741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 1782aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 1861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 187f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 188f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 189f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 190f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 191f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 192f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 193f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 194f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 195f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 2021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 2031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 2041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 2051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 2081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 212d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 213d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 214d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 215d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 216d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 217d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 2181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 2191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 2201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 2211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 2221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 2231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 2241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const TargetData &TD; 2251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 2271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 2281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 2291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 231edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 2321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 2331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo(funcinfo) { 2341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 236a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 237a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 238a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 239d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 240d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 241edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 242d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 243d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 244d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 245d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 246d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 247d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 248d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 249d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 250d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads); 251d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 252d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 253d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 254a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 255a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 2561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 2571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 2591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 2601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 2611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 2661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 2701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 2741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getValue(const Value *V) { 2771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 2781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.Val) return N; 2791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 2811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) 2821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 2831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visit(CE->getOpcode(), *CE); 2841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 2851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N; 2861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 2871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 2881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 2891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 2901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<UndefValue>(C)) { 291b882752bd04602249d391699dc7183de007f8964Nate Begeman return N = DAG.getNode(ISD::UNDEF, VT); 2921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 2931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Canonicalize all constant ints to be unsigned. 2961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 2971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 3001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 3011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 3021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 3031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 3041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 3071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.ValueMap.find(V); 3081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 309c8ea3c47103656a0924909f41651bf5d396c26cdChris Lattner 310d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner unsigned InReg = VMI->second; 311d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 312d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, make it so now. 313d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 314d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 315d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 316d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (DestVT < VT) { 317d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Source must be expanded. This input value is actually coming from the 318d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register pair VMI->second and VMI->second+1. 319d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 320d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 321d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 322d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (DestVT > VT) { // Promotion case 323d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (MVT::isFloatingPoint(VT)) 324d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::FP_ROUND, VT, N); 325d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner else 326d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::TRUNCATE, VT, N); 327d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 328d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 329d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 330d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return N; 3311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 3341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 3351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 3361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 3371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 3401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 3411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 3421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 3431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 3451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSwitch(SwitchInst &I) { assert(0 && "TODO"); } 3461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 3471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 3481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 3505fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitBinary(User &I, unsigned IntOp, unsigned FPOp, unsigned VecOp); 351e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 3525fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 3535fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::ADD, ISD::FADD, ISD::VADD); 35401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 355b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 3565fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitMul(User &I) { 3575fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::MUL, ISD::FMUL, ISD::VMUL); 35801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 3591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 36001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 3615fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SDIV : ISD::UDIV, ISD::FDIV, 0); 3621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 36401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 3655fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SREM : ISD::UREM, ISD::FREM, 0); 3661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3675fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAnd(User &I) { visitBinary(I, ISD::AND, 0, 0); } 3685fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitOr (User &I) { visitBinary(I, ISD::OR, 0, 0); } 3695fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitXor(User &I) { visitBinary(I, ISD::XOR, 0, 0); } 370e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShl(User &I) { visitShift(I, ISD::SHL); } 371e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShr(User &I) { 372e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman visitShift(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 3731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc); 3761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); } 3771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); } 3781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); } 3791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); } 3801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); } 3811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); } 3821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 3841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 3851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 3861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 3871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 3891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 3901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 3911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 3921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 3931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 3941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 395c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 3961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 3981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 3991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 4001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 40139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 4021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4037041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 4071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 4111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 4151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 418a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 4201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 423f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner MVT::ValueType TmpVT; 424f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 4251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Op1.getValueType()) { 4261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown value type!"); 4271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i1: 4281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i8: 4291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i16: 430f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner case MVT::i32: 431f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // If this is a machine where 32-bits is legal or expanded, promote to 432f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // 32-bits, otherwise, promote to 64-bits. 433f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 434f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = TLI.getTypeToTransformTo(MVT::i32); 435f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner else 436f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = MVT::i32; 437f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 438f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // Extend integer types to result type. 4391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isSigned()) 440f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, Op1); 4411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner else 442f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, Op1); 4431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; 4441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f32: 4451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i64: 4461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f64: 4471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; // No extension needed! 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4494a95945fa5aa431110f50092f4a45d24772a553bNate Begeman // Allow targets to lower this further to meet ABI requirements 4504a95945fa5aa431110f50092f4a45d24772a553bNate Begeman DAG.setRoot(TLI.LowerReturnTo(getRoot(), Op1, DAG)); 4511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 4641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 4651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 466a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 467dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 475a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 476dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ0MBB))); 4771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 4781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 4791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 4801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 482a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 483dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ1MBB))); 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 485e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 486e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 487e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(Cond); 488e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ0MBB)); 489e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ1MBB)); 490e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops)); 4911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 495b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 496b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 49701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (I.getType()->isFloatingPoint()) { 49801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 49901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 50001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 50101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 50201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 50301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 50401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 5055fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::SUB, ISD::FSUB, ISD::VSUB); 506b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 507b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 5085fbb5d2459a5410590f285250faa604576308a93Nate Begemanvoid SelectionDAGLowering::visitBinary(User &I, unsigned IntOp, unsigned FPOp, 5095fbb5d2459a5410590f285250faa604576308a93Nate Begeman unsigned VecOp) { 5105fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 5111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 5121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 5132c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 514b67eb9131c5c04d2e55c6b587fde954619feceafChris Lattner if (Ty->isIntegral()) { 5155fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(IntOp, Op1.getValueType(), Op1, Op2)); 5165fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else if (Ty->isFloatingPoint()) { 5175fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(FPOp, Op1.getValueType(), Op1, Op2)); 5185fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 5195fbb5d2459a5410590f285250faa604576308a93Nate Begeman const PackedType *PTy = cast<PackedType>(Ty); 5204ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman unsigned NumElements = PTy->getNumElements(); 5214ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 5224ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman 5234ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // Immediately scalarize packed types containing only one element, so that 5244ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // the Legalize pass does not have to deal with them. 5254ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman if (NumElements == 1) { 5264ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman unsigned Opc = MVT::isFloatingPoint(PVT) ? FPOp : IntOp; 5274ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman setValue(&I, DAG.getNode(Opc, PVT, Op1, Op2)); 5284ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } else { 5294ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman SDOperand Num = DAG.getConstant(NumElements, MVT::i32); 5304ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman SDOperand Typ = DAG.getValueType(PVT); 5314ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman setValue(&I, DAG.getNode(VecOp, Op1.getValueType(), Num, Typ, Op1, Op2)); 5324ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } 5335fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 534e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 5352c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 536e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 537e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 538e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 539e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 540e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 541e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 5421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 5431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 5461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode UnsignedOpcode) { 5471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 5481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 5491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 5501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isUnsigned()) 5511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 5527cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 5531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 5561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 5571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 5581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 5591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 5601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TrueVal, FalseVal)); 5611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 5641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 5651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType SrcTy = TLI.getValueType(I.getOperand(0)->getType()); 5661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType DestTy = TLI.getValueType(I.getType()); 5671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.getValueType() == DestTy) { 5691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 570ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner } else if (DestTy == MVT::i1) { 571ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 572ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner SDOperand Zero = isInteger(SrcTy) ? DAG.getConstant(0, N.getValueType()) : 573ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 5747cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 575ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else if (isInteger(SrcTy)) { 576ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isInteger(DestTy)) { // Int -> Int cast 577ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Truncating cast? 578ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestTy, N)); 579ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 580ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestTy, N)); 581ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 582ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestTy, N)); 583ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // Int -> FP cast 584ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 585ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestTy, N)); 586ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 587ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestTy, N)); 588ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 5891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 590ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner assert(isFloatingPoint(SrcTy) && "Unknown value type!"); 591ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isFloatingPoint(DestTy)) { // FP -> FP cast 592ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Rounding cast? 593ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestTy, N)); 594ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 595ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestTy, N)); 596ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // FP -> Int cast. 597ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 598ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestTy, N)); 599ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 600ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestTy, N)); 601ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 6021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 6061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 6071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 6081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 6091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 6111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 6121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 6131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const StructType *StTy = dyn_cast<StructType> (Ty)) { 6141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 6151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 6161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 6171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field]; 6181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 619dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 6201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 6221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 6231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 6247c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 6257c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 6267c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 6277c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (CI->getRawValue() == 0) continue; 6287c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 6297c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t Offs; 6307c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 6317c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 6327c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 6337c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 6347c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 6357c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 6367c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 6377c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 6387c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 6397c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 6407c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 6417c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 6427c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 6437c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 6447c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 6457c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (Idx->getType()->isSigned()) 6467c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 6477c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 6487c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN); 6497c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 6507c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 6517c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 6527c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 6537c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 6547c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 6557c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 6567c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 6576b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 6581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 6597c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 6601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6617c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 6627c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 6637c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 6647c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 6651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 6681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 6711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 6721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 6731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 6741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 6751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 6771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 678ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 679ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman I.getAlignment()); 6801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 68268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 68368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 68468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 68568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 68668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 6871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 68868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 6891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 6901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 6921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 6931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 6941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 6951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 6961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 6971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 6981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 6991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 7001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 7011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 7021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 7031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 7041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 7051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 707adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs; 708adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(AllocSize.getValueType()); 709adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(MVT::Other); 710adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 711adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getRoot()); 712adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(AllocSize); 713adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getIntPtrConstant(Align)); 714adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 7151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 7161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 7181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 7191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 7201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 7241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 725edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 726d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 727d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 728d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 729d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 730d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 731d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 732d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 7335fbb5d2459a5410590f285250faa604576308a93Nate Begeman 7345fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 7355fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 7365fbb5d2459a5410590f285250faa604576308a93Nate Begeman 7375fbb5d2459a5410590f285250faa604576308a93Nate Begeman if (Type::PackedTyID == Ty->getTypeID()) { 7385fbb5d2459a5410590f285250faa604576308a93Nate Begeman const PackedType *PTy = cast<PackedType>(Ty); 7394ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman unsigned NumElements = PTy->getNumElements(); 7404ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 7414ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman 7424ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // Immediately scalarize packed types containing only one element, so that 7434ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // the Legalize pass does not have to deal with them. 7444ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman if (NumElements == 1) { 7454ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman L = DAG.getLoad(PVT, Root, Ptr, DAG.getSrcValue(I.getOperand(0))); 7464ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } else { 7474ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman L = DAG.getVecLoad(NumElements, PVT, Root, Ptr, 7484ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman DAG.getSrcValue(I.getOperand(0))); 7494ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } 7505fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 7515fbb5d2459a5410590f285250faa604576308a93Nate Begeman L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, 7525fbb5d2459a5410590f285250faa604576308a93Nate Begeman DAG.getSrcValue(I.getOperand(0))); 7535fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 754d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner setValue(&I, L); 755d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 756d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 757d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 758d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 759d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 7601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 7641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 7651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 7661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 767369e6db9b6033bb60519b0ad84afeacc9ec9b416Chris Lattner DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr, 76806ef88472f7bac3512e224974e87a0a456471b82Andrew Lenharth DAG.getSrcValue(I.getOperand(1)))); 7691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 771c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 772c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 773c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 774c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 775c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 776c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 777c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 778c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 779c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 780c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return 0; 781c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return 0; 782c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 783c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 784c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 785c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 786c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 787c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 788c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::memcpy: visitMemIntrinsic(I, ISD::MEMCPY); return 0; 789c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::memset: visitMemIntrinsic(I, ISD::MEMSET); return 0; 790c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::memmove: visitMemIntrinsic(I, ISD::MEMMOVE); return 0; 791c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 792c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::readport: 793c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::readio: { 794c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner std::vector<MVT::ValueType> VTs; 795c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner VTs.push_back(TLI.getValueType(I.getType())); 796c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner VTs.push_back(MVT::Other); 797c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner std::vector<SDOperand> Ops; 798c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Ops.push_back(getRoot()); 799c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Ops.push_back(getValue(I.getOperand(1))); 800c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = DAG.getNode(Intrinsic == Intrinsic::readport ? 801c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner ISD::READPORT : ISD::READIO, VTs, Ops); 802c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 803c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, Tmp); 804c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(Tmp.getValue(1)); 805c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 806c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 807c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::writeport: 808c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::writeio: 809c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(Intrinsic == Intrinsic::writeport ? 810c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner ISD::WRITEPORT : ISD::WRITEIO, MVT::Other, 811c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getRoot(), getValue(I.getOperand(1)), 812c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)))); 813c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 814b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner 815c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_stoppoint: 816b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 817b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_debugger_stop"; 818b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 819b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 820b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 821c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_region_start: 822b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 823b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_dbg_region_start"; 824b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 825b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 826b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 827c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_region_end: 828b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 829b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_dbg_region_end"; 830b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 831b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 832b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 833c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_func_start: 834b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 835b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_dbg_subprogram"; 836b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 837b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 838b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 839c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_declare: 840c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (I.getType() != Type::VoidTy) 841c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 842c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 843c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 844c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::isunordered: 845c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 846c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 847c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 848c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 849c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::sqrt: 850c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 851c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 852c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 853c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 854c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 855c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 856c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 857c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 858c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 8598b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 8608b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<MVT::ValueType> VTs; 8618b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::i64); 8628b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::Other); 8638b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<SDOperand> Ops; 8648b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth Ops.push_back(getRoot()); 8658b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, VTs, Ops); 8668b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 8678b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 86851b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 8698b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 870c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::cttz: 871c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 872c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 873c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 874c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 875c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::ctlz: 876c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 877c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 878c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 879c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 880c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::ctpop: 881c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 882c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 883c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 884c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 885c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner default: 886c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner std::cerr << I; 887c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner assert(0 && "This intrinsic is not implemented yet!"); 888c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 889c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 890c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 891c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 892c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 8931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 89464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 895c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 896c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 897c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 898c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 899c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 900c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 901c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 902c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 903c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 904c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 905c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 906c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 907c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 908c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 909c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 910c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 911c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 912f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 913f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 914f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getType() == I.getOperand(1)->getType()) { 915c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 916f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 917f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 918f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 919c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 920f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 921f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 922f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getType() == I.getOperand(1)->getType()) { 923c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 924f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 925f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 926f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 927f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 928c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 929c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 930edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 93164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 93264e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 93364e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 93464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 93564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 9361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 937c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 9381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 9391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 9401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 9411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 9421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 943edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 9448e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 9458e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 946edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 947cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 9489092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 949adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 9501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 951cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 952cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 9531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 9561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 9571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 95968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 96068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 96168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 96268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 96368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 9641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 9661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType()); 9671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 9681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 9691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 9711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType())); 972cf5734dddd66af9388a171b44996505ede47feedChris Lattner 973cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 974adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 975cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 976cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 977cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 978cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 9791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 9821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 9831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 9841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetData().getIntPtrType())); 9851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 986cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 987adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 988cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 989cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 9901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 992025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 993025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 994025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 995025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 996025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 997025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 998025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 999025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 1000025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 1001025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 1002025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 1003025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 1004025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 1005025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 10064a95945fa5aa431110f50092f4a45d24772a553bNate BegemanSDOperand TargetLowering::LowerReturnTo(SDOperand Chain, SDOperand Op, 10074a95945fa5aa431110f50092f4a45d24772a553bNate Begeman SelectionDAG &DAG) { 10084a95945fa5aa431110f50092f4a45d24772a553bNate Begeman return DAG.getNode(ISD::RET, MVT::Other, Chain, Op); 10094a95945fa5aa431110f50092f4a45d24772a553bNate Begeman} 10104a95945fa5aa431110f50092f4a45d24772a553bNate Begeman 1011e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVAStart(SDOperand Chain, 1012e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand VAListP, Value *VAListV, 1013e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SelectionDAG &DAG) { 10141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 10151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 101639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 10171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 1018e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner return SDOperand(); 10191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1021e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVAEnd(SDOperand Chain, SDOperand LP, Value *LV, 102239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner SelectionDAG &DAG) { 102339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner // Default to a noop. 102439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return Chain; 102539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 102639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 1027e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVACopy(SDOperand Chain, 1028e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand SrcP, Value *SrcV, 1029e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand DestP, Value *DestV, 1030e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SelectionDAG &DAG) { 1031e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner // Default to copying the input list. 1032e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand Val = DAG.getLoad(getPointerTy(), Chain, 1033e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SrcP, DAG.getSrcValue(SrcV)); 1034213e557cef3e653e2d3a00b07b137c143128430aAndrew Lenharth SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), 1035e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner Val, DestP, DAG.getSrcValue(DestV)); 1036e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner return Result; 103739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 103839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 103939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand,SDOperand> 1040e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerTargetLowering::LowerVAArg(SDOperand Chain, SDOperand VAListP, Value *VAListV, 1041e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner const Type *ArgTy, SelectionDAG &DAG) { 10421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 10431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 104439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 10451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 1046d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return std::make_pair(SDOperand(), SDOperand()); 10471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 104839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 104939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 105039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 1051e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner DAG.setRoot(TLI.LowerVAStart(getRoot(), getValue(I.getOperand(1)), 1052e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner I.getOperand(1), DAG)); 105339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 105439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 10551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 105639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 1057e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner TLI.LowerVAArg(getRoot(), getValue(I.getOperand(0)), I.getOperand(0), 1058558bc88a00930fce283b240b7c9555f649a18f1bAndrew Lenharth I.getType(), DAG); 105939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 106039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 10611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 106400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.setRoot(TLI.LowerVAEnd(getRoot(), getValue(I.getOperand(1)), 1065e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner I.getOperand(1), DAG)); 10661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 1069e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand Result = 1070e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner TLI.LowerVACopy(getRoot(), getValue(I.getOperand(2)), I.getOperand(2), 1071e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner getValue(I.getOperand(1)), I.getOperand(1), DAG); 1072e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner DAG.setRoot(Result); 10731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 107639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 107739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 107839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 107939ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 108039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 108139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 10821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 108450381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 1085171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 1086171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 1087d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 1088171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 1089171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 109039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 109139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 109239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 1093a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 109439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 109539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 109639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 10971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10987041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 10997041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner std::vector<SDOperand> Ops; 1100a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner Ops.push_back(getRoot()); 11017041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(1))); 11027041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(2))); 11037041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(3))); 11047041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(4))); 11057041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops)); 11061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11087041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 11097041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 11107041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 11111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 11131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 11141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1116495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 111736b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 111836b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 1119495a0b51915eb763576874f29192820b731edc22Chris Lattner} 11201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 11221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 11231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 11241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 11251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1126495a0b51915eb763576874f29192820b731edc22Chris Lattner // First pass, split all critical edges for PHI nodes with incoming values 1127495a0b51915eb763576874f29192820b731edc22Chris Lattner // that are constants, this way the load of the constant into a vreg will not 1128495a0b51915eb763576874f29192820b731edc22Chris Lattner // be placed into MBBs that are used some other way. 112936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 113036b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner PHINode *PN; 113136b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (BasicBlock::iterator BBI = BB->begin(); 113236b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner (PN = dyn_cast<PHINode>(BBI)); ++BBI) 113336b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 113436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 113536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 113636b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 1137c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 11381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 11391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 11411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 1142edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 11431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 11441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1147ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 1148ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 1149f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 115018c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 1151d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 115218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 1153d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 1154d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 1155d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 1156d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 1157d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 1158d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SelectionDAG &DAG = SDL.DAG; 1159d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 1160d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 1161d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 1162d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 1163fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 1164fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 1165fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 1166fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 1167d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 1168d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 1169d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 1170d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 1171d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(0, MVT::i32)); 1172d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 1173d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(1, MVT::i32)); 1174d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo); 1175d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 1176d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 11771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1179068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 1180068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 1181068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 11821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 1183068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 11840afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 1185bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 1186bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 1187bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1188bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 1189bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1190bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 1191bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 1192bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 1193fa57702388f139e964befecb4b98c7dfe836945fChris Lattner 1194bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 1195bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 1196bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 1197bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 1198bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 1199bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 1200bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 12010afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 1202bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1203bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Next, if the function has live ins that need to be copied into vregs, 1204bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // emit the copies now, into the top of the block. 1205bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MachineFunction &MF = SDL.DAG.getMachineFunction(); 1206bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (MF.livein_begin() != MF.livein_end()) { 1207bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SSARegMap *RegMap = MF.getSSARegMap(); 1208bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner const MRegisterInfo &MRI = *MF.getTarget().getRegisterInfo(); 1209bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (MachineFunction::livein_iterator LI = MF.livein_begin(), 1210bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner E = MF.livein_end(); LI != E; ++LI) 1211bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LI->second) 1212bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MRI.copyRegToReg(*MF.begin(), MF.begin()->end(), LI->second, 1213bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LI->first, RegMap->getRegClass(LI->second)); 12141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1215bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1216bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 1217bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 1218068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 1219068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1220068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1221068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 1222068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 1223068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner FunctionLoweringInfo &FuncInfo) { 1224068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 1225068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1226068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 1227edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1228bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 1229bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 1230bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 12311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 12331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 12341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 12361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 12371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 12381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 12391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 12411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 12421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 1243f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 1244ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 12451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 1246ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1247ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 12481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 12511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 12521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 12531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 12541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 12551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 1256edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 12571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 12591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 12601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 12621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 12631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 12641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 12651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 12661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 12671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 12681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 12701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 12711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 12721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 1273f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 1274f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 1275f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 1276f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1277f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 1278f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 1279f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 1280f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 1281ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1282ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 1283f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 1284f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 1285f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 1286f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 1287ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 1288edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 1289ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 1290ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 1291ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 1292ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1293ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 1294ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 12951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1296edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1297f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 1298f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 1299f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 1300f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 1301f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 1302f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 13031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 13041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 13051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 13061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1307ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 13085a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 13097436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 13107436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 13117436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 13127436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 13137436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 13147436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 13157436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 13167436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 13177436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 13187436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 13197436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 13207436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 1321ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains)); 1322ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 1323ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 13241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 13251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 1326a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 1327a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 1328a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 13291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 13321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo) { 1333ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner SelectionDAG DAG(TLI, MF); 13341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurDAG = &DAG; 13351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 13361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // First step, lower LLVM code to some DAG. This DAG may use operations and 13381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // types that are not supported by the target. 13391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 13401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1341af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 1342af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(false); 13432300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 13441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 13451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 13461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 13481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 1349ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 13501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 13521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 13531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1354af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 1355af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(true); 13562300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 1357d48050aa1509130871b8bb2453270c92b969c2e7Chris Lattner if (ViewDAGs) DAG.viewGraph(); 1358d48050aa1509130871b8bb2453270c92b969c2e7Chris Lattner 1359a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 1360a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 13611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 13621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 13641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 13651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1366a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 13671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 13681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 13691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 13701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 13711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner "This is not a machine PHI node that we are updating!"); 13721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second); 13731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addMachineBasicBlockOperand(BB); 13741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1375a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner 1376a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Finally, add the CFG edges from the last selected MBB to the successor 1377a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // MBBs. 1378a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 1379a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) { 1380a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[TI->getSuccessor(i)]; 1381a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner BB->addSuccessor(Succ0MBB); 1382a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 13831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1384