SelectionDAGISel.cpp revision b882752bd04602249d391699dc7183de007f8964
11c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===// 21c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 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. 71c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 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" 161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Constants.h" 171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 317944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#include "llvm/Support/CommandLine.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 377944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#ifndef _NDEBUG 387944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 397944d9d9957db1efe085d9df3ea89826f50029b7Chris LattnerViewDAGs("view-isel-dags", cl::Hidden, 407944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner cl::desc("Pop up a window to show isel dags as they are selected")); 417944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 427944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic const bool ViewDAGS = 0; 437944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 447944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 49f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 50f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 710afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// BlockLocalArguments - If any arguments are only used in a single basic 720afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// block, and if the target can access the arguments without side-effects, 730afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// avoid emitting CopyToReg nodes for those arguments. This map keeps 740afa8e348eab21d3e09ae3240544886d61879266Chris Lattner /// track of which arguments are local to each BB. 750afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::multimap<BasicBlock*, std::pair<Argument*, 760afa8e348eab21d3e09ae3240544886d61879266Chris Lattner unsigned> > BlockLocalArguments; 770afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 780afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned CreateRegForValue(const Value *V) { 841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // The common case is that we will only create one register for this 861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // value. If we have that case, create and return the virtual register. 871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NV = TLI.getNumElements(VT); 88fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner if (NV == 1) { 89fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner // If we are promoting this value, pick the next largest supported type. 9098e5c0e5e4c5be1b531d287d0a1373a62fe562e2Chris Lattner return MakeReg(TLI.getTypeToTransformTo(VT)); 91fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner } 921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this value is represented with multiple target registers, make sure 941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // to create enough consequtive registers of the right (smaller) type. 951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NT = VT-1; // Find the type to use. 961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner --NT; 981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 1001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1; i != NV; ++i) 1011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MakeReg((MVT::ValueType)NT); 1021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R; 1031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 1141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// PHI nodes or outside of the basic block that defines it. 1151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 1161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 1171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 1181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 1191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI)) 1201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 1211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 1221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 1251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &fn, MachineFunction &mf) 1261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 1271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Initialize the mapping of values to registers. This is only set up for 1291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // instruction values that are used outside of the block that defines 1301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // them. 131e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); AI != E; ++AI) 1321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(AI); 1331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function::iterator BB = Fn.begin(), E = Fn.end(); 1351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 1371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) { 1381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 1391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 1401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 1411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TySize *= CUI->getValue(); // Get total allocated size. 1421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 143f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 1441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (; BB != E; ++BB) 147f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner for (BasicBlock::iterator I = BB->begin(), e = BB->end(); I != e; ++I) 1481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 1491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 1501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 1511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 1521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 1541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 1551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 1561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 1571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 1581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 1591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 1601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 1621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 1631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 165f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 166f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 167f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 168f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 169f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 170f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 171f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 172f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 173f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 1741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 1861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 1871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 1891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 190d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 191d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 192d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 193d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 194d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 195d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 1981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 1991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 2001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 2021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const TargetData &TD; 2031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 2051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &funcinfo) 2101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo(funcinfo) { 2121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 214a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 215a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 216a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 217d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 218d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 219d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 220d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 221d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 222d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 223d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 224d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 225d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 226d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 227d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 228d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads); 229d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 230d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 231d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 232a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 233a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 2341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 2351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 2371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 2381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 2391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 2401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 2411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 2421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 2431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 2441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 2481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 2511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 2521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getValue(const Value *V) { 2551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 2561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.Val) return N; 2571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 2591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) 2601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 2611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visit(CE->getOpcode(), *CE); 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N; 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 2661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 2671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 2681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<UndefValue>(C)) { 269b882752bd04602249d391699dc7183de007f8964Nate Begeman return N = DAG.getNode(ISD::UNDEF, VT); 2701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 2711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 2721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Canonicalize all constant ints to be unsigned. 2741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 2781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 2791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 2801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 2811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 2821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 2851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.ValueMap.find(V); 2861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 287c8ea3c47103656a0924909f41651bf5d396c26cdChris Lattner 288ef5cd1d3cf7d0b20987a545fcd2d0af2bfe6c422Chris Lattner return N = DAG.getCopyFromReg(VMI->second, VT, DAG.getEntryNode()); 2891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 2921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 2931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 2981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 2991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 3001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 3011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 3031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSwitch(SwitchInst &I) { assert(0 && "TODO"); } 3041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 3051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 3061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 3081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBinary(User &I, unsigned Opcode); 3091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAdd(User &I) { visitBinary(I, ISD::ADD); } 310b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 3111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMul(User &I) { visitBinary(I, ISD::MUL); } 3121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 3131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visitBinary(I, I.getType()->isUnsigned() ? ISD::UDIV : ISD::SDIV); 3141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 3161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visitBinary(I, I.getType()->isUnsigned() ? ISD::UREM : ISD::SREM); 3171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAnd(User &I) { visitBinary(I, ISD::AND); } 3191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitOr (User &I) { visitBinary(I, ISD::OR); } 3201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitXor(User &I) { visitBinary(I, ISD::XOR); } 3211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitShl(User &I) { visitBinary(I, ISD::SHL); } 3221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitShr(User &I) { 3231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visitBinary(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 3241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc); 3271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); } 3281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); } 3291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); } 3301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); } 3311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); } 3321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); } 3331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 3351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 3361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 3371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 3381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 3401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 3411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 3421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 3431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 3441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 3451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 3461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 3481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVANext(VANextInst &I); 3491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 3501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 3511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 35239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 3531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3547041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 3551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 3571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 3581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 3591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 3611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 3621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 3631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 3651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 3661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 3681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 369a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 3701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 3711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 374f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner MVT::ValueType TmpVT; 375f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 3761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Op1.getValueType()) { 3771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown value type!"); 3781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i1: 3791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i8: 3801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i16: 381f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner case MVT::i32: 382f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // If this is a machine where 32-bits is legal or expanded, promote to 383f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // 32-bits, otherwise, promote to 64-bits. 384f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 385f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = TLI.getTypeToTransformTo(MVT::i32); 386f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner else 387f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = MVT::i32; 388f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 389f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // Extend integer types to result type. 3901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isSigned()) 391f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, Op1); 3921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner else 393f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, Op1); 3941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; 3951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f32: 3961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Extend float to double. 3971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Op1 = DAG.getNode(ISD::FP_EXTEND, MVT::f64, Op1); 3981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; 3991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i64: 4001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f64: 4011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; // No extension needed! 4021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 404a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot(), Op1)); 4051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 4081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 4091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 4151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 420a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 4211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.getBasicBlock(Succ0MBB))); 4221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 4231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 4241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 4261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 4271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 4281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 429a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 4301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond, DAG.getBasicBlock(Succ0MBB))); 4311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 4321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 4331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 4341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 4351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 436a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 4371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond, DAG.getBasicBlock(Succ1MBB))); 4381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 439e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 440e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 441e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(Cond); 442e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ0MBB)); 443e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ1MBB)); 444e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops)); 4451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 449b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 450b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 451b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 452b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner if (CFP->isExactlyValue(-0.0)) { 453b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 454b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 455b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner return; 456b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner } 457b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 458b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner visitBinary(I, ISD::SUB); 459b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 460b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBinary(User &I, unsigned Opcode) { 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 4642c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 4652c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner if (isa<ShiftInst>(I)) 4662c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner Op2 = DAG.getNode(ISD::ZERO_EXTEND, TLI.getShiftAmountTy(), Op2); 4672c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode UnsignedOpcode) { 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isUnsigned()) 4771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 478f30b73b1c6b6ca8453dc61eb3777b4e4414d3839Chris Lattner setValue(&I, DAG.getSetCC(Opcode, MVT::i1, Op1, Op2)); 4791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 4821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 4831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 4851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 4861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TrueVal, FalseVal)); 4871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 4901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 4911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType SrcTy = TLI.getValueType(I.getOperand(0)->getType()); 4921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType DestTy = TLI.getValueType(I.getType()); 4931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.getValueType() == DestTy) { 4951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 496ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else if (isInteger(SrcTy)) { 497ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isInteger(DestTy)) { // Int -> Int cast 498ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Truncating cast? 499ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestTy, N)); 500ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 501ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestTy, N)); 502ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 503ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestTy, N)); 504ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // Int -> FP cast 505ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 506ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestTy, N)); 507ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 508ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestTy, N)); 509ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 5101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 511ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner assert(isFloatingPoint(SrcTy) && "Unknown value type!"); 512ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isFloatingPoint(DestTy)) { // FP -> FP cast 513ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Rounding cast? 514ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestTy, N)); 515ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 516ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestTy, N)); 517ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // FP -> Int cast. 518ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 519ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestTy, N)); 520ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 521ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestTy, N)); 522ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 5231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 5271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 5281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 5291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 5301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 5321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 5331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 5341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const StructType *StTy = dyn_cast<StructType> (Ty)) { 5351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 5361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 5371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 5381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field]; 5391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 5401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(Offset)); 5411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 5431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 5451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<Constant>(Idx) || !cast<Constant>(Idx)->isNullValue()) { 5461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Idx * ElementSize; 5471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 5487cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner SDOperand IdxN = getValue(Idx), Scale = getIntPtrConstant(ElementSize); 5497cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner 5507cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 5517cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner // it. 5527cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner if (IdxN.getValueType() < Scale.getValueType()) { 5537cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner if (Idx->getType()->isSigned()) 5547cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, Scale.getValueType(), IdxN); 5557cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner else 5567cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, Scale.getValueType(), IdxN); 5577cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner } else if (IdxN.getValueType() > Scale.getValueType()) 5587cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, Scale.getValueType(), IdxN); 5597cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner 5607cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 5617cc4777a263f6a52877d29201311fde5f6edb632Chris Lattner 5621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 5631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 5671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 5701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 5711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 5731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 5741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 5761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 5771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Align = TLI.getTargetData().getTypeAlignment(Ty); 5781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 58068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 58168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 58268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 58368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 58468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 5851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 58668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 5871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 5881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 5901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 5911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 5921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 5931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 5941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 5951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 5961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 5971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 5981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 5991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 6001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 6011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 6021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 6031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, AllocSize.getValueType(), 606a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner getRoot(), AllocSize, 6071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(Align)); 6081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 6091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 6111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 6121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 6131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 6171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 618d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 619d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 620d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 621d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 622d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 623d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 624d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 625d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 626d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 627d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand L = DAG.getLoad(TLI.getValueType(I.getType()), Root, Ptr); 628d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner setValue(&I, L); 629d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 630d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 631d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 632d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 633d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 6341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 6381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 6391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 6401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 641a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr)); 6421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 64564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 6461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Function *F = I.getCalledFunction()) 647c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 648c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner switch (F->getIntrinsicID()) { 649c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case 0: // Not an LLVM intrinsic. 650c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->getName() == "fabs" || F->getName() == "fabsf") { 651c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 652c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 653c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 654c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 655c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 656c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 657c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 658c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 659c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner break; 660c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::vastart: visitVAStart(I); return; 661c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return; 662c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return; 663c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return; 664c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return; 665c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner default: 666c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner // FIXME: IMPLEMENT THESE. 667c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner // readport, writeport, readio, writeio 668c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner assert(0 && "This intrinsic is not implemented yet!"); 669c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 670c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::setjmp: RenameFn = "setjmp"; break; 671c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::longjmp: RenameFn = "longjmp"; break; 672c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::memcpy: visitMemIntrinsic(I, ISD::MEMCPY); return; 673c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::memset: visitMemIntrinsic(I, ISD::MEMSET); return; 674c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::memmove: visitMemIntrinsic(I, ISD::MEMMOVE); return; 675c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner 676c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::isunordered: 677c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getSetCC(ISD::SETUO, MVT::i1,getValue(I.getOperand(1)), 678c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner getValue(I.getOperand(2)))); 679c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 680c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner case Intrinsic::pcmarker: { 681c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner SDOperand Num = getValue(I.getOperand(1)); 682c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Num)); 683c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 684c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 685c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 6861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 68764e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 68864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 68964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 69064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 69164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 6921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 6931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 6951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 6961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 6971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 6981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7008e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 7018e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 7028e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman 703cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 7048e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), Callee, Args, DAG); 7051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 706cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 707cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 7081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 7111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 7121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 71468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 71568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 71668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 71768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 71868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 7191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 7211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType()); 7221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 7231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 7241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 7261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType())); 727cf5734dddd66af9388a171b44996505ede47feedChris Lattner 728cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 7298e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman TLI.LowerCallTo(getRoot(), I.getType(), false, 730cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 731cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 732cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 733cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 7341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 7371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 7381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 7391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetData().getIntPtrType())); 7401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 741cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 7428e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman TLI.LowerCallTo(getRoot(), Type::VoidTy, false, 743cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 744cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 7451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 74739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 74839ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerVAStart(SDOperand Chain, SelectionDAG &DAG) { 7491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 7501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 75139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 7521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 753d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return std::make_pair(SDOperand(), SDOperand()); 7541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 75639ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerSDOperand TargetLowering::LowerVAEnd(SDOperand Chain, SDOperand L, 75739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner SelectionDAG &DAG) { 75839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner // Default to a noop. 75939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return Chain; 76039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 76139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 76239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand,SDOperand> 76339ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerVACopy(SDOperand Chain, SDOperand L, SelectionDAG &DAG) { 76439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner // Default to returning the input list. 76539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(L, Chain); 76639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 76739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 76839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand,SDOperand> 76939ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerVAArgNext(bool isVANext, SDOperand Chain, SDOperand VAList, 77039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner const Type *ArgTy, SelectionDAG &DAG) { 7711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 7721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 77339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 7741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 775d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return std::make_pair(SDOperand(), SDOperand()); 7761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 77739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 77839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 77939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 780a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner std::pair<SDOperand,SDOperand> Result = TLI.LowerVAStart(getRoot(), DAG); 78139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 78239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 78339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 78439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 7851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 78639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 787a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerVAArgNext(false, getRoot(), getValue(I.getOperand(0)), 78839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner I.getType(), DAG); 78939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 79039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 79139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 79239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 79339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVANext(VANextInst &I) { 79439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 795a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerVAArgNext(true, getRoot(), getValue(I.getOperand(0)), 79639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner I.getArgType(), DAG); 79739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 79839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 7991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 802a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(TLI.LowerVAEnd(getRoot(), getValue(I.getOperand(1)), DAG)); 8031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 80639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 807a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerVACopy(getRoot(), getValue(I.getOperand(1)), DAG); 80839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 80939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 8101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 81339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 81439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 81539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 81639ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 81739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 81839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 8191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 821171453a284b097f1ee89fb87ff495c3a6c7b6297Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op) { 822171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 823171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 824d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 825171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 826171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 82739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 82839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 82939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 830a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 83139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 83239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 83339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 8341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8357041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 8367041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner std::vector<SDOperand> Ops; 837a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner Ops.push_back(getRoot()); 8387041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(1))); 8397041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(2))); 8407041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(3))); 8417041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(4))); 8427041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops)); 8431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8457041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 8467041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 8477041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 8481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 8501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 8511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 8561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 8571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 8581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 8591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 8611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 8631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 8641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 8661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 869ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 870ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 8711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG = SDL.DAG; 872f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 87318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 87418c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner cast<RegSDNode>(Op)->getReg() != Reg) && 87518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 876a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner return DAG.getCopyToReg(SDL.getRoot(), Op, Reg); 8771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8790afa8e348eab21d3e09ae3240544886d61879266Chris Lattner/// IsOnlyUsedInOneBasicBlock - If the specified argument is only used in a 8800afa8e348eab21d3e09ae3240544886d61879266Chris Lattner/// single basic block, return that block. Otherwise, return a null pointer. 8810afa8e348eab21d3e09ae3240544886d61879266Chris Lattnerstatic BasicBlock *IsOnlyUsedInOneBasicBlock(Argument *A) { 8820afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (A->use_empty()) return 0; 8830afa8e348eab21d3e09ae3240544886d61879266Chris Lattner BasicBlock *BB = cast<Instruction>(A->use_back())->getParent(); 8840afa8e348eab21d3e09ae3240544886d61879266Chris Lattner for (Argument::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; 8850afa8e348eab21d3e09ae3240544886d61879266Chris Lattner ++UI) 8860afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (isa<PHINode>(*UI) || cast<Instruction>(*UI)->getParent() != BB) 8870afa8e348eab21d3e09ae3240544886d61879266Chris Lattner return 0; // Disagreement among the users? 888aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner 889aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // Okay, there is a single BB user. Only permit this optimization if this is 890aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // the entry block, otherwise, we might sink argument loads into loops and 891aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // stuff. Later, when we have global instruction selection, this won't be an 892aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner // issue clearly. 893aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner if (BB == BB->getParent()->begin()) 894aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner return BB; 895aa781b34040f07db00fb4b59cb567e6ad9ef5861Chris Lattner return 0; 8960afa8e348eab21d3e09ae3240544886d61879266Chris Lattner} 8970afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 898068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 899068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 900068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 9011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 902068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 9030afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 904068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 905068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner if (BB == &F.front()) { 9060afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 9070afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 908068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 909068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 9100afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // If there were side effects accessing the argument list, do not do 9110afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // anything special. 9120afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (OldRoot != SDL.DAG.getRoot()) { 9130afa8e348eab21d3e09ae3240544886d61879266Chris Lattner unsigned a = 0; 914a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 915a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner AI != E; ++AI,++a) 9160afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (!AI->use_empty()) { 9170afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDL.setValue(AI, Args[a]); 9180afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDOperand Copy = 9190afa8e348eab21d3e09ae3240544886d61879266Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 9200afa8e348eab21d3e09ae3240544886d61879266Chris Lattner UnorderedChains.push_back(Copy); 9210afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 9220afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } else { 9230afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Otherwise, if any argument is only accessed in a single basic block, 9240afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // emit that argument only to that basic block. 9250afa8e348eab21d3e09ae3240544886d61879266Chris Lattner unsigned a = 0; 926a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 927a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner AI != E; ++AI,++a) 9280afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (!AI->use_empty()) { 9290afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (BasicBlock *BBU = IsOnlyUsedInOneBasicBlock(AI)) { 9300afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FuncInfo.BlockLocalArguments.insert(std::make_pair(BBU, 9310afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::make_pair(AI, a))); 9320afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } else { 9330afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDL.setValue(AI, Args[a]); 9340afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDOperand Copy = 9350afa8e348eab21d3e09ae3240544886d61879266Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 9360afa8e348eab21d3e09ae3240544886d61879266Chris Lattner UnorderedChains.push_back(Copy); 9370afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 9380afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 9390afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 9400afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 9411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9420afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // See if there are any block-local arguments that need to be emitted in this 9430afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // block. 9440afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 9450afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (!FuncInfo.BlockLocalArguments.empty()) { 9460afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::multimap<BasicBlock*, std::pair<Argument*, unsigned> >::iterator BLAI = 9470afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FuncInfo.BlockLocalArguments.lower_bound(BB); 9480afa8e348eab21d3e09ae3240544886d61879266Chris Lattner if (BLAI != FuncInfo.BlockLocalArguments.end() && BLAI->first == BB) { 9490afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Lower the arguments into this block. 9500afa8e348eab21d3e09ae3240544886d61879266Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 9510afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 9520afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Set up the value mapping for the local arguments. 9530afa8e348eab21d3e09ae3240544886d61879266Chris Lattner for (; BLAI != FuncInfo.BlockLocalArguments.end() && BLAI->first == BB; 9540afa8e348eab21d3e09ae3240544886d61879266Chris Lattner ++BLAI) 9550afa8e348eab21d3e09ae3240544886d61879266Chris Lattner SDL.setValue(BLAI->second.first, Args[BLAI->second.second]); 9560afa8e348eab21d3e09ae3240544886d61879266Chris Lattner 9570afa8e348eab21d3e09ae3240544886d61879266Chris Lattner // Any dead arguments will just be ignored here. 9580afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 9591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 960068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 961068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 962068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 963068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 964068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 965068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner FunctionLoweringInfo &FuncInfo) { 966068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 967068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 968068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 969068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 970068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner // Lower any arguments needed in this block. 971068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 9721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 9741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 9751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 9771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 9781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 9791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 9801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 9821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 9831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 984f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 985ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 9861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 987ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 988ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 9891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 9901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 9921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 9931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 9941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 9951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 9961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 9971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 9981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 10001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 10011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 10031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 10041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 10051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 10061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 10071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 10081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 10091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 10111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 10121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 10131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 1014f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 1015f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 1016f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 1017f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1018f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 1019f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 1020f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 1021f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 1022ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1023ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 1024f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 1025f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 1026f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 1027f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 1028ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 1029ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner assert(isa<AllocaInst>(PHIOp) && 1030ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 1031ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 1032ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 1033ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1034ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 1035ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 10361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1037f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner 1038f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 1039f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 1040f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 1041f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 1042f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 1043f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 10441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 10471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1048ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 10495a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 1050d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner UnorderedChains.push_back(SDL.getRoot()); 1051ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains)); 1052ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 1053ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 10541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 10551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 1056a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 1057a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 1058a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 10591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 10621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo) { 1063ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner SelectionDAG DAG(TLI, MF); 10641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurDAG = &DAG; 10651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 10661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // First step, lower LLVM code to some DAG. This DAG may use operations and 10681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // types that are not supported by the target. 10691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 10701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 10721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 10731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 10751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 1076ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 10771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 10791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 10801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1081a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 1082a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 10831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 10841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10857944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner if (ViewDAGs) DAG.viewGraph(); 10867944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 10871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 10881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 10891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1090a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 10911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 10921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 10931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 10941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 10951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner "This is not a machine PHI node that we are updating!"); 10961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second); 10971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addMachineBasicBlockOperand(BB); 10981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1099a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner 1100a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Finally, add the CFG edges from the last selected MBB to the successor 1101a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // MBBs. 1102a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 1103a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) { 1104a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[TI->getSuccessor(i)]; 1105a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner BB->addSuccessor(Succ0MBB); 1106a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 11071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1108