SelectionDAGISel.cpp revision 6c38b33613d64522581dc55d82fffa4aee0e9f22
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" 221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 27fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 33495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 347944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#include "llvm/Support/CommandLine.h" 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 402300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman// Temporary command line code to enable use of the dag combiner as a beta 412300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman// option. 422300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begemannamespace llvm { 432300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman bool CombinerEnabled; 442300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman} 452300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begemannamespace { 462300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman cl::opt<bool, true> 472300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman CombineDAG("enable-dag-combiner", cl::Hidden, 482300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman cl::desc("Run the DAG combiner before and after Legalize"), 492300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman cl::location(CombinerEnabled), 502300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman cl::init(false)); 512300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman} 52da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 537944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 547944d9d9957db1efe085d9df3ea89826f50029b7Chris LattnerViewDAGs("view-isel-dags", cl::Hidden, 557944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner cl::desc("Pop up a window to show isel dags as they are selected")); 567944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 57a639a43602cd64087a9730632fbf6f7cf7d88276Chris Lattnerstatic const bool ViewDAGs = 0; 587944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 597944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 602300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 65f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 66f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 870afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// BlockLocalArguments - If any arguments are only used in a single basic 880afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// block, and if the target can access the arguments without side-effects, 890afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// avoid emitting CopyToReg nodes for those arguments. This map keeps 900afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// track of which arguments are local to each BB. 910afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::multimap<BasicBlock*, std::pair<Argument*, 920afa8e348eab21d3e09ae3240544886d61879266Chris Lattner unsigned> > BlockLocalArguments; 930afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 940afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 98edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned CreateRegForValue(const Value *V) { 1001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 1011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // The common case is that we will only create one register for this 1021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // value. If we have that case, create and return the virtual register. 1031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NV = TLI.getNumElements(VT); 104fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner if (NV == 1) { 105fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner // If we are promoting this value, pick the next largest supported type. 10698e5c0e5e4c5be1b531d287d0a1373a62fe562e2Chris Lattner return MakeReg(TLI.getTypeToTransformTo(VT)); 107fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner } 108edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this value is represented with multiple target registers, make sure 1101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // to create enough consequtive registers of the right (smaller) type. 1111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NT = VT-1; // Find the type to use. 1121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 1131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner --NT; 114edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 1161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1; i != NV; ++i) 1171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MakeReg((MVT::ValueType)NT); 1181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R; 1191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 120edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 1301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// PHI nodes or outside of the basic block that defines it. 1311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 1321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 1331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 1341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 1351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI)) 1361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 1371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 1381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 141edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 1421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 1431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Initialize the mapping of values to registers. This is only set up for 1451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // instruction values that are used outside of the block that defines 1461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // them. 14716ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 14816ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 1491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(AI); 1501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function::iterator BB = Fn.begin(), E = Fn.end(); 1521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 1541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) { 1551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 1561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 1571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 158a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 159a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // If the alignment of the value is smaller than the size of the value, 160a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // and if the size of the value is particularly small (<= 8 bytes), 161a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // round up to the size of the value for potentially better performance. 162a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // 163a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // FIXME: This could be made better with a preferred alignment hook in 164a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // TargetData. It serves primarily to 8-byte align doubles for X86. 165a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner if (Align < TySize && TySize <= 8) Align = TySize; 166a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 167fd88f64934c43613dd4a70b97db620de1338782bChris Lattner if (CUI->getValue()) // Don't produce zero sized stack objects 168fd88f64934c43613dd4a70b97db620de1338782bChris Lattner TySize *= CUI->getValue(); // Get total allocated size. 1691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 170f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (; BB != E; ++BB) 174f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner for (BasicBlock::iterator I = BB->begin(), e = BB->end(); I != e; ++I) 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 1861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 1871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 1891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 1901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 1911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 192f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 193f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 194f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 195f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 196f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 197f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 198f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 199f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 200f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 2081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 2101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 2121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 2131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 2141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 2161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 217d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 218d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 219d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 220d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 221d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 222d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 2231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 2241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 2251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 2261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 2271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 2281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 2291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const TargetData &TD; 2301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 2321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 2331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 2341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 236edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 2371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 2381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo(funcinfo) { 2391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 241a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 242a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 243a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 244d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 245d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 246edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 247d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 248d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 249d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 250d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 251d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 252d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 253d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 254d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 255d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads); 256d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 257d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 258d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 259a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 260a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 2611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 2661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 2671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 2681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 2691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 2701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 2711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 2781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 2791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getValue(const Value *V) { 2821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 2831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.Val) return N; 2841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 2861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) 2871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 2881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visit(CE->getOpcode(), *CE); 2891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 2901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N; 2911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 2921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 2931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<UndefValue>(C)) { 296b882752bd04602249d391699dc7183de007f8964Nate Begeman return N = DAG.getNode(ISD::UNDEF, VT); 2971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 2981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 2991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 3001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Canonicalize all constant ints to be unsigned. 3011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 3021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 3051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 3061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 3071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 3081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 3091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 3121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.ValueMap.find(V); 3131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 314c8ea3c47103656a0924909f41651bf5d396c26cdChris Lattner 315d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner unsigned InReg = VMI->second; 316d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 317d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, make it so now. 318d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 319d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 320d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 321d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (DestVT < VT) { 322d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Source must be expanded. This input value is actually coming from the 323d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register pair VMI->second and VMI->second+1. 324d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 325d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 326d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 327d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (DestVT > VT) { // Promotion case 328d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (MVT::isFloatingPoint(VT)) 329d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::FP_ROUND, VT, N); 330d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner else 331d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::TRUNCATE, VT, N); 332d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 333d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 334d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 335d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return N; 3361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 3391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 3401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 3411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 3421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 3451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 3461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 3471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 3481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 3501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSwitch(SwitchInst &I) { assert(0 && "TODO"); } 3511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 3521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 3531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 3558f03405ee57094d627c342fb6087399a30009a02Chris Lattner void visitBinary(User &I, unsigned Opcode, bool isShift = false); 3561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAdd(User &I) { visitBinary(I, ISD::ADD); } 357b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 3581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMul(User &I) { visitBinary(I, ISD::MUL); } 3591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 3601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visitBinary(I, I.getType()->isUnsigned() ? ISD::UDIV : ISD::SDIV); 3611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 3631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visitBinary(I, I.getType()->isUnsigned() ? ISD::UREM : ISD::SREM); 3641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAnd(User &I) { visitBinary(I, ISD::AND); } 3661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitOr (User &I) { visitBinary(I, ISD::OR); } 3671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitXor(User &I) { visitBinary(I, ISD::XOR); } 3688f03405ee57094d627c342fb6087399a30009a02Chris Lattner void visitShl(User &I) { visitBinary(I, ISD::SHL, true); } 3691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitShr(User &I) { 3708f03405ee57094d627c342fb6087399a30009a02Chris Lattner visitBinary(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA, true); 3711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc); 3741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); } 3751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); } 3761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); } 3771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); } 3781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); } 3791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); } 3801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 3821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 3831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 3841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 3851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 3871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 3881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 3891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 3901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 3911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 3921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 3931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 3951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 3961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 3971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 39839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 3991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4007041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 4011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 4031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 4071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 4081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 4111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 415a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 420f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner MVT::ValueType TmpVT; 421f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 4221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Op1.getValueType()) { 4231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown value type!"); 4241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i1: 4251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i8: 4261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i16: 427f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner case MVT::i32: 428f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // If this is a machine where 32-bits is legal or expanded, promote to 429f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // 32-bits, otherwise, promote to 64-bits. 430f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 431f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = TLI.getTypeToTransformTo(MVT::i32); 432f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner else 433f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = MVT::i32; 434f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 435f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // Extend integer types to result type. 4361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isSigned()) 437f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, Op1); 4381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner else 439f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, Op1); 4401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; 4411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f32: 4421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i64: 4431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f64: 4441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; // No extension needed! 4451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 447a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot(), Op1)); 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 4511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 4571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 463a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 464dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 4651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 472a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 473dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ0MBB))); 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 4771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 4781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 479a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 480dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ1MBB))); 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 482e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 483e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 484e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(Cond); 485e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ0MBB)); 486e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ1MBB)); 487e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops)); 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 492b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 493b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 494b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 495b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner if (CFP->isExactlyValue(-0.0)) { 496b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 497b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 498b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner return; 499b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner } 500b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 501b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner visitBinary(I, ISD::SUB); 502b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 503b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 5048f03405ee57094d627c342fb6087399a30009a02Chris Lattnervoid SelectionDAGLowering::visitBinary(User &I, unsigned Opcode, bool isShift) { 5051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 5061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 5072c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 5088f03405ee57094d627c342fb6087399a30009a02Chris Lattner if (isShift) 509fab08875b73656f373b10a59aad475615df82bafChris Lattner Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 5102c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 5111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 5121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 5151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode UnsignedOpcode) { 5161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 5171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 5181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 5191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isUnsigned()) 5201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 5217cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 5221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 5251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 5261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 5271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 5281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 5291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TrueVal, FalseVal)); 5301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 5331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 5341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType SrcTy = TLI.getValueType(I.getOperand(0)->getType()); 5351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType DestTy = TLI.getValueType(I.getType()); 5361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.getValueType() == DestTy) { 5381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 539ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner } else if (DestTy == MVT::i1) { 540ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 541ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner SDOperand Zero = isInteger(SrcTy) ? DAG.getConstant(0, N.getValueType()) : 542ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 5437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 544ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else if (isInteger(SrcTy)) { 545ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isInteger(DestTy)) { // Int -> Int cast 546ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Truncating cast? 547ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestTy, N)); 548ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 549ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestTy, N)); 550ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 551ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestTy, N)); 552ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // Int -> FP cast 553ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 554ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestTy, N)); 555ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 556ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestTy, N)); 557ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 5581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 559ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner assert(isFloatingPoint(SrcTy) && "Unknown value type!"); 560ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isFloatingPoint(DestTy)) { // FP -> FP cast 561ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Rounding cast? 562ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestTy, N)); 563ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 564ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestTy, N)); 565ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // FP -> Int cast. 566ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 567ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestTy, N)); 568ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 569ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestTy, N)); 570ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 5711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 5751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 5761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 5771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 5781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 5801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 5811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 5821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const StructType *StTy = dyn_cast<StructType> (Ty)) { 5831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 5841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 5851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 5861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field]; 5871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 588dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 5891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 5911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 5921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 5931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<Constant>(Idx) || !cast<Constant>(Idx)->isNullValue()) { 5941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Idx * ElementSize; 5951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 5967cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner SDOperand IdxN = getValue(Idx), Scale = getIntPtrConstant(ElementSize); 5977cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner 5987cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 5997cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner // it. 6007cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner if (IdxN.getValueType() < Scale.getValueType()) { 6017cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner if (Idx->getType()->isSigned()) 6027cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, Scale.getValueType(), IdxN); 6037cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner else 6047cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, Scale.getValueType(), IdxN); 6057cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner } else if (IdxN.getValueType() > Scale.getValueType()) 6067cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, Scale.getValueType(), IdxN); 6077cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner 6087cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 6091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 6101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 6141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 6171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 6181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 6191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 6201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 6211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 6231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 6241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 6251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 62768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 62868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 62968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 63068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 63168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 6321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 63368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 6341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 6351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 6371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 6381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 6391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 6401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 6411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 6421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 6431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 6441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 6451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 6461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 6471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 6481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 6491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 6501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 652adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs; 653adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(AllocSize.getValueType()); 654adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(MVT::Other); 655adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 656adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getRoot()); 657adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(AllocSize); 658adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getIntPtrConstant(Align)); 659adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 6601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 6611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 6631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 6641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 6651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 6691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 670edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 671d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 672d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 673d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 674d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 675d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 676d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 677d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 678d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 679369e6db9b6033bb60519b0ad84afeacc9ec9b416Chris Lattner SDOperand L = DAG.getLoad(TLI.getValueType(I.getType()), Root, Ptr, 68006ef88472f7bac3512e224974e87a0a456471b82Andrew Lenharth DAG.getSrcValue(I.getOperand(0))); 681d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner setValue(&I, L); 682d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 683d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 684d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 685d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 686d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 6871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 6911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 6921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 6931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 694369e6db9b6033bb60519b0ad84afeacc9ec9b416Chris Lattner DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr, 69506ef88472f7bac3512e224974e87a0a456471b82Andrew Lenharth DAG.getSrcValue(I.getOperand(1)))); 6961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 69964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 700d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner SDOperand Tmp; 7011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Function *F = I.getCalledFunction()) 702c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 703c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner switch (F->getIntrinsicID()) { 704c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case 0: // Not an LLVM intrinsic. 705c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->getName() == "fabs" || F->getName() == "fabsf") { 706c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 707c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 708c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 709d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner Tmp = getValue(I.getOperand(1)); 710c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 711c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 712c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 713c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 714f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner else if (F->getName() == "sin" || F->getName() == "sinf") { 715f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 716f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 717f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getType() == I.getOperand(1)->getType()) { 718d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner Tmp = getValue(I.getOperand(1)); 719f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 720f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 721f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 722f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 723f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner else if (F->getName() == "cos" || F->getName() == "cosf") { 724f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 725f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 726f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getType() == I.getOperand(1)->getType()) { 727d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner Tmp = getValue(I.getOperand(1)); 728f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 729f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 730f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 731f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 732c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner break; 733c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::vastart: visitVAStart(I); return; 734c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return; 735c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return; 736c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return; 737c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return; 738d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner 7396c38b33613d64522581dc55d82fffa4aee0e9f22Chris Lattner case Intrinsic::setjmp: 7406c38b33613d64522581dc55d82fffa4aee0e9f22Chris Lattner RenameFn = "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 7416c38b33613d64522581dc55d82fffa4aee0e9f22Chris Lattner break; 7426c38b33613d64522581dc55d82fffa4aee0e9f22Chris Lattner case Intrinsic::longjmp: 7436c38b33613d64522581dc55d82fffa4aee0e9f22Chris Lattner RenameFn = "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 7446c38b33613d64522581dc55d82fffa4aee0e9f22Chris Lattner break; 745c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::memcpy: visitMemIntrinsic(I, ISD::MEMCPY); return; 746c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::memset: visitMemIntrinsic(I, ISD::MEMSET); return; 747c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::memmove: visitMemIntrinsic(I, ISD::MEMMOVE); return; 748edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 749d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner case Intrinsic::readport: 7501ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner case Intrinsic::readio: { 7511ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner std::vector<MVT::ValueType> VTs; 7521ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner VTs.push_back(TLI.getValueType(I.getType())); 7531ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner VTs.push_back(MVT::Other); 7541ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner std::vector<SDOperand> Ops; 7551ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner Ops.push_back(getRoot()); 7561ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner Ops.push_back(getValue(I.getOperand(1))); 757d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner Tmp = DAG.getNode(F->getIntrinsicID() == Intrinsic::readport ? 7581ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner ISD::READPORT : ISD::READIO, VTs, Ops); 75900b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen 760d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner setValue(&I, Tmp); 761d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner DAG.setRoot(Tmp.getValue(1)); 762d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner return; 7631ca85d567c8860a8a7cf0730107f4ee701fa4fd0Chris Lattner } 764d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner case Intrinsic::writeport: 765d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner case Intrinsic::writeio: 766d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner DAG.setRoot(DAG.getNode(F->getIntrinsicID() == Intrinsic::writeport ? 767d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner ISD::WRITEPORT : ISD::WRITEIO, MVT::Other, 768d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner getRoot(), getValue(I.getOperand(1)), 769d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner getValue(I.getOperand(2)))); 770d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner return; 7717ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner case Intrinsic::dbg_stoppoint: 7727ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner case Intrinsic::dbg_region_start: 7737ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner case Intrinsic::dbg_region_end: 7747ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner case Intrinsic::dbg_func_start: 7757ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner case Intrinsic::dbg_declare: 7767ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner if (I.getType() != Type::VoidTy) 7777ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 7787ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner return; 7797ea0ade1b6a16b5836645b61da671715180ab039Chris Lattner 780c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::isunordered: 7817cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 7827cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 783c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 784f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner 785f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner case Intrinsic::sqrt: 786f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 787f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner getValue(I.getOperand(1)).getValueType(), 788f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner getValue(I.getOperand(1)))); 789f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 790f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner 791d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner case Intrinsic::pcmarker: 792d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner Tmp = getValue(I.getOperand(1)); 793d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 794c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 795691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case Intrinsic::cttz: 796691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth setValue(&I, DAG.getNode(ISD::CTTZ, 797691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getValue(I.getOperand(1)).getValueType(), 798691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getValue(I.getOperand(1)))); 799691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth return; 800691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case Intrinsic::ctlz: 801691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth setValue(&I, DAG.getNode(ISD::CTLZ, 802691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getValue(I.getOperand(1)).getValueType(), 803691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getValue(I.getOperand(1)))); 804691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth return; 805691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth case Intrinsic::ctpop: 806691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth setValue(&I, DAG.getNode(ISD::CTPOP, 807691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getValue(I.getOperand(1)).getValueType(), 808691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth getValue(I.getOperand(1)))); 809691ef2ba066dda14ae4ac0ad645054fbc967785aAndrew Lenharth return; 810d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner default: 811d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner std::cerr << I; 812d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner assert(0 && "This intrinsic is not implemented yet!"); 813d0f6c1f52dddf11701406c31fd3e9448314a8366Chris Lattner return; 814c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 815edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 81664e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 81764e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 81864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 81964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 82064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 8211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 822edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 8241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 8251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 8261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 8271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 828edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 8298e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 8308e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 831edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 832cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 8339092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 834adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 8351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 836cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 837cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 8381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 8411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 8421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 84468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 84568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 84668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 84768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 84868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 8491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 8511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType()); 8521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 8531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 8541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 8561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType())); 857cf5734dddd66af9388a171b44996505ede47feedChris Lattner 858cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 859adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 860cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 861cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 862cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 863cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 8641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 8671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 8681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 8691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetData().getIntPtrType())); 8701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 871cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 872adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 873cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 874cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 8751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 877025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 878025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 879025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 880025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 881025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 882025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 883025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 884025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 885025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 886025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 887025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 888025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 889025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 890025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 891e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVAStart(SDOperand Chain, 892e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand VAListP, Value *VAListV, 893e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SelectionDAG &DAG) { 8941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 8951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 89639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 8971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 898e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner return SDOperand(); 8991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 901e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVAEnd(SDOperand Chain, SDOperand LP, Value *LV, 90239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner SelectionDAG &DAG) { 90339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner // Default to a noop. 90439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return Chain; 90539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 90639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 907e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVACopy(SDOperand Chain, 908e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand SrcP, Value *SrcV, 909e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand DestP, Value *DestV, 910e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SelectionDAG &DAG) { 911e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner // Default to copying the input list. 912e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand Val = DAG.getLoad(getPointerTy(), Chain, 913e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SrcP, DAG.getSrcValue(SrcV)); 914213e557cef3e653e2d3a00b07b137c143128430aAndrew Lenharth SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), 915e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner Val, DestP, DAG.getSrcValue(DestV)); 916e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner return Result; 91739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 91839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 91939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand,SDOperand> 920e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerTargetLowering::LowerVAArg(SDOperand Chain, SDOperand VAListP, Value *VAListV, 921e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner const Type *ArgTy, SelectionDAG &DAG) { 9221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 9231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 92439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 9251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 926d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return std::make_pair(SDOperand(), SDOperand()); 9271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 92839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 92939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 93039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 931e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner DAG.setRoot(TLI.LowerVAStart(getRoot(), getValue(I.getOperand(1)), 932e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner I.getOperand(1), DAG)); 93339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 93439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 9351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 93639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 937e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner TLI.LowerVAArg(getRoot(), getValue(I.getOperand(0)), I.getOperand(0), 938558bc88a00930fce283b240b7c9555f649a18f1bAndrew Lenharth I.getType(), DAG); 93939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 94039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 9411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 94400b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.setRoot(TLI.LowerVAEnd(getRoot(), getValue(I.getOperand(1)), 945e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner I.getOperand(1), DAG)); 9461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 949e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand Result = 950e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner TLI.LowerVACopy(getRoot(), getValue(I.getOperand(2)), I.getOperand(2), 951e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner getValue(I.getOperand(1)), I.getOperand(1), DAG); 952e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner DAG.setRoot(Result); 9531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 95639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 95739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 95839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 95939ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 96039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 96139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 9621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 96450381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 965171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 966171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 967d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 968171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 969171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 97039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 97139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 97239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 973a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 97439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 97539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 97639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 9771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9787041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 9797041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner std::vector<SDOperand> Ops; 980a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner Ops.push_back(getRoot()); 9817041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(1))); 9827041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(2))); 9837041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(3))); 9847041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(4))); 9857041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops)); 9861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9887041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 9897041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 9907041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 9911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 9931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 9941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 996495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 99736b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 99836b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 999495a0b51915eb763576874f29192820b731edc22Chris Lattner} 10001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 10031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 10041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 10051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 10061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1007495a0b51915eb763576874f29192820b731edc22Chris Lattner // First pass, split all critical edges for PHI nodes with incoming values 1008495a0b51915eb763576874f29192820b731edc22Chris Lattner // that are constants, this way the load of the constant into a vreg will not 1009495a0b51915eb763576874f29192820b731edc22Chris Lattner // be placed into MBBs that are used some other way. 101036b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 101136b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner PHINode *PN; 101236b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (BasicBlock::iterator BBI = BB->begin(); 101336b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner (PN = dyn_cast<PHINode>(BBI)); ++BBI) 101436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 101536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 101636b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 101736b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 1018495a0b51915eb763576874f29192820b731edc22Chris Lattner 10191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 10201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 10221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 1023edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 10241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 10251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1028ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 1029ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 1030f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 103118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 1032d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 103318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 1034d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 1035d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 1036d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 1037d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 1038d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 1039d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SelectionDAG &DAG = SDL.DAG; 1040d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 1041d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 1042d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 1043d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 1044fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 1045fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 1046fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 1047fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 1048d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 1049d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 1050d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 1051d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 1052d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(0, MVT::i32)); 1053d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 1054d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(1, MVT::i32)); 1055d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo); 1056d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 1057d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 10581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10600afa8e348eab21d3e09ae3240544886d61879266Chris Lattner/// IsOnlyUsedInOneBasicBlock - If the specified argument is only used in a 10610afa8e348eab21d3e09ae3240544886d61879266Chris Lattner/// single basic block, return that block. Otherwise, return a null pointer. 10620afa8e348eab21d3e09ae3240544886d61879266Chris Lattnerstatic BasicBlock *IsOnlyUsedInOneBasicBlock(Argument *A) { 10630afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (A->use_empty()) return 0; 10640afa8e348eab21d3e09ae3240544886d61879266Chris Lattner BasicBlock *BB = cast<Instruction>(A->use_back())->getParent(); 10650afa8e348eab21d3e09ae3240544886d61879266Chris Lattner for (Argument::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; 10660afa8e348eab21d3e09ae3240544886d61879266Chris Lattner ++UI) 10670afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (isa<PHINode>(*UI) || cast<Instruction>(*UI)->getParent() != BB) 10680afa8e348eab21d3e09ae3240544886d61879266Chris Lattner return 0; // Disagreement among the users? 1069aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner 1070aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // Okay, there is a single BB user. Only permit this optimization if this is 1071aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // the entry block, otherwise, we might sink argument loads into loops and 1072aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // stuff. Later, when we have global instruction selection, this won't be an 1073aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // issue clearly. 1074aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner if (BB == BB->getParent()->begin()) 1075aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner return BB; 1076aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner return 0; 10770afa8e348eab21d3e09ae3240544886d61879266Chris Lattner} 10780afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 1079068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 1080068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 1081068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 10821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 1083068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 10840afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 1085068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1086068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner if (BB == &F.front()) { 10870afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 10880afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 1089068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 1090068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 10910afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // If there were side effects accessing the argument list, do not do 10920afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // anything special. 10930afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (OldRoot != SDL.DAG.getRoot()) { 10940afa8e348eab21d3e09ae3240544886d61879266Chris Lattner unsigned a = 0; 1095a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1096a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner AI != E; ++AI,++a) 10970afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (!AI->use_empty()) { 10980afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDL.setValue(AI, Args[a]); 10999d3a483a3826d3749c2db9863ddb6e824f1dd6d4Chris Lattner 1100fab08875b73656f373b10a59aad475615df82bafChris Lattner SDOperand Copy = 1101fab08875b73656f373b10a59aad475615df82bafChris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 1102fab08875b73656f373b10a59aad475615df82bafChris Lattner UnorderedChains.push_back(Copy); 11030afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 11040afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } else { 11050afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Otherwise, if any argument is only accessed in a single basic block, 11060afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // emit that argument only to that basic block. 11070afa8e348eab21d3e09ae3240544886d61879266Chris Lattner unsigned a = 0; 1108a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1109a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner AI != E; ++AI,++a) 11100afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (!AI->use_empty()) { 11110afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (BasicBlock *BBU = IsOnlyUsedInOneBasicBlock(AI)) { 11120afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FuncInfo.BlockLocalArguments.insert(std::make_pair(BBU, 11130afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::make_pair(AI, a))); 11140afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } else { 11150afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDL.setValue(AI, Args[a]); 1116edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman SDOperand Copy = 11170afa8e348eab21d3e09ae3240544886d61879266Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 11180afa8e348eab21d3e09ae3240544886d61879266Chris Lattner UnorderedChains.push_back(Copy); 11190afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 11200afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 11210afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 1122405ef9e28d955c1b107c27bedfd4be8b9165af01Chris Lattner 1123fa57702388f139e964befecb4b98c7dfe836945fChris Lattner // Next, if the function has live ins that need to be copied into vregs, 1124fa57702388f139e964befecb4b98c7dfe836945fChris Lattner // emit the copies now, into the top of the block. 1125fa57702388f139e964befecb4b98c7dfe836945fChris Lattner MachineFunction &MF = SDL.DAG.getMachineFunction(); 1126fa57702388f139e964befecb4b98c7dfe836945fChris Lattner if (MF.livein_begin() != MF.livein_end()) { 1127fa57702388f139e964befecb4b98c7dfe836945fChris Lattner SSARegMap *RegMap = MF.getSSARegMap(); 1128fa57702388f139e964befecb4b98c7dfe836945fChris Lattner const MRegisterInfo &MRI = *MF.getTarget().getRegisterInfo(); 1129fa57702388f139e964befecb4b98c7dfe836945fChris Lattner for (MachineFunction::livein_iterator LI = MF.livein_begin(), 1130fa57702388f139e964befecb4b98c7dfe836945fChris Lattner E = MF.livein_end(); LI != E; ++LI) 1131fa57702388f139e964befecb4b98c7dfe836945fChris Lattner if (LI->second) 1132fa57702388f139e964befecb4b98c7dfe836945fChris Lattner MRI.copyRegToReg(*MF.begin(), MF.begin()->end(), LI->second, 1133fa57702388f139e964befecb4b98c7dfe836945fChris Lattner LI->first, RegMap->getRegClass(LI->second)); 1134fa57702388f139e964befecb4b98c7dfe836945fChris Lattner } 1135fa57702388f139e964befecb4b98c7dfe836945fChris Lattner 1136fa57702388f139e964befecb4b98c7dfe836945fChris Lattner // Finally, if the target has anything special to do, allow it to do so. 1137405ef9e28d955c1b107c27bedfd4be8b9165af01Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 11380afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 11391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11400afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // See if there are any block-local arguments that need to be emitted in this 11410afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // block. 11420afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 11430afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (!FuncInfo.BlockLocalArguments.empty()) { 11440afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::multimap<BasicBlock*, std::pair<Argument*, unsigned> >::iterator BLAI = 11450afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FuncInfo.BlockLocalArguments.lower_bound(BB); 11460afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (BLAI != FuncInfo.BlockLocalArguments.end() && BLAI->first == BB) { 11470afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Lower the arguments into this block. 11480afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 1149edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 11500afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Set up the value mapping for the local arguments. 11510afa8e348eab21d3e09ae3240544886d61879266Chris Lattner for (; BLAI != FuncInfo.BlockLocalArguments.end() && BLAI->first == BB; 11520afa8e348eab21d3e09ae3240544886d61879266Chris Lattner ++BLAI) 11530afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDL.setValue(BLAI->second.first, Args[BLAI->second.second]); 1154edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 11550afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Any dead arguments will just be ignored here. 11560afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 11571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1158068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 1159068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1160068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1161068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 1162068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 1163068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner FunctionLoweringInfo &FuncInfo) { 1164068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 1165068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1166068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 1167edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1168068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner // Lower any arguments needed in this block. 1169068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 11701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 11721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 11731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 11751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 11761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 11771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 11781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 11801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 11811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 1182f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 1183ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 11841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 1185ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1186ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 11871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 11881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 11901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 11911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 11921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 11931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 11941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 1195edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 11961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 11981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 11991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 12011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 12021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 12031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 12041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 12051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 12061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 12071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 12091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 12101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 12111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 1212f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 1213f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 1214f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 1215f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1216f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 1217f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 1218f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 1219f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 1220ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1221ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 1222f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 1223f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 1224f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 1225f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 1226ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 1227edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 1228ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 1229ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 1230ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 1231ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1232ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 1233ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 12341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1235edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1236f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 1237f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 1238f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 1239f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 1240f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 1241f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 12421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 12451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1246ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 12475a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 1248d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner UnorderedChains.push_back(SDL.getRoot()); 1249ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains)); 1250ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 1251ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 12521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 12531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 1254a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 1255a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 1256a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 12571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 12601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo) { 1261ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner SelectionDAG DAG(TLI, MF); 12621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurDAG = &DAG; 12631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 12641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // First step, lower LLVM code to some DAG. This DAG may use operations and 12661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // types that are not supported by the target. 12671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 12681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12692300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman // Run the DAG combiner in pre-legalize mode, if we are told to do so 12702300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman if (CombinerEnabled) DAG.Combine(false); 12712300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 12721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 12731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 12741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 12761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 1277ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 12781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 12801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 12811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 128282cfa5d616ff0f760425cbf6e2983fbab618fbdaChris Lattner if (ViewDAGs) DAG.viewGraph(); 128382cfa5d616ff0f760425cbf6e2983fbab618fbdaChris Lattner 12842300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman // Run the DAG combiner in post-legalize mode, if we are told to do so 12852300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman if (CombinerEnabled) DAG.Combine(true); 12862300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 1287a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 1288a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 12891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 12901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 12921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 12931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1294a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 12951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 12961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 12971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 12981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 12991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner "This is not a machine PHI node that we are updating!"); 13001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second); 13011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addMachineBasicBlockOperand(BB); 13021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1303a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner 1304a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Finally, add the CFG edges from the last selected MBB to the successor 1305a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // MBBs. 1306a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 1307a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) { 1308a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[TI->getSuccessor(i)]; 1309a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner BB->addSuccessor(Succ0MBB); 1310a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 13111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1312