SelectionDAGISel.cpp revision 3f23952404cd03a8ab934cedcef7916f52a796c0
11c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 31c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// The LLVM Compiler Infrastructure 41c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 51c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This file was developed by the LLVM research group and is distributed under 61c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 81c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 91c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This implements the SelectionDAGISel class. 111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define DEBUG_TYPE "isel" 151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 16a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng#include "llvm/CodeGen/ScheduleDAG.h" 17adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Constants.h" 191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 2136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner#include "llvm/GlobalVariable.h" 221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 24b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner#include "llvm/CodeGen/IntrinsicLowering.h" 25b2efb853f00d45b1c8d57f92acd0028fbdeffda6Jim Laskey#include "llvm/CodeGen/MachineDebugInfo.h" 261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 31fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 37495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 387944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#include "llvm/Support/CommandLine.h" 397c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 45da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 467944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 47a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 48a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 49a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 50a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 51a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 527944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 53a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic const bool ViewISelDAGs = 0; 54a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic const bool ViewSchedDAGs = 0; 557944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 567944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 574ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Chengnamespace { 584ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng cl::opt<SchedHeuristics> 594ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng ISHeuristic( 604ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "sched", 614ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng cl::desc("Choose scheduling style"), 623f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng cl::init(defaultScheduling), 634ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng cl::values( 643f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng clEnumValN(defaultScheduling, "default", 653f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng "Target preferred scheduling style"), 664ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValN(noScheduling, "none", 6717d52f723421ce28d1b9fe2fc058366ed43ec094Jim Laskey "No scheduling: breadth first sequencing"), 684ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValN(simpleScheduling, "simple", 694ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "Simple two pass scheduling: minimize critical path " 704ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "and maximize processor utilization"), 714ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValN(simpleNoItinScheduling, "simple-noitin", 724ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "Simple two pass scheduling: Same as simple " 734ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "except using generic latency"), 743f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng clEnumValN(listSchedulingBURR, "list-burr", 75f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng "Bottom up register reduction list scheduling"), 764ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValEnd)); 774ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng} // namespace 784ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 794ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 84f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 85f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 1001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 1021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 1031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 1041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 1051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 1071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 1081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 109edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned CreateRegForValue(const Value *V) { 1111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 1121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // The common case is that we will only create one register for this 1131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // value. If we have that case, create and return the virtual register. 1141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NV = TLI.getNumElements(VT); 115fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner if (NV == 1) { 116fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner // If we are promoting this value, pick the next largest supported type. 11798e5c0e5e4c5be1b531d287d0a1373a62fe562e2Chris Lattner return MakeReg(TLI.getTypeToTransformTo(VT)); 118fb849800ea2040c188365c265421ad54fbdcf219Chris Lattner } 119edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this value is represented with multiple target registers, make sure 1211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // to create enough consequtive registers of the right (smaller) type. 1221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned NT = VT-1; // Find the type to use. 1231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 1241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner --NT; 125edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 1271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1; i != NV; ++i) 1281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MakeReg((MVT::ValueType)NT); 1291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R; 1301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 131edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 1411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// PHI nodes or outside of the basic block that defines it. 1421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 1431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 1441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 1451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 1461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI)) 1471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 1481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 1491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 151bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 152bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// entry block, return true. 153bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 154bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 155bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 156bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (cast<Instruction>(*UI)->getParent() != Entry) 157bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 158bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 159bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 160bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 162edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 1631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 165bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 166bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 16716ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 16816ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 169bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 170bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 172bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 173bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 174bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 1752aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) { 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 181ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 182ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 183ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 184a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 185a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // If the alignment of the value is smaller than the size of the value, 186a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // and if the size of the value is particularly small (<= 8 bytes), 187a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // round up to the size of the value for potentially better performance. 188a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // 189a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // FIXME: This could be made better with a preferred alignment hook in 190a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // TargetData. It serves primarily to 8-byte align doubles for X86. 191a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner if (Align < TySize && TySize <= 8) Align = TySize; 1922dfa8192abaad8a3c29132dba50e8b85218e918cChris Lattner TySize *= CUI->getValue(); // Get total allocated size. 193d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 1941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 195f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1982aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 1992aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 2021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 2031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 2041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 2082aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 2101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 2121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 2141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 2151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 2161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 217f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 218f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 219f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 220f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 221f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 222f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 223f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 224f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 225f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 2321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 2331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 2341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 2351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 2361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 2371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 2381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 2391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 2411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 242d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 243d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 244d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 245d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 246d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 247d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 2481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 2491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 2501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 2511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 2521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 2531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 2541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const TargetData &TD; 2551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 2571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 2581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 2591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 261edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo(funcinfo) { 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 266a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 267a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 268a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 269d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 270d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 271edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 272d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 273d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 274d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 275d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 276d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 277d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 278d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 279d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 280d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads); 281d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 282d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 283d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 284a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 285a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 2861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 2871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 2891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 2901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 2911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 2921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 2931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 2961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 3001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 3031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 3041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getValue(const Value *V) { 3071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 3081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.Val) return N; 3091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3108cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman const Type *VTy = V->getType(); 3118cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman MVT::ValueType VT = TLI.getValueType(VTy); 3121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) 3131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 3141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner visit(CE->getOpcode(), *CE); 3151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 3161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N; 3171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 3181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 3191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 3201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 3211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (isa<UndefValue>(C)) { 322b882752bd04602249d391699dc7183de007f8964Nate Begeman return N = DAG.getNode(ISD::UNDEF, VT); 3231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 3241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 3258cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } else if (const PackedType *PTy = dyn_cast<PackedType>(VTy)) { 3268cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman unsigned NumElements = PTy->getNumElements(); 3278cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 3288cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman MVT::ValueType TVT = MVT::getVectorType(PVT, NumElements); 3298cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman 3308cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // Now that we know the number and type of the elements, push a 3318cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // Constant or ConstantFP node onto the ops list for each element of 3328cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // the packed constant. 3338cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman std::vector<SDOperand> Ops; 3343b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) { 3353b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner if (MVT::isFloatingPoint(PVT)) { 3363b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner for (unsigned i = 0; i != NumElements; ++i) { 3373b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner const ConstantFP *El = cast<ConstantFP>(CP->getOperand(i)); 3383b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner Ops.push_back(DAG.getConstantFP(El->getValue(), PVT)); 3393b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner } 3403b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner } else { 3413b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner for (unsigned i = 0; i != NumElements; ++i) { 3423b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner const ConstantIntegral *El = 3433b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner cast<ConstantIntegral>(CP->getOperand(i)); 3443b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner Ops.push_back(DAG.getConstant(El->getRawValue(), PVT)); 3453b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner } 3463b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner } 3473b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner } else { 3483b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 3493b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner SDOperand Op; 3508cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (MVT::isFloatingPoint(PVT)) 3513b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner Op = DAG.getConstantFP(0, PVT); 3528cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman else 3533b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner Op = DAG.getConstant(0, PVT); 3543b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner Ops.assign(NumElements, Op); 3558cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman } 3563b841e9f52611c1f92c60f979c775adf2c1fe22dChris Lattner 3578cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // Handle the case where we have a 1-element vector, in which 3588cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman // case we want to immediately turn it into a scalar constant. 359cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman if (Ops.size() == 1) { 3608cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman return N = Ops[0]; 361cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } else if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) { 362cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman return N = DAG.getNode(ISD::ConstantVec, TVT, Ops); 363cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } else { 364cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // If the packed type isn't legal, then create a ConstantVec node with 365cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman // generic Vector type instead. 366cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman return N = DAG.getNode(ISD::ConstantVec, MVT::Vector, Ops); 367cc827e60b67b2cbcf08a37b119e68081e4171b8aNate Begeman } 3681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 3691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Canonicalize all constant ints to be unsigned. 3701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 3711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 3741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 3751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 3761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 3771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 3781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 3811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo.ValueMap.find(V); 3821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 383c8ea3c47103656a0924909f41651bf5d396c26cdChris Lattner 384d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner unsigned InReg = VMI->second; 385d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 386d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, make it so now. 387d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 388d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 389d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 390d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (DestVT < VT) { 391d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // Source must be expanded. This input value is actually coming from the 392d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register pair VMI->second and VMI->second+1. 393d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 394d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 395d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 396d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (DestVT > VT) { // Promotion case 397d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (MVT::isFloatingPoint(VT)) 398d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::FP_ROUND, VT, N); 399d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner else 400d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner N = DAG.getNode(ISD::TRUNCATE, VT, N); 401d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 402d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 403d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 404d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return N; 4051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 4081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 4111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 4151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 419c0f4cd99316b0b9ae10b5774d1036d74d838f0afRobert Bocchino void visitExtractElement(ExtractElementInst &I) { assert(0 && "TODO"); } 4204eb2e3a6f45e6f0a4a8f0002918f8d14c34169c1Robert Bocchino void visitInsertElement(InsertElementInst &I) { assert(0 && "TODO"); } 4211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSwitch(SwitchInst &I) { assert(0 && "TODO"); } 4221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 4231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 4241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 4265fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitBinary(User &I, unsigned IntOp, unsigned FPOp, unsigned VecOp); 427e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 4285fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 4295fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::ADD, ISD::FADD, ISD::VADD); 43001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 431b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 4325fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitMul(User &I) { 4335fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::MUL, ISD::FMUL, ISD::VMUL); 43401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 4351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 43601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 4375fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SDIV : ISD::UDIV, ISD::FDIV, 0); 4381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 44001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 4415fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SREM : ISD::UREM, ISD::FREM, 0); 4421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4435fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAnd(User &I) { visitBinary(I, ISD::AND, 0, 0); } 4445fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitOr (User &I) { visitBinary(I, ISD::OR, 0, 0); } 4455fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitXor(User &I) { visitBinary(I, ISD::XOR, 0, 0); } 446e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShl(User &I) { visitShift(I, ISD::SHL); } 447e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShr(User &I) { 448e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman visitShift(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 4491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc); 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); } 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); } 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); } 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); } 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); } 4571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); } 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 4651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 471c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 47739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 4781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4797041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 4801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 4821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 4831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 4861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 4871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 4901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 4911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 4931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 494a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 4951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 4961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 499f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner MVT::ValueType TmpVT; 500f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 5011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Op1.getValueType()) { 5021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown value type!"); 5031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i1: 5041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i8: 5051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i16: 506f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner case MVT::i32: 507f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // If this is a machine where 32-bits is legal or expanded, promote to 508f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // 32-bits, otherwise, promote to 64-bits. 509f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 510f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = TLI.getTypeToTransformTo(MVT::i32); 511f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner else 512f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner TmpVT = MVT::i32; 513f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner 514f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner // Extend integer types to result type. 5151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isSigned()) 516f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, Op1); 5171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner else 518f51d3bd6769d46e7cf7beaa283d1ca449629bd32Chris Lattner Op1 = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, Op1); 5191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; 5201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f32: 5214eebb60f843e0aa67b62f3b8643101bc0e39531dChris Lattner // If this is a machine where f32 is promoted to f64, do so now. 5224eebb60f843e0aa67b62f3b8643101bc0e39531dChris Lattner if (TLI.getTypeAction(MVT::f32) == TargetLowering::Promote) 5234eebb60f843e0aa67b62f3b8643101bc0e39531dChris Lattner Op1 = DAG.getNode(ISD::FP_EXTEND, TLI.getTypeToTransformTo(MVT::f32),Op1); 5244eebb60f843e0aa67b62f3b8643101bc0e39531dChris Lattner break; 5251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::i64: 5261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case MVT::f64: 5271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner break; // No extension needed! 5281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5294a95945fa5aa431110f50092f4a45d24772a553bNate Begeman // Allow targets to lower this further to meet ABI requirements 5304a95945fa5aa431110f50092f4a45d24772a553bNate Begeman DAG.setRoot(TLI.LowerReturnTo(getRoot(), Op1, DAG)); 5311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 5341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 5351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 5361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 5381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 5391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 5401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 5411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 5421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 5451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 546a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 547dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 5481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 5491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 5501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 5521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 5531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 5541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 555a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 556dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ0MBB))); 5571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 5581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 5591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 5601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 5611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 562a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 563dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ1MBB))); 5641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 565e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 566e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 567e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(Cond); 568e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ0MBB)); 569e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(DAG.getBasicBlock(Succ1MBB)); 570e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops)); 5711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 575b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 576b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 57701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (I.getType()->isFloatingPoint()) { 57801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 57901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 58001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 58101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 58201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 58301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 58401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 5855fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::SUB, ISD::FSUB, ISD::VSUB); 586b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 587b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 5885fbb5d2459a5410590f285250faa604576308a93Nate Begemanvoid SelectionDAGLowering::visitBinary(User &I, unsigned IntOp, unsigned FPOp, 5895fbb5d2459a5410590f285250faa604576308a93Nate Begeman unsigned VecOp) { 5905fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 5911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 5921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 5932c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 594b67eb9131c5c04d2e55c6b587fde954619feceafChris Lattner if (Ty->isIntegral()) { 5955fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(IntOp, Op1.getValueType(), Op1, Op2)); 5965fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else if (Ty->isFloatingPoint()) { 5975fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(FPOp, Op1.getValueType(), Op1, Op2)); 5985fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 5995fbb5d2459a5410590f285250faa604576308a93Nate Begeman const PackedType *PTy = cast<PackedType>(Ty); 6004ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman unsigned NumElements = PTy->getNumElements(); 6014ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 602f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman MVT::ValueType TVT = MVT::getVectorType(PVT, NumElements); 6034ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman 6044ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // Immediately scalarize packed types containing only one element, so that 605f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman // the Legalize pass does not have to deal with them. Similarly, if the 606f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman // abstract vector is going to turn into one that the target natively 607f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman // supports, generate that type now so that Legalize doesn't have to deal 608f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman // with that either. These steps ensure that Legalize only has to handle 609f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman // vector types in its Expand case. 610f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman unsigned Opc = MVT::isFloatingPoint(PVT) ? FPOp : IntOp; 6114ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman if (NumElements == 1) { 6124ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman setValue(&I, DAG.getNode(Opc, PVT, Op1, Op2)); 613f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } else if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) { 614f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman setValue(&I, DAG.getNode(Opc, TVT, Op1, Op2)); 6154ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } else { 6164ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman SDOperand Num = DAG.getConstant(NumElements, MVT::i32); 6174ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman SDOperand Typ = DAG.getValueType(PVT); 618ab48be377298bd509427a29e174cf4e305138819Nate Begeman setValue(&I, DAG.getNode(VecOp, MVT::Vector, Op1, Op2, Num, Typ)); 6194ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } 6205fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 621e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 6222c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 623e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 624e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 625e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 626e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 627e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 628e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 6291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 6301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 6331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode UnsignedOpcode) { 6341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 6351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 6361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 6371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isUnsigned()) 6381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 6397cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 6401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 6431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 6441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 6451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 6461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 6471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TrueVal, FalseVal)); 6481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 6511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 6521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType SrcTy = TLI.getValueType(I.getOperand(0)->getType()); 6531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType DestTy = TLI.getValueType(I.getType()); 6541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (N.getValueType() == DestTy) { 6561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 657ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner } else if (DestTy == MVT::i1) { 658ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 659ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner SDOperand Zero = isInteger(SrcTy) ? DAG.getConstant(0, N.getValueType()) : 660ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 6617cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 662ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else if (isInteger(SrcTy)) { 663ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isInteger(DestTy)) { // Int -> Int cast 664ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Truncating cast? 665ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestTy, N)); 666ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 667ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestTy, N)); 668ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 669ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestTy, N)); 670ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // Int -> FP cast 671ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 672ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestTy, N)); 673ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 674ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestTy, N)); 675ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 6761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 677ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner assert(isFloatingPoint(SrcTy) && "Unknown value type!"); 678ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (isFloatingPoint(DestTy)) { // FP -> FP cast 679ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (DestTy < SrcTy) // Rounding cast? 680ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestTy, N)); 681ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 682ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestTy, N)); 683ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } else { // FP -> Int cast. 684ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 685ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestTy, N)); 686ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 687ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestTy, N)); 688ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 6891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 6931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 6941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 6951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 6961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 6981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 6991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 700c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 7011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 7021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 7031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 7041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field]; 7051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 706dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 7071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 7091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 7101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 7117c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 7127c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 7137c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 7147c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (CI->getRawValue() == 0) continue; 7157c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 7167c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t Offs; 7177c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 7187c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 7197c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 7207c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 7217c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 7227c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 7237c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 7247c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 7257c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 7267c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 7277c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 7287c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 7297c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 7307c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 7317c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 7327c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (Idx->getType()->isSigned()) 7337c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 7347c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 7357c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN); 7367c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 7377c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 7387c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 7397c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 7407c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 7417c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 7427c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 7437c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 7446b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 7451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 7467c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 7471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7487c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 7497c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 7507c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 7517c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 7521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 7551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 7581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 7591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 7601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 7611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 7621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 7641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 765ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 766ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman I.getAlignment()); 7671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 76968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 77068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 77168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 77268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 77368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 7741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 77568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 7761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 7771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 7791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 7801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 7811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 7821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 7831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 7841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 7851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 7861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 7871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 7881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 7891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 7901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 7911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 7921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 794adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs; 795adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(AllocSize.getValueType()); 796adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(MVT::Other); 797adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 798adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getRoot()); 799adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(AllocSize); 800adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getIntPtrConstant(Align)); 801adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 8021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 8031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 8051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 8061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 8071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 80936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner/// getStringValue - Turn an LLVM constant pointer that eventually points to a 81036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner/// global into a string value. Return an empty string if we can't do it. 81136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner/// 81236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattnerstatic std::string getStringValue(Value *V, unsigned Offset = 0) { 81336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) { 81436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (GV->hasInitializer() && isa<ConstantArray>(GV->getInitializer())) { 81536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner ConstantArray *Init = cast<ConstantArray>(GV->getInitializer()); 81636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (Init->isString()) { 81736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::string Result = Init->getAsString(); 81836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (Offset < Result.size()) { 81936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // If we are pointing INTO The string, erase the beginning... 82036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result.erase(Result.begin(), Result.begin()+Offset); 82136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 82236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // Take off the null terminator, and any string fragments after it. 82336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::string::size_type NullPos = Result.find_first_of((char)0); 82436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (NullPos != std::string::npos) 82536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Result.erase(Result.begin()+NullPos, Result.end()); 82636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner return Result; 82736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 82836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 82936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 83036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } else if (Constant *C = dyn_cast<Constant>(V)) { 83136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) 83236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner return getStringValue(GV, Offset); 83336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 83436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr) { 83536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // Turn a gep into the specified offset. 83636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner if (CE->getNumOperands() == 3 && 83736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner cast<Constant>(CE->getOperand(1))->isNullValue() && 83836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner isa<ConstantInt>(CE->getOperand(2))) { 83936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner return getStringValue(CE->getOperand(0), 84036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Offset+cast<ConstantInt>(CE->getOperand(2))->getRawValue()); 84136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 84236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 84336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 84436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 84536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner return ""; 84636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner} 8471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 8491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 850edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 851d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 852d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 853d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 854d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 855d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 856d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 857d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 8585fbb5d2459a5410590f285250faa604576308a93Nate Begeman 8595fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 8605fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 8615fbb5d2459a5410590f285250faa604576308a93Nate Begeman 8628cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 8634ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman unsigned NumElements = PTy->getNumElements(); 8644ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 865f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman MVT::ValueType TVT = MVT::getVectorType(PVT, NumElements); 8664ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman 8674ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // Immediately scalarize packed types containing only one element, so that 8684ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman // the Legalize pass does not have to deal with them. 8694ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman if (NumElements == 1) { 8704ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman L = DAG.getLoad(PVT, Root, Ptr, DAG.getSrcValue(I.getOperand(0))); 871f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman } else if (TVT != MVT::Other && TLI.isTypeLegal(TVT)) { 872f43a3ca26d7bf431be5cdfb5963350a158e840afNate Begeman L = DAG.getLoad(TVT, Root, Ptr, DAG.getSrcValue(I.getOperand(0))); 8734ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } else { 8744ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman L = DAG.getVecLoad(NumElements, PVT, Root, Ptr, 8754ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman DAG.getSrcValue(I.getOperand(0))); 8764ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman } 8775fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 8785fbb5d2459a5410590f285250faa604576308a93Nate Begeman L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, 8795fbb5d2459a5410590f285250faa604576308a93Nate Begeman DAG.getSrcValue(I.getOperand(0))); 8805fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 881d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner setValue(&I, L); 882d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 883d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 884d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 885d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 886d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 8871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 8901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 8911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 8921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 8931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 894369e6db9b6033bb60519b0ad84afeacc9ec9b416Chris Lattner DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr, 89506ef88472f7bac3512e224974e87a0a456471b82Andrew Lenharth DAG.getSrcValue(I.getOperand(1)))); 8961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 898c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 899c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 900c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 901c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 902c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 903c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 904c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 905c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 906c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 907c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return 0; 908c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return 0; 909c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 910c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 911c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 912c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 913c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 914c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 915c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::memcpy: visitMemIntrinsic(I, ISD::MEMCPY); return 0; 916c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::memset: visitMemIntrinsic(I, ISD::MEMSET); return 0; 917c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::memmove: visitMemIntrinsic(I, ISD::MEMMOVE); return 0; 918c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 919c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::readport: 920c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::readio: { 921c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner std::vector<MVT::ValueType> VTs; 922c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner VTs.push_back(TLI.getValueType(I.getType())); 923c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner VTs.push_back(MVT::Other); 924c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner std::vector<SDOperand> Ops; 925c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Ops.push_back(getRoot()); 926c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Ops.push_back(getValue(I.getOperand(1))); 927c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = DAG.getNode(Intrinsic == Intrinsic::readport ? 928c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner ISD::READPORT : ISD::READIO, VTs, Ops); 929c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 930c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, Tmp); 931c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(Tmp.getValue(1)); 932c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 933c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 934c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::writeport: 935c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::writeio: 936c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(Intrinsic == Intrinsic::writeport ? 937c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner ISD::WRITEPORT : ISD::WRITEIO, MVT::Other, 938c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getRoot(), getValue(I.getOperand(1)), 939c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)))); 940c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 941b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner 94286cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 943b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 944b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_debugger_stop"; 94536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 94636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::string fname = "<unknown>"; 94736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner std::vector<SDOperand> Ops; 94836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 94936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // Input Chain 95036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(getRoot()); 95136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 95236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // line number 95336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(getValue(I.getOperand(2))); 95436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 95536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner // column 95636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner Ops.push_back(getValue(I.getOperand(3))); 95736ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 95886cb643801be1308ba1da7db774b64852a119e94Chris Lattner // filename/working dir 95986cb643801be1308ba1da7db774b64852a119e94Chris Lattner // Pull the filename out of the the compilation unit. 96086cb643801be1308ba1da7db774b64852a119e94Chris Lattner const GlobalVariable *cunit = dyn_cast<GlobalVariable>(I.getOperand(4)); 96186cb643801be1308ba1da7db774b64852a119e94Chris Lattner if (cunit && cunit->hasInitializer()) { 96286cb643801be1308ba1da7db774b64852a119e94Chris Lattner if (ConstantStruct *CS = 96386cb643801be1308ba1da7db774b64852a119e94Chris Lattner dyn_cast<ConstantStruct>(cunit->getInitializer())) { 96486cb643801be1308ba1da7db774b64852a119e94Chris Lattner if (CS->getNumOperands() > 0) { 96586cb643801be1308ba1da7db774b64852a119e94Chris Lattner Ops.push_back(DAG.getString(getStringValue(CS->getOperand(3)))); 966f5395cee6a24699a016b2e379cf4804b09ce5030Jim Laskey Ops.push_back(DAG.getString(getStringValue(CS->getOperand(4)))); 96786cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 96886cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 96986cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 97086cb643801be1308ba1da7db774b64852a119e94Chris Lattner 97186cb643801be1308ba1da7db774b64852a119e94Chris Lattner if (Ops.size() == 5) // Found filename/workingdir. 97286cb643801be1308ba1da7db774b64852a119e94Chris Lattner DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops)); 973d67b3a8bf75d4d3c50263960a9375e6856588f2cChris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 974b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 97536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 976c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_region_start: 977b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 978b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_dbg_region_start"; 979b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 980b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 981b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 982c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_region_end: 983b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 984b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_dbg_region_end"; 985b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 986b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 987b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 988c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_func_start: 989b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions()) 990b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return "llvm_dbg_subprogram"; 991b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner if (I.getType() != Type::VoidTy) 992b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 993b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 994c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::dbg_declare: 995c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (I.getType() != Type::VoidTy) 996c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType()))); 997c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 998c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 9990b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f32: 10000b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f64: 1001c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 1002c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 1003c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1004c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 10050b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 10060b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 1007c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 1008c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1009c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1010c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1011c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 1012c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1013c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 1014c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1015c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 10168b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 10178b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<MVT::ValueType> VTs; 10188b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::i64); 10198b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::Other); 10208b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<SDOperand> Ops; 10218b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth Ops.push_back(getRoot()); 10228b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, VTs, Ops); 10238b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 10248b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 102551b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 10268b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 1027d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 1028d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 1029d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 1030d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 1031d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 1032d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 1033d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 10340b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 10350b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 10360b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 10370b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 1038c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 1039c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1040c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1041c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 10420b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 10430b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 10440b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 10450b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 1046c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 1047c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1048c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1049c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 10500b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 10510b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 10520b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 10530b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 1054c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 1055c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1056c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1057c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1058140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 1059140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<MVT::ValueType> VTs; 1060140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(TLI.getPointerTy()); 1061140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(MVT::Other); 1062140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<SDOperand> Ops; 1063140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Ops.push_back(getRoot()); 1064140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, VTs, Ops); 1065140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 1066140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 1067140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 1068140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 106939a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 107039a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 107139a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 1072140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 107339a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 1074ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 1075ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 1076ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 1077c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner default: 1078c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner std::cerr << I; 1079c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner assert(0 && "This intrinsic is not implemented yet!"); 1080c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1081c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1082c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 1083c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 1084c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 10851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 108664e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 1087c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 1088c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 1089c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 1090c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 1091c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 1092c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 1093c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 1094c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 1095c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 1096c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1097c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1098c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1099c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1100c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 1101c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 1102c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1103c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 1104f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1105f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1106d12b2d7b5ae73c6f1b89a30f12e9d30e731b2e20Chris Lattner I.getType() == I.getOperand(1)->getType() && 1107d12b2d7b5ae73c6f1b89a30f12e9d30e731b2e20Chris Lattner TLI.isOperationLegal(ISD::FSIN, 1108d12b2d7b5ae73c6f1b89a30f12e9d30e731b2e20Chris Lattner TLI.getValueType(I.getOperand(1)->getType()))) { 1109c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1110f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 1111f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1112f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1113c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 1114f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1115f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1116d12b2d7b5ae73c6f1b89a30f12e9d30e731b2e20Chris Lattner I.getType() == I.getOperand(1)->getType() && 1117d12b2d7b5ae73c6f1b89a30f12e9d30e731b2e20Chris Lattner TLI.isOperationLegal(ISD::FCOS, 1118d12b2d7b5ae73c6f1b89a30f12e9d30e731b2e20Chris Lattner TLI.getValueType(I.getOperand(1)->getType()))) { 1119c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1120f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 1121f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1122f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1123f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1124c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1125c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1126edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 112764e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 112864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 112964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 113064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 113164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 11321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1133c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 11341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 11351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 11361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 11371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 11381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1139edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 11408e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 11418e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 1142edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1143cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 11449092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 1145adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 11461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 1147cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 1148cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 11491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 11521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 11531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 115568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 115668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 115768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 115868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 115968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 11601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 11621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType()); 11631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 11641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 11651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 11671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType())); 1168cf5734dddd66af9388a171b44996505ede47feedChris Lattner 1169cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 1170adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 1171cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 1172cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 1173cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 1174cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 11751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 11781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 11791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 11801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetData().getIntPtrType())); 11811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 1182cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 1183adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 1184cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 1185cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 11861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1188025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 1189025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 1190025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 1191025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 1192025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 1193025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 1194025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 1195025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 1196025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 1197025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 1198025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 1199025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 1200025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 1201025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 12024a95945fa5aa431110f50092f4a45d24772a553bNate BegemanSDOperand TargetLowering::LowerReturnTo(SDOperand Chain, SDOperand Op, 12034a95945fa5aa431110f50092f4a45d24772a553bNate Begeman SelectionDAG &DAG) { 12044a95945fa5aa431110f50092f4a45d24772a553bNate Begeman return DAG.getNode(ISD::RET, MVT::Other, Chain, Op); 12054a95945fa5aa431110f50092f4a45d24772a553bNate Begeman} 12064a95945fa5aa431110f50092f4a45d24772a553bNate Begeman 1207e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVAStart(SDOperand Chain, 1208e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand VAListP, Value *VAListV, 1209e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SelectionDAG &DAG) { 12101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 12111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 121239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 12131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 1214e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner return SDOperand(); 12151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1217e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVAEnd(SDOperand Chain, SDOperand LP, Value *LV, 121839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner SelectionDAG &DAG) { 121939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner // Default to a noop. 122039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return Chain; 122139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 122239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 1223e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerSDOperand TargetLowering::LowerVACopy(SDOperand Chain, 1224e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand SrcP, Value *SrcV, 1225e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand DestP, Value *DestV, 1226e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SelectionDAG &DAG) { 1227e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner // Default to copying the input list. 1228e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand Val = DAG.getLoad(getPointerTy(), Chain, 1229e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SrcP, DAG.getSrcValue(SrcV)); 1230213e557cef3e653e2d3a00b07b137c143128430aAndrew Lenharth SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1), 1231e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner Val, DestP, DAG.getSrcValue(DestV)); 1232e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner return Result; 123339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 123439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 123539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand,SDOperand> 1236e64e72b794cfa385372436b3c88460aeee0acbf6Chris LattnerTargetLowering::LowerVAArg(SDOperand Chain, SDOperand VAListP, Value *VAListV, 1237e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner const Type *ArgTy, SelectionDAG &DAG) { 12381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // We have no sane default behavior, just emit a useful error message and bail 12391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // out. 124039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::cerr << "Variable arguments handling not implemented on this target!\n"; 12411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 1242d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return std::make_pair(SDOperand(), SDOperand()); 12431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 124439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 124539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 124639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 1247e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner DAG.setRoot(TLI.LowerVAStart(getRoot(), getValue(I.getOperand(1)), 1248e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner I.getOperand(1), DAG)); 124939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 125039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 12511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 125239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 1253e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner TLI.LowerVAArg(getRoot(), getValue(I.getOperand(0)), I.getOperand(0), 1254558bc88a00930fce283b240b7c9555f649a18f1bAndrew Lenharth I.getType(), DAG); 125539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 125639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 12571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 126000b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen DAG.setRoot(TLI.LowerVAEnd(getRoot(), getValue(I.getOperand(1)), 1261e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner I.getOperand(1), DAG)); 12621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 1265e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner SDOperand Result = 1266e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner TLI.LowerVACopy(getRoot(), getValue(I.getOperand(2)), I.getOperand(2), 1267e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner getValue(I.getOperand(1)), I.getOperand(1), DAG); 1268e64e72b794cfa385372436b3c88460aeee0acbf6Chris Lattner DAG.setRoot(Result); 12691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 127239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 127339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 127439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 127539ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 127639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 127739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 12781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 128050381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 1281171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 1282171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 1283d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 1284171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 1285171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 128639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 128739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 128839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 1289a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 129039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 129139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 129239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 12931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12947041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 12956ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer#if 0 12966ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer // If the size of the cpy/move/set is constant (known) 12976ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer if (ConstantUInt* op3 = dyn_cast<ConstantUInt>(I.getOperand(3))) { 12986ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer uint64_t size = op3->getValue(); 12996ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer switch (Op) { 13006ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer case ISD::MEMSET: 13016ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer if (size <= TLI.getMaxStoresPerMemSet()) { 13026ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer if (ConstantUInt* op4 = dyn_cast<ConstantUInt>(I.getOperand(4))) { 13036ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 13046ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer uint64_t align = op4.getValue(); 13056ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer while (size > align) { 13066ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer size -=align; 13076ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer } 13086ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer Value *SrcV = I.getOperand(0); 13096ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer SDOperand Src = getValue(SrcV); 13106ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer SDOperand Ptr = getValue(I.getOperand(1)); 13116ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr, 13126ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer DAG.getSrcValue(I.getOperand(1)))); 13136ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer } 13146ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer break; 13156ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer } 13166ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer break; // don't do this optimization, use a normal memset 13176ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer case ISD::MEMMOVE: 13186ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer case ISD::MEMCPY: 13196ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer break; // FIXME: not implemented yet 13206ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer } 13216ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer } 13226ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer#endif 13236ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer 13246ff7240a5c484af6e42e2ba6a6d7e03ddf844922Reid Spencer // Non-optimized version 13257041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner std::vector<SDOperand> Ops; 1326a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner Ops.push_back(getRoot()); 13277041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(1))); 13287041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(2))); 13297041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(3))); 13307041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner Ops.push_back(getValue(I.getOperand(4))); 13317041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops)); 13321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13347041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 13357041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 13367041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 13371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 13391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 13401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1342495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 134336b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 134436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 1345495a0b51915eb763576874f29192820b731edc22Chris Lattner} 13461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1347c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1348c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 1349c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// casting to the type of GEPI. 1350c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattnerstatic Value *InsertGEPComputeCode(Value *&V, BasicBlock *BB, Instruction *GEPI, 1351c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr, Value *PtrOffset) { 1352c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (V) return V; // Already computed. 1353c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1354c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock::iterator InsertPt; 1355c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (BB == GEPI->getParent()) { 1356c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If insert into the GEP's block, insert right after the GEP. 1357c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner InsertPt = GEPI; 1358c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ++InsertPt; 1359c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 1360c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 1361c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner InsertPt = BB->begin(); 1362c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 1363c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1364c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1365c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 1366c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // BB so that there is only one value live across basic blocks (the cast 1367c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // operand). 1368c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 1369c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 1370c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Ptr = new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 1371c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 1372c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Add the offset, cast it to the right type. 1373c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 1374c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = new CastInst(Ptr, GEPI->getType(), "", InsertPt); 1375c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner return V = Ptr; 1376c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 1377c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1378c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1379c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 1380c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 1381c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 1382c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 1383c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 1384c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 1385c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattnerstatic void OptimizeGEPExpression(GetElementPtrInst *GEPI, 1386c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const TargetData &TD) { 1387c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 1388c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 1389c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 1390c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 1391c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 1392c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 1393c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 1394c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 1395c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 1396c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1397c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1398c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (!isUsedOutsideDefBB) return; 1399c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1400c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 1401c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 1402c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 1403c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 1404c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 1405c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) 1406c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue()) { 1407c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 1408c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 1409c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1410c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 14113802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 14123802c2552fe4475418db3c948e7601d7259f996dChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) return; 1413c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1414c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 1415c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 1416c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 1417c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 1418c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr = new CastInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 1419c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 1420c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1421c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 1422c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 1423c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 1424c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 1425c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 1426c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 1427c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset += TD.getStructLayout(StTy)->MemberOffsets[Field]; 1428c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 1429c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 1430c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 1431c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1432c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 1433c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 1434c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue() == 0) continue; 1435c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1436c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 1437c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset += (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 1438c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner else 1439c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset+=TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 1440c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 1441c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1442c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1443c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 1444c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1445c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 1446c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = new CastInst(Idx, UIntPtrTy, "", GEPI); 1447c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1448c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 1449c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 1450c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 1451c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *SizeCst = ConstantUInt::get(UIntPtrTy, ElementSize); 1452c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1453c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 1454c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 1455c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 1456c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1457c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1458c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1459c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 1460c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 1461c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *PtrOffset = ConstantUInt::get(UIntPtrTy, ConstantOffset); 1462c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1463c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 1464c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 1465c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 1466c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 1467c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 1468c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 1469c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 1470c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 1471c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner std::map<BasicBlock*,Value*> InsertedExprs; 1472c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner while (!GEPI->use_empty()) { 1473c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Instruction *User = cast<Instruction>(GEPI->use_back()); 1474c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 1475c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // If this use is not foldable into the addressing mode, use a version 1476c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // emitted in the GEP block. 1477c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Value *NewVal; 1478c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (!isa<LoadInst>(User) && 1479c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner (!isa<StoreInst>(User) || User->getOperand(0) == GEPI)) { 1480c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 1481c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Ptr, PtrOffset); 1482c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner } else { 1483c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // Otherwise, insert the code in the User's block so it can be folded into 1484c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // any users in that block. 1485c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 1486c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner User->getParent(), GEPI, 1487c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr, PtrOffset); 1488c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 1489c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner User->replaceUsesOfWith(GEPI, NewVal); 1490c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner } 1491c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1492c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 1493c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 1494c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 1495c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 14961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 14971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 14981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 14991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 15001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1501c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // First, split all critical edges for PHI nodes with incoming values that are 1502c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constants, this way the load of the constant into a vreg will not be placed 1503c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // into MBBs that are used some other way. 1504c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 1505c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // In this pass we also look for GEP instructions that are used across basic 1506c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // blocks and rewrites them to improve basic-block-at-a-time selection. 1507c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 150836b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 150936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner PHINode *PN; 1510c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock::iterator BBI; 1511c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (BBI = BB->begin(); (PN = dyn_cast<PHINode>(BBI)); ++BBI) 151236b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 151336b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 151436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 1515c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 1516c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (BasicBlock::iterator E = BB->end(); BBI != E; ) 1517c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(BBI++)) 1518c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner OptimizeGEPExpression(GEPI, TLI.getTargetData()); 151936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 1520c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 15211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 15221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 15241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 1525edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 15261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 15271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 15281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1530ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 1531ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 1532f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 153318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 1534d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 153518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 1536d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 1537d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 1538d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 1539d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 1540d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 1541d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SelectionDAG &DAG = SDL.DAG; 1542d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 1543d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 1544d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 1545d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 1546fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 1547fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 1548fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 1549fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 1550d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 1551d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 1552d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 1553d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 1554d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(0, MVT::i32)); 1555d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 1556d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(1, MVT::i32)); 1557d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo); 1558d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 1559d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 15601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 15611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1562068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 1563068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 1564068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 15651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 1566068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 15670afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 1568bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 1569bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 1570bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1571bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 1572bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1573bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 1574bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 1575bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 1576fa57702388f139e964befecb4b98c7dfe836945fChris Lattner 1577bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 1578bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 1579bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 1580bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 1581bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 1582bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 1583bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 15840afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 1585bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1586bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Next, if the function has live ins that need to be copied into vregs, 1587bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // emit the copies now, into the top of the block. 1588bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MachineFunction &MF = SDL.DAG.getMachineFunction(); 1589bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (MF.livein_begin() != MF.livein_end()) { 1590bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SSARegMap *RegMap = MF.getSSARegMap(); 1591bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner const MRegisterInfo &MRI = *MF.getTarget().getRegisterInfo(); 1592bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (MachineFunction::livein_iterator LI = MF.livein_begin(), 1593bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner E = MF.livein_end(); LI != E; ++LI) 1594bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LI->second) 1595bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MRI.copyRegToReg(*MF.begin(), MF.begin()->end(), LI->second, 1596bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LI->first, RegMap->getRegClass(LI->second)); 15971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1598bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 1599bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 1600bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 1601068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 1602068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1603068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1604068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 1605068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 1606068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner FunctionLoweringInfo &FuncInfo) { 1607068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 1608068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 1609068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 1610edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1611bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 1612bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 1613bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 16141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 16161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 16171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 16191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 16201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 16211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 16221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 16241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 16251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 1626f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 1627ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 16281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 1629ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1630ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 16311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 16321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 16341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 16351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 16361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 16371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 16381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 1639edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 16401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 16421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 16431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 16451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 16461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 16471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 16481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 16491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 16501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 16511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 16531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 16541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 16551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 1656f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 1657f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 1658f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 1659f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 1660f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 1661f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 1662f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 1663f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 1664ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1665ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 1666f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 1667f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 1668f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 1669f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 1670ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 1671edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 1672ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 1673ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 1674ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 1675ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 1676ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 1677ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 16781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1679edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1680f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 1681f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 1682f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 1683f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 1684f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 1685f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 16861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 16871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 16881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 16891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1690ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 16915a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 16927436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 16937436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 16947436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 16957436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 16967436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 16977436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 16987436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 16997436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 17007436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 17017436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 17027436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 17037436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 1704ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains)); 1705ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 1706ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 17071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 17081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 1709a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 1710a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 1711a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 17121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 17131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 17151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo) { 1716b2efb853f00d45b1c8d57f92acd0028fbdeffda6Jim Laskey SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 17171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurDAG = &DAG; 17181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 17191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // First step, lower LLVM code to some DAG. This DAG may use operations and 17211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // types that are not supported by the target. 17221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 17231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1724af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 1725af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(false); 17262300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 17271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 17281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 17291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 17311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 1732ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 17331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 17351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 17361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1737af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 1738af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(true); 17392300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 1740a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 1741d48050aa1509130871b8bb2453270c92b969c2e7Chris Lattner 1742a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 1743a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 17441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 17451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 17471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 17481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1749a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 17501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 17511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 17521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 17531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 17541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner "This is not a machine PHI node that we are updating!"); 17551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second); 17561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHI->addMachineBasicBlockOperand(BB); 17571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1758a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner 1759a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Finally, add the CFG edges from the last selected MBB to the successor 1760a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // MBBs. 1761a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 1762a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) { 1763a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[TI->getSuccessor(i)]; 1764a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner BB->addSuccessor(Succ0MBB); 1765a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 17661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1767a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 1768a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 1769a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 1770a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 1771a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 1772a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 17734ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng ScheduleDAG *SL = NULL; 17744ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 17754ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng switch (ISHeuristic) { 17764ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng default: assert(0 && "Unrecognized scheduling heuristic"); 17773f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng case defaultScheduling: 17783f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) 17793f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng SL = createSimpleDAGScheduler(noScheduling, DAG, BB); 17803f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng else /* TargetLowering::SchedulingForRegPressure */ 17813f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng SL = createBURRListDAGScheduler(DAG, BB); 17823f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng break; 17834ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case noScheduling: 17844ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case simpleScheduling: 17854ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case simpleNoItinScheduling: 17864ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng SL = createSimpleDAGScheduler(ISHeuristic, DAG, BB); 17874ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng break; 1788f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng case listSchedulingBURR: 1789f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng SL = createBURRListDAGScheduler(DAG, BB); 17904ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 1791a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 1792a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 1793