SelectionDAGISel.cpp revision 466685d41a9ea4905b9486fea38e83802e46f196
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" 22ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner#include "llvm/InlineAsm.h" 231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 2543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey#include "llvm/IntrinsicInst.h" 26b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner#include "llvm/CodeGen/IntrinsicLowering.h" 27b2efb853f00d45b1c8d57f92acd0028fbdeffda6Jim Laskey#include "llvm/CodeGen/MachineDebugInfo.h" 281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 3037efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 32eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey#include "llvm/CodeGen/SchedulerRegistry.h" 331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 35fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 41124729155d860a0850eb4ef2a7cea4145e13a057Vladimir Prus#include "llvm/Target/TargetOptions.h" 42495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 437c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 45a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 474e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner#include <set> 481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 497e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 52da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 537944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 54a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 55a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 56a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 57a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 58a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 597944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 605e46a19ec848cd4fc9649bd5170c43d9e657668cChris Lattnerstatic const bool ViewISelDAGs = 0, ViewSchedDAGs = 0; 617944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 627944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 63eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 64eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 65eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 66eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// RegisterScheduler class - Track the registration of instruction schedulers. 67eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 68eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 69eb577ba3b815a1fa4627b060dd2345d17abf672dJim LaskeyMachinePassRegistry RegisterScheduler::Registry; 70eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 71eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 72eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 73eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// ISHeuristic command line option for instruction schedulers. 74eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 75eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 764ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Chengnamespace { 77eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey cl::opt<RegisterScheduler::FunctionPassCtor, false, 78eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterPassParser<RegisterScheduler> > 7913ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey ISHeuristic("sched", 803700f90c19f51deae00f85b80d31e1f7fbda1f99Chris Lattner cl::init(&createDefaultScheduler), 8113ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey cl::desc("Instruction schedulers available:")); 8213ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 839ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey static RegisterScheduler 849373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey defaultListDAGScheduler("default", " Best scheduler for the target", 859373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey createDefaultScheduler); 864ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng} // namespace 874ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 88864635ad7b3046d3042311423071152c613961deChris Lattnernamespace { 89864635ad7b3046d3042311423071152c613961deChris Lattner /// RegsForValue - This struct represents the physical registers that a 90864635ad7b3046d3042311423071152c613961deChris Lattner /// particular value is assigned and the type information about the value. 91864635ad7b3046d3042311423071152c613961deChris Lattner /// This is needed because values can be promoted into larger registers and 92864635ad7b3046d3042311423071152c613961deChris Lattner /// expanded into multiple smaller registers than the value. 939525528a7dc5462b6374d38c81ba5c07b11741feChris Lattner struct VISIBILITY_HIDDEN RegsForValue { 94864635ad7b3046d3042311423071152c613961deChris Lattner /// Regs - This list hold the register (for legal and promoted values) 95864635ad7b3046d3042311423071152c613961deChris Lattner /// or register set (for expanded values) that the value should be assigned 96864635ad7b3046d3042311423071152c613961deChris Lattner /// to. 97864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 98864635ad7b3046d3042311423071152c613961deChris Lattner 99864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT - The value type of each register. 100864635ad7b3046d3042311423071152c613961deChris Lattner /// 101864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 102864635ad7b3046d3042311423071152c613961deChris Lattner 103864635ad7b3046d3042311423071152c613961deChris Lattner /// ValueVT - The value type of the LLVM value, which may be promoted from 104864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT or made from merging the two expanded parts. 105864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT; 106864635ad7b3046d3042311423071152c613961deChris Lattner 107864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue() : RegVT(MVT::Other), ValueVT(MVT::Other) {} 108864635ad7b3046d3042311423071152c613961deChris Lattner 109864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(unsigned Reg, MVT::ValueType regvt, MVT::ValueType valuevt) 110864635ad7b3046d3042311423071152c613961deChris Lattner : RegVT(regvt), ValueVT(valuevt) { 111864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 112864635ad7b3046d3042311423071152c613961deChris Lattner } 113864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(const std::vector<unsigned> ®s, 114864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType regvt, MVT::ValueType valuevt) 115864635ad7b3046d3042311423071152c613961deChris Lattner : Regs(regs), RegVT(regvt), ValueVT(valuevt) { 116864635ad7b3046d3042311423071152c613961deChris Lattner } 117864635ad7b3046d3042311423071152c613961deChris Lattner 118864635ad7b3046d3042311423071152c613961deChris Lattner /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from 119864635ad7b3046d3042311423071152c613961deChris Lattner /// this value and returns the result as a ValueVT value. This uses 120864635ad7b3046d3042311423071152c613961deChris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 121864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand getCopyFromRegs(SelectionDAG &DAG, 1229f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const; 123c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 124c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 125c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// specified value into the registers specified by this object. This uses 126c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 127c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 128a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 129a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const; 130c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 131c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// AddInlineAsmOperands - Add this value to the specified inlineasm node 132c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// operand list. This adds the code marker and includes the number of 133c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// values added into it. 134c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 1359f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const; 136864635ad7b3046d3042311423071152c613961deChris Lattner }; 137864635ad7b3046d3042311423071152c613961deChris Lattner} 1384ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 1391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 1401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 1419373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// createDefaultScheduler - This creates an instruction scheduler appropriate 1429373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// for the target. 1439373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey ScheduleDAG* createDefaultScheduler(SelectionDAGISel *IS, 1449373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey SelectionDAG *DAG, 1459373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey MachineBasicBlock *BB) { 1469373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering &TLI = IS->getTargetLowering(); 1479373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1489373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) { 1499373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createTDListDAGScheduler(IS, DAG, BB); 1509373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } else { 1519373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey assert(TLI.getSchedulingPreference() == 1529373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering::SchedulingForRegPressure && "Unknown sched type!"); 1539373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createBURRListDAGScheduler(IS, DAG, BB); 1549373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1559373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1569373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1579373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1589373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey //===--------------------------------------------------------------------===// 1591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 1601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 161f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 162f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 1631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 1651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 1661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 1671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 1691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 1741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 186edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1873c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned CreateRegForValue(const Value *V); 1883c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 1891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 198f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// PHI nodes or outside of the basic block that defines it, or used by a 199f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// switch instruction, which may expand to multiple basic blocks. 2001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 2021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 2031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 204f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI) || 205f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman isa<SwitchInst>(*UI)) 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 2081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 210bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 211f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// entry block, return true. This includes arguments used by switches, since 212f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the switch may expand into multiple basic blocks. 213bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 214bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 215bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 216f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != Entry || isa<SwitchInst>(*UI)) 217bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 218bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 219bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 220bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 222edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 2231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 2241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 225bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 226bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 22716ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 22816ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 229bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 230bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 2311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 232bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 233bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 234bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 2352aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 2361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 2381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) { 2391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 240a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 241ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 242a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson std::max((unsigned)TLI.getTargetData()->getTypeAlignment(Ty), 243ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 244a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 245a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // If the alignment of the value is smaller than the size of the value, 246a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // and if the size of the value is particularly small (<= 8 bytes), 247a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // round up to the size of the value for potentially better performance. 248a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // 249a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // FIXME: This could be made better with a preferred alignment hook in 250a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // TargetData. It serves primarily to 8-byte align doubles for X86. 251a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner if (Align < TySize && TySize <= 8) Align = TySize; 2522dfa8192abaad8a3c29132dba50e8b85218e918cChris Lattner TySize *= CUI->getValue(); // Get total allocated size. 253d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 2541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 255f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 2561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2582aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 2592aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 2611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 2661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 2671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 2682aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 2691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 2701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 2711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 2721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 2741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 277f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 278f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 27970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 28070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NumElements; 28170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) 28270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner NumElements = TLI.getNumElements(VT); 28370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else { 28470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType VT1,VT2; 28570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner NumElements = 28670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 28770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner VT1, VT2); 28870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 289f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 290f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 291f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 292f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 293f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2973c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// CreateRegForValue - Allocate the appropriate number of virtual registers of 2983c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// the correctly promoted or expanded types. Assign these registers 2993c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// consecutive vreg numbers and return the first assigned number. 3003c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattnerunsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) { 3013c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 3023c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3033c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The number of multiples of registers that we need, to, e.g., split up 3043c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // a <2 x int64> -> 4 x i32 registers. 3053c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumVectorRegs = 1; 3063c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3073c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a packed type, figure out what type it will decompose into 3083c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // and how many of the elements it will use. 3093c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (VT == MVT::Vector) { 3103c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner const PackedType *PTy = cast<PackedType>(V->getType()); 3113c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumElts = PTy->getNumElements(); 3123c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType EltTy = TLI.getValueType(PTy->getElementType()); 3133c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3143c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // Divide the input until we get to a supported size. This will always 3153c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // end with a scalar if the target doesn't support vectors. 3163c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (NumElts > 1 && !TLI.isTypeLegal(getVectorType(EltTy, NumElts))) { 3173c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumElts >>= 1; 3183c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumVectorRegs <<= 1; 3193c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3206cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner if (NumElts == 1) 3216cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = EltTy; 3226cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner else 3236cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = getVectorType(EltTy, NumElts); 3243c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3253c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3263c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The common case is that we will only create one register for this 3273c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // value. If we have that case, create and return the virtual register. 3283c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NV = TLI.getNumElements(VT); 3293c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (NV == 1) { 3303c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If we are promoting this value, pick the next largest supported type. 3313c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType PromotedType = TLI.getTypeToTransformTo(VT); 3323c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned Reg = MakeReg(PromotedType); 3333c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a vector of supported or promoted types (e.g. 4 x i16), 3343c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // create all of the registers. 3353c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NumVectorRegs; ++i) 3363c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg(PromotedType); 3373c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return Reg; 3383c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3393c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3403c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this value is represented with multiple target registers, make sure 3413c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // to create enough consecutive registers of the right (smaller) type. 3423c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NT = VT-1; // Find the type to use. 3433c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 3443c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner --NT; 3453c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3463c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 3473c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NV*NumVectorRegs; ++i) 3483c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg((MVT::ValueType)NT); 3493c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return R; 3503c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner} 3511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 3531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 3541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 3551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 3561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 3571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 3581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 3591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 3601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 3621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 363d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 364d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 365d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 366d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 367d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 368d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 369f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Case - A pair of values to record the Value for a switch case, and the 370f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// case's target basic block. 371f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<Constant*, MachineBasicBlock*> Case; 372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::vector<Case>::iterator CaseItr; 373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<CaseItr, CaseItr> CaseRange; 374f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 375f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseRec - A struct with ctor used in lowering switches to a binary tree 376f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// of conditional branches. 377f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseRec { 378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec(MachineBasicBlock *bb, Constant *lt, Constant *ge, CaseRange r) : 379f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseBB(bb), LT(lt), GE(ge), Range(r) {} 380f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseBB - The MBB in which to emit the compare and branch 382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *CaseBB; 383f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// LT, GE - If nonzero, we know the current case value must be less-than or 384f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// greater-than-or-equal-to these Constants. 385f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *LT; 386f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *GE; 387f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Range - A pair of iterators representing the range of case values to be 388f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// processed at this point in the binary search tree. 389f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange Range; 390f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 391f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 392f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// The comparison function for sorting Case values. 393f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 394f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman bool operator () (const Case& C1, const Case& C2) { 395f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (const ConstantUInt* U1 = dyn_cast<const ConstantUInt>(C1.first)) 396f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return U1->getValue() < cast<const ConstantUInt>(C2.first)->getValue(); 397f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 398f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const ConstantSInt* S1 = dyn_cast<const ConstantSInt>(C1.first); 399f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return S1->getValue() < cast<const ConstantSInt>(C2.first)->getValue(); 400f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 401f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 402f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 4051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 4071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 4081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 409a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD; 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 411f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 412f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 413f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 41437efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGISel::JumpTable JT; 415f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 421edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 4221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 4239453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT(0,0,0,0), FuncInfo(funcinfo) { 4241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 426a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 427a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 428a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 429d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 430d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 431edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 432d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 433d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 434d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 435d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 436d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 437d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 438d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 439d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 440bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, 441bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &PendingLoads[0], PendingLoads.size()); 442d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 443d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 444d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 445a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 446a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 4471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 46228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 463466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 46428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile); 4651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 470199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4774e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 478864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue GetRegistersForValue(const std::string &ConstrCode, 479864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, 480864635ad7b3046d3042311423071152c613961deChris Lattner bool OutReg, bool InReg, 481864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 482864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &InputRegs); 483f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 4851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 4861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 487f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 490f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Helper for visitSwitch 491f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 49237efe6764568a3829fee26aba532283131d1a104Nate Begeman void visitJumpTable(SelectionDAGISel::JumpTable &JT); 493f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 4951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 4961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 4971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4985fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitBinary(User &I, unsigned IntOp, unsigned FPOp, unsigned VecOp); 499e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 5005fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 5015fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::ADD, ISD::FADD, ISD::VADD); 50201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 503b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 5045fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitMul(User &I) { 5055fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::MUL, ISD::FMUL, ISD::VMUL); 50601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 5071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 50801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 5093e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng visitBinary(I, 5103e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng Ty->isSigned() ? ISD::SDIV : ISD::UDIV, ISD::FDIV, 5113e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng Ty->isSigned() ? ISD::VSDIV : ISD::VUDIV); 5121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 51401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 5155fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SREM : ISD::UREM, ISD::FREM, 0); 5161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5173e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitAnd(User &I) { visitBinary(I, ISD::AND, 0, ISD::VAND); } 5183e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitOr (User &I) { visitBinary(I, ISD::OR, 0, ISD::VOR); } 5193e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitXor(User &I) { visitBinary(I, ISD::XOR, 0, ISD::VXOR); } 520e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShl(User &I) { visitShift(I, ISD::SHL); } 521e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShr(User &I) { 522e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman visitShift(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 5231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 525f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc, 526f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::CondCode FPOpc); 527f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ, 528f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOEQ); } 529f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE, 530f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETUNE); } 531f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE, 532f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOLE); } 533f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE, 534f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOGE); } 535f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT, 536f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOLT); } 537f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT, 538f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOGT); } 5391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5402bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5412bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 5423e104b11168da4692b69cc6b236c1da22adff959Chris Lattner void visitShuffleVector(User &I); 543c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 5461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 555ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner void visitInlineAsm(CallInst &I); 556c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 5570eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 5581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 5601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 5611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 5621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 56339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 5641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5657041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 5661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 5681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 5691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 5731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 5761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 5771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 578199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 579199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 580199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 581199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 582199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 583199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 584199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 585199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 586199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 587199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 588199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 589199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 590199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 591199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 592199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 593199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 59423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner if (!isa<PackedType>(VTy)) 59523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 59623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 597b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR of undef nodes. 59823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner const PackedType *PTy = cast<PackedType>(VTy); 59923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 60023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 60123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 602bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 60323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 60423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 60523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 60623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 60723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 608bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, 609bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 610199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 611199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 612199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (const PackedType *PTy = dyn_cast<PackedType>(VTy)) { 613199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 614199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 615199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 616199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 617199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 618199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // the packed constant. 619bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 620199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) { 6212bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 6222bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 623199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 624199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 625199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 626199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 627199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 628199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 629199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 630199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 631199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 632199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 633b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR node with generic Vector type. 63423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 63523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 636bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR,MVT::Vector,&Ops[0],Ops.size()); 637199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 638199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 639199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 640199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 641199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 642199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 643199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 644199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 645199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 646199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 647199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 648199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 649199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 650199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 651199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.ValueMap.find(V); 652199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 653199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 654199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned InReg = VMI->second; 655199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 656199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // If this type is not legal, make it so now. 65770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) { 65870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 659199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 66070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 66170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (DestVT < VT) { 66270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Source must be expanded. This input value is actually coming from the 66370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // register pair VMI->second and VMI->second+1. 66470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 66570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 66670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (DestVT > VT) { // Promotion case 667199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(VT)) 668199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::FP_ROUND, VT, N); 669199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 670199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::TRUNCATE, VT, N); 671199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 67270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 67370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Otherwise, if this is a vector, make it available as a generic vector 67470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // here. 67570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 6762e2ef9535070bb352601482cceac1140c1158cddChris Lattner const PackedType *PTy = cast<PackedType>(VTy); 6772e2ef9535070bb352601482cceac1140c1158cddChris Lattner unsigned NE = TLI.getPackedTypeBreakdown(PTy, PTyElementVT, 67870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyLegalElementVT); 67970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 68070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Build a VBUILD_VECTOR with the input registers. 681bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 68270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 68370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the value types are legal, just VBUILD the CopyFromReg nodes. 68470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) 68570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 68670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT)); 68770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyElementVT < PTyLegalElementVT) { 68870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was promoted, use TRUNCATE of FP_ROUND as appropriate. 68970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 69070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 69170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 69270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyElementVT)) 69370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::FP_ROUND, PTyElementVT, Op); 69470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 69570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::TRUNCATE, PTyElementVT, Op); 69670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(Op); 69770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 69870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 69970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was expanded, use BUILD_PAIR. 70070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner assert((NE & 1) == 0 && "Must expand into a multiple of 2 elements!"); 70170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE/2; ++i) { 70270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op0 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 70370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 70470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op1 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 70570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 70670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Op0, Op1)); 70770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 70870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 70970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 71070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getConstant(NE, MVT::i32)); 71170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getValueType(PTyLegalElementVT)); 712bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, &Ops[0], Ops.size()); 7132e2ef9535070bb352601482cceac1140c1158cddChris Lattner 7142e2ef9535070bb352601482cceac1140c1158cddChris Lattner // Finally, use a VBIT_CONVERT to make this available as the appropriate 7152e2ef9535070bb352601482cceac1140c1158cddChris Lattner // vector type. 7162e2ef9535070bb352601482cceac1140c1158cddChris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 7172e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getConstant(PTy->getNumElements(), 7182e2ef9535070bb352601482cceac1140c1158cddChris Lattner MVT::i32), 7192e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getValueType(TLI.getValueType(PTy->getElementType()))); 720199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 721199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 722199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 723199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 724199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 725199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 7261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 7271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 728a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 7291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 7301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 731bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> NewValues; 732ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 733ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 734ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 7358e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng bool isSigned = I.getOperand(i)->getType()->isSigned(); 736ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman 737ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // If this is an integer return value, we need to promote it ourselves to 738ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // the full width of a register, since LegalizeOp will use ANY_EXTEND rather 739ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // than sign/zero. 7408e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // FIXME: C calling convention requires the return type to be promoted to 7418e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // at least 32-bit. But this is not necessary for non-C calling conventions. 742ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (MVT::isInteger(RetOp.getValueType()) && 743ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp.getValueType() < MVT::i64) { 744ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman MVT::ValueType TmpVT; 745ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 746ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = TLI.getTypeToTransformTo(MVT::i32); 747ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 748ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = MVT::i32; 7491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7508e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng if (isSigned) 751ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, RetOp); 752ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 753ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, RetOp); 754ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 755ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(RetOp); 7568e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng NewValues.push_back(DAG.getConstant(isSigned, MVT::i32)); 7571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 758bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, 759bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &NewValues[0], NewValues.size())); 7601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 7631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 7641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 765f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(Succ0MBB); 7661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 7681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 7691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 7701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 7711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 7721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 7741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 7751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 776a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 777dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 7781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 7791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 780f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(Succ1MBB); 7811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 7831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 7841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 7851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 786a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 787dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ0MBB))); 7881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 7891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 7901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 7911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 7921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 793a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 794dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ1MBB))); 7951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 796e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 797e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 798298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // If the false case is the current basic block, then this is a self 799298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // loop. We do not want to emit "Loop: ... brcond Out; br Loop", as it 800298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // adds an extra instruction in the loop. Instead, invert the 801298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // condition and emit "Loop: ... br!cond Loop; br Out. 802298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng if (CurMBB == Succ1MBB) { 803298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng std::swap(Succ0MBB, Succ1MBB); 804298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng SDOperand True = DAG.getConstant(1, Cond.getValueType()); 805298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 806298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng } 80781e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman SDOperand True = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 80881e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.getBasicBlock(Succ0MBB)); 80981e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, True, 81081e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.getBasicBlock(Succ1MBB))); 8111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 8121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 8131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 8141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 815f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 816f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 817f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 818f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand SwitchOp = getValue(CB.SwitchV); 819f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand CaseOp = getValue(CB.CaseC); 820f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand Cond = DAG.getSetCC(MVT::i1, SwitchOp, CaseOp, CB.CC); 821f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 822f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 823f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 824f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 825f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 826f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 827f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 828f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 829f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 830f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 831f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CB.LHSBB == NextBlock) { 832f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::swap(CB.LHSBB, CB.RHSBB); 833f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 834f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 835f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 836f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 837f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(CB.LHSBB)); 838f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CB.RHSBB == NextBlock) 839f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 840f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 841f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 842f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(CB.RHSBB))); 843f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 844f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(CB.LHSBB); 845f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(CB.RHSBB); 846f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 847f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 84837efe6764568a3829fee26aba532283131d1a104Nate Begemanvoid SelectionDAGLowering::visitJumpTable(SelectionDAGISel::JumpTable &JT) { 84937efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code for the jump table 85037efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType PTy = TLI.getPointerTy(); 8518825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng assert((PTy == MVT::i32 || PTy == MVT::i64) && 8528825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng "Jump table entries are 32-bit values"); 8532ae5b87996dca039d0721f1c463835f726979030Evan Cheng bool isPIC = TLI.getTargetMachine().getRelocationModel() == Reloc::PIC_; 8548825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng // PIC jump table entries are 32-bit values. 8552ae5b87996dca039d0721f1c463835f726979030Evan Cheng unsigned EntrySize = isPIC ? 4 : MVT::getSizeInBits(PTy)/8; 85637efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand Copy = DAG.getCopyFromReg(getRoot(), JT.Reg, PTy); 85737efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand IDX = DAG.getNode(ISD::MUL, PTy, Copy, 8588825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng DAG.getConstant(EntrySize, PTy)); 8592f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman SDOperand TAB = DAG.getJumpTable(JT.JTI,PTy); 8602f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman SDOperand ADD = DAG.getNode(ISD::ADD, PTy, IDX, TAB); 8612ae5b87996dca039d0721f1c463835f726979030Evan Cheng SDOperand LD = DAG.getLoad(isPIC ? MVT::i32 : PTy, Copy.getValue(1), ADD, 862466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng NULL, 0); 8632ae5b87996dca039d0721f1c463835f726979030Evan Cheng if (isPIC) { 86416113431e84bb8adba21fc73bb5715a1297000aeAndrew Lenharth // For Pic, the sequence is: 86516113431e84bb8adba21fc73bb5715a1297000aeAndrew Lenharth // BRIND(load(Jumptable + index) + RelocBase) 86616113431e84bb8adba21fc73bb5715a1297000aeAndrew Lenharth // RelocBase is the JumpTable on PPC and X86, GOT on Alpha 867beec30eaf301bd6882cd06800b5175b94f033f9dAndrew Lenharth SDOperand Reloc = DAG.getNode(ISD::JumpTableRelocBase, PTy, TAB); 8688825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng ADD = DAG.getNode(ISD::ADD, PTy, 869beec30eaf301bd6882cd06800b5175b94f033f9dAndrew Lenharth ((PTy != MVT::i32) ? DAG.getNode(ISD::SIGN_EXTEND, PTy, LD) : LD), Reloc); 8702f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRIND, MVT::Other, LD.getValue(1), ADD)); 8712f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } else { 8722f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRIND, MVT::Other, LD.getValue(1), LD)); 8732f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } 87437efe6764568a3829fee26aba532283131d1a104Nate Begeman} 87537efe6764568a3829fee26aba532283131d1a104Nate Begeman 876f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitch(SwitchInst &I) { 877f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 878f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 879f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 880f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 881f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 882f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 883f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 884f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 885f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (I.getNumOperands() == 2) { 886f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 887f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[I.getDefaultDest()]; 888f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 889f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (DefaultMBB != NextBlock) 890f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 891f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(DefaultMBB))); 892a3bb86dd6b6220c69d9d7e4e11aea42fa1ec2bc5Chris Lattner CurMBB->addSuccessor(DefaultMBB); 893f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 894f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 895f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 896f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 897f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 898f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 899f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<Case> Cases; 900f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 1; i < I.getNumSuccessors(); ++i) { 901f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *SMBB = FuncInfo.MBBMap[I.getSuccessor(i)]; 902f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cases.push_back(Case(I.getSuccessorValue(i), SMBB)); 903f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 904f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::sort(Cases.begin(), Cases.end(), CaseCmp()); 905f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 906f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 907f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 908f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 909f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Value *SV = I.getOperand(0); 910f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Default = FuncInfo.MBBMap[I.getDefaultDest()]; 91137efe6764568a3829fee26aba532283131d1a104Nate Begeman 91237efe6764568a3829fee26aba532283131d1a104Nate Begeman // Get the MachineFunction which holds the current MBB. This is used during 91337efe6764568a3829fee26aba532283131d1a104Nate Begeman // emission of jump tables, and when inserting any additional MBBs necessary 91437efe6764568a3829fee26aba532283131d1a104Nate Begeman // to represent the switch. 915f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction *CurMF = CurMBB->getParent(); 916f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const BasicBlock *LLVMBB = CurMBB->getBasicBlock(); 91737efe6764568a3829fee26aba532283131d1a104Nate Begeman 91817c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // If the switch has more than 5 blocks, and at least 31.25% dense, and the 91917c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // target supports indirect branches, then emit a jump table rather than 92017c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // lowering the switch to a binary tree of conditional branches. 9219453eea49bca1c3904047db495855c93e001d1cdNate Begeman if (TLI.isOperationLegal(ISD::BRIND, TLI.getPointerTy()) && 922f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman Cases.size() > 5) { 92337efe6764568a3829fee26aba532283131d1a104Nate Begeman uint64_t First = cast<ConstantIntegral>(Cases.front().first)->getRawValue(); 92437efe6764568a3829fee26aba532283131d1a104Nate Begeman uint64_t Last = cast<ConstantIntegral>(Cases.back().first)->getRawValue(); 925f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman double Density = (double)Cases.size() / (double)((Last - First) + 1ULL); 926f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 92717c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman if (Density >= 0.3125) { 92837efe6764568a3829fee26aba532283131d1a104Nate Begeman // Create a new basic block to hold the code for loading the address 92937efe6764568a3829fee26aba532283131d1a104Nate Begeman // of the jump table, and jumping to it. Update successor information; 93037efe6764568a3829fee26aba532283131d1a104Nate Begeman // we will either branch to the default case for the switch, or the jump 93137efe6764568a3829fee26aba532283131d1a104Nate Begeman // table. 93237efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *JumpTableBB = new MachineBasicBlock(LLVMBB); 93337efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMF->getBasicBlockList().insert(BBI, JumpTableBB); 93437efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(Default); 93537efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(JumpTableBB); 93637efe6764568a3829fee26aba532283131d1a104Nate Begeman 93737efe6764568a3829fee26aba532283131d1a104Nate Begeman // Subtract the lowest switch case value from the value being switched on 93837efe6764568a3829fee26aba532283131d1a104Nate Begeman // and conditional branch to default mbb if the result is greater than the 93937efe6764568a3829fee26aba532283131d1a104Nate Begeman // difference between smallest and largest cases. 94037efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SwitchOp = getValue(SV); 94137efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType VT = SwitchOp.getValueType(); 94237efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 94337efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(First, VT)); 94437efe6764568a3829fee26aba532283131d1a104Nate Begeman 94537efe6764568a3829fee26aba532283131d1a104Nate Begeman // The SDNode we just created, which holds the value being switched on 94637efe6764568a3829fee26aba532283131d1a104Nate Begeman // minus the the smallest case value, needs to be copied to a virtual 94737efe6764568a3829fee26aba532283131d1a104Nate Begeman // register so it can be used as an index into the jump table in a 94837efe6764568a3829fee26aba532283131d1a104Nate Begeman // subsequent basic block. This value may be smaller or larger than the 94937efe6764568a3829fee26aba532283131d1a104Nate Begeman // target's pointer type, and therefore require extension or truncating. 95037efe6764568a3829fee26aba532283131d1a104Nate Begeman if (VT > TLI.getPointerTy()) 95137efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::TRUNCATE, TLI.getPointerTy(), SUB); 95237efe6764568a3829fee26aba532283131d1a104Nate Begeman else 95337efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), SUB); 95437efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JumpTableReg = FuncInfo.MakeReg(TLI.getPointerTy()); 95537efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CopyTo = DAG.getCopyToReg(getRoot(), JumpTableReg, SwitchOp); 95637efe6764568a3829fee26aba532283131d1a104Nate Begeman 95737efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the range check for the jump table, and branch to the default 95837efe6764568a3829fee26aba532283131d1a104Nate Begeman // block for the switch statement if the value being switched on exceeds 95937efe6764568a3829fee26aba532283131d1a104Nate Begeman // the largest case in the switch. 96037efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CMP = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 96137efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(Last-First,VT), ISD::SETUGT); 96237efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, CMP, 96337efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getBasicBlock(Default))); 96437efe6764568a3829fee26aba532283131d1a104Nate Begeman 965f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Build a vector of destination BBs, corresponding to each target 966f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // of the jump table. If the value of the jump table slot corresponds to 967f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // a case statement, push the case's BB onto the vector, otherwise, push 968f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // the default BB. 96937efe6764568a3829fee26aba532283131d1a104Nate Begeman std::vector<MachineBasicBlock*> DestBBs; 970f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman uint64_t TEI = First; 971f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman for (CaseItr ii = Cases.begin(), ee = Cases.end(); ii != ee; ++TEI) { 972f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (cast<ConstantIntegral>(ii->first)->getRawValue() == TEI) { 973f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman DestBBs.push_back(ii->second); 974f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman ++ii; 975f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } else { 976f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman DestBBs.push_back(Default); 977f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 97837efe6764568a3829fee26aba532283131d1a104Nate Begeman } 979f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 980f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Update successor info 981c66764c00756d800aede2fd32d55658a236b1912Chris Lattner for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(), 982c66764c00756d800aede2fd32d55658a236b1912Chris Lattner E = DestBBs.end(); I != E; ++I) 983c66764c00756d800aede2fd32d55658a236b1912Chris Lattner JumpTableBB->addSuccessor(*I); 984f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 985f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Create a jump table index for this jump table, or return an existing 986f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // one. 98737efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JTI = CurMF->getJumpTableInfo()->getJumpTableIndex(DestBBs); 98837efe6764568a3829fee26aba532283131d1a104Nate Begeman 98937efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the jump table information so that we can codegen it as a second 99037efe6764568a3829fee26aba532283131d1a104Nate Begeman // MachineBasicBlock 99137efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.Reg = JumpTableReg; 99237efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.JTI = JTI; 99337efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.MBB = JumpTableBB; 9949453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT.Default = Default; 99537efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 99637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 99737efe6764568a3829fee26aba532283131d1a104Nate Begeman } 998f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 999f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Push the initial CaseRec onto the worklist 1000f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<CaseRec> CaseVec; 1001f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 1002f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1003f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman while (!CaseVec.empty()) { 1004f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Grab a record representing a case range to process off the worklist 1005f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec CR = CaseVec.back(); 1006f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.pop_back(); 1007f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1008f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Size is the number of Cases represented by this range. If Size is 1, 1009f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // then we are processing a leaf of the binary search tree. Otherwise, 1010f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // we need to pick a pivot, and push left and right ranges onto the 1011f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // worklist. 1012f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman unsigned Size = CR.Range.second - CR.Range.first; 1013f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1014f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (Size == 1) { 1015f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1016f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the Case's target mbb if the value being switched on SV is equal 1017f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // to C. Otherwise, branch to default. 1018f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = CR.Range.first->first; 1019f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Target = CR.Range.first->second; 1020f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, C, Target, Default, 1021f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CR.CaseBB); 1022f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the MBB representing the leaf node is the current MBB, then just 1023f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // call visitSwitchCase to emit the code into the current block. 1024f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, push the CaseBlock onto the vector to be later processed 1025f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // by SDISel, and insert the node's MBB before the next MBB. 1026f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1027f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1028f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else { 1029f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1030f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMF->getBasicBlockList().insert(BBI, CR.CaseBB); 1031f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1032f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1033f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // split case range at pivot 1034f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseItr Pivot = CR.Range.first + (Size / 2); 1035f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange LHSR(CR.Range.first, Pivot); 1036f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange RHSR(Pivot, CR.Range.second); 1037f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = Pivot->first; 1038f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *RHSBB = 0, *LHSBB = 0; 1039f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // We know that we branch to the LHS if the Value being switched on is 1040f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // less than the Pivot value, C. We use this to optimize our binary 1041f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // tree a bit, by recognizing that if SV is greater than or equal to the 1042f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // LHS's Case Value, and that Case Value is exactly one less than the 1043f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Pivot's Value, then we can branch directly to the LHS's Target, 1044f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // rather than creating a leaf node for it. 1045f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((LHSR.second - LHSR.first) == 1 && 1046f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSR.first->first == CR.GE && 1047f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman cast<ConstantIntegral>(C)->getRawValue() == 1048f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman (cast<ConstantIntegral>(CR.GE)->getRawValue() + 1ULL)) { 1049f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSBB = LHSR.first->second; 1050f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1051f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSBB = new MachineBasicBlock(LLVMBB); 1052f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(LHSBB,C,CR.GE,LHSR)); 1053f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1054f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Similar to the optimization above, if the Value being switched on is 1055f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // known to be less than the Constant CR.LT, and the current Case Value 1056f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // is CR.LT - 1, then we can branch directly to the target block for 1057f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the current Case Value, rather than emitting a RHS leaf node for it. 1058f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((RHSR.second - RHSR.first) == 1 && CR.LT && 1059f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman cast<ConstantIntegral>(RHSR.first->first)->getRawValue() == 1060f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman (cast<ConstantIntegral>(CR.LT)->getRawValue() - 1ULL)) { 1061f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman RHSBB = RHSR.first->second; 1062f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1063f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman RHSBB = new MachineBasicBlock(LLVMBB); 1064f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(RHSBB,CR.LT,C,RHSR)); 1065f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1066f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1067f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the LHS node if the value being switched on SV is less than C. 1068f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, branch to LHS. 1069f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman ISD::CondCode CC = C->getType()->isSigned() ? ISD::SETLT : ISD::SETULT; 1070f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(CC, SV, C, LHSBB, RHSBB, CR.CaseBB); 1071f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1072f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1073f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else { 1074f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1075f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMF->getBasicBlockList().insert(BBI, CR.CaseBB); 1076f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1077f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1078f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1079f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1080f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1081b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 1082b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 108301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (I.getType()->isFloatingPoint()) { 108401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 108501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 108601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 108701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 108801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 108901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 109001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 10915fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::SUB, ISD::FSUB, ISD::VSUB); 1092b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 1093b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 10945fbb5d2459a5410590f285250faa604576308a93Nate Begemanvoid SelectionDAGLowering::visitBinary(User &I, unsigned IntOp, unsigned FPOp, 10955fbb5d2459a5410590f285250faa604576308a93Nate Begeman unsigned VecOp) { 10965fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 10971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 10981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 10992c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1100b67eb9131c5c04d2e55c6b587fde954619feceafChris Lattner if (Ty->isIntegral()) { 11015fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(IntOp, Op1.getValueType(), Op1, Op2)); 11025fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else if (Ty->isFloatingPoint()) { 11035fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(FPOp, Op1.getValueType(), Op1, Op2)); 11045fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 11055fbb5d2459a5410590f285250faa604576308a93Nate Begeman const PackedType *PTy = cast<PackedType>(Ty); 1106c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Num = DAG.getConstant(PTy->getNumElements(), MVT::i32); 1107c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Typ = DAG.getValueType(TLI.getValueType(PTy->getElementType())); 1108c7029805ef35ce9805931067b841e6af11db382eChris Lattner setValue(&I, DAG.getNode(VecOp, MVT::Vector, Op1, Op2, Num, Typ)); 11095fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1110e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 11112c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1112e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 1113e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 1114e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 1115e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 1116e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 1117e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 11181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 11191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 1122f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::CondCode UnsignedOpcode, 1123f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::CondCode FPOpcode) { 11241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 11251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 11261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 112780235d508e5f7a9603ef43ba6625984173ff0323Evan Cheng if (!FiniteOnlyFPMath() && I.getOperand(0)->getType()->isFloatingPoint()) 1128f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng Opcode = FPOpcode; 1129f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng else if (I.getOperand(0)->getType()->isUnsigned()) 11301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 11317cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 11321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 11351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 11361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 11371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 1138b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner if (!isa<PackedType>(I.getType())) { 1139b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 1140b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner TrueVal, FalseVal)); 1141b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } else { 1142b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::VSELECT, MVT::Vector, Cond, TrueVal, FalseVal, 1143b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-2), 1144b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-1))); 1145b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } 11461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 11491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 1150e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 115128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 11521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1153e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner if (DestVT == MVT::Vector) { 1154e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast to a vector from something else. This is always a bit 1155e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1156e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 1157e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 1158e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N, 1159e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getConstant(DestTy->getNumElements(),MVT::i32), 1160e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getValueType(EltVT))); 1161e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (SrcVT == DestVT) { 11621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 116328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (DestVT == MVT::i1) { 1164ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 116528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand Zero = isInteger(SrcVT) ? DAG.getConstant(0, N.getValueType()) : 1166ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 11677cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 116828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isInteger(SrcVT)) { 116928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isInteger(DestVT)) { // Int -> Int cast 117028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Truncating cast? 117128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 1172ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 117328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 1174ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 117528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 11767e358908b885f50fb9258b7d10509bad20ca4c3bChris Lattner } else if (isFloatingPoint(DestVT)) { // Int -> FP cast 1177ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 117828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 1179ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 118028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 1181e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1182e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1183ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 118428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isFloatingPoint(SrcVT)) { 118528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isFloatingPoint(DestVT)) { // FP -> FP cast 118628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Rounding cast? 118728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N)); 1188ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 118928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 1190e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (isInteger(DestVT)) { // FP -> Int cast. 1191ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 119228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 1193ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 119428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 119528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else { 1196e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1197ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 1198e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1199e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(SrcVT == MVT::Vector && "Unknown cast!"); 1200e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(DestVT != MVT::Vector && "Casts to vector already handled!"); 1201e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast from a vector to something else. This is always a bit 1202e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1203e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N)); 12041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12072bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 1208c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1209c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 1210c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1211c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 1212c7029805ef35ce9805931067b841e6af11db382eChris Lattner 12132332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Num = *(InVec.Val->op_end()-2); 12142332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 12152332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner setValue(&I, DAG.getNode(ISD::VINSERT_VECTOR_ELT, MVT::Vector, 12162332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner InVec, InVal, InIdx, Num, Typ)); 1217c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 1218c7029805ef35ce9805931067b841e6af11db382eChris Lattner 12192bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 1220384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1221384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1222384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 1223384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 1224384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner setValue(&I, DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, 1225384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 1226384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 1227c7029805ef35ce9805931067b841e6af11db382eChris Lattner 12283e104b11168da4692b69cc6b236c1da22adff959Chris Lattnervoid SelectionDAGLowering::visitShuffleVector(User &I) { 12293e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V1 = getValue(I.getOperand(0)); 12303e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V2 = getValue(I.getOperand(1)); 12313e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Mask = getValue(I.getOperand(2)); 12323e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 12333e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Num = *(V1.Val->op_end()-2); 12343e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Typ = *(V2.Val->op_end()-1); 12353e104b11168da4692b69cc6b236c1da22adff959Chris Lattner setValue(&I, DAG.getNode(ISD::VVECTOR_SHUFFLE, MVT::Vector, 12363e104b11168da4692b69cc6b236c1da22adff959Chris Lattner V1, V2, Mask, Num, Typ)); 12373e104b11168da4692b69cc6b236c1da22adff959Chris Lattner} 12383e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 12393e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 12401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 12411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 12421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 12431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 12451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 12461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 1247c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 12481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 12491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 12501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 1251a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t Offset = TD->getStructLayout(StTy)->MemberOffsets[Field]; 12521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 1253dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 12541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 12561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 12571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 12587c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12597c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 12607c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 12617c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (CI->getRawValue() == 0) continue; 12627c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12637c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t Offs; 12647c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 1265a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson Offs = (int64_t)TD->getTypeSize(Ty)*CSI->getValue(); 12667c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 1267a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson Offs = TD->getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 12687c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 12697c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 12707c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 12717c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12727c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 1273a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 12747c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 12757c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12767c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 12777c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 12787c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 12797c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (Idx->getType()->isSigned()) 12807c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 12817c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 12827c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN); 12837c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 12847c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 12857c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12867c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 12877c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 12887c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 12897c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 12907c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 12916b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 12921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 12937c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 12941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12957c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12967c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 12977c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 12987c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 12991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 13001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 13011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 13021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 13051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 13061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 13071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 13081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 13091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 1311a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 1312a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson unsigned Align = std::max((unsigned)TLI.getTargetData()->getTypeAlignment(Ty), 1313ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman I.getAlignment()); 13141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 131668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 131768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 131868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 131968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 132068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 13211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 132268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 13231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 13241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 13261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 13271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 13281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 13291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 13301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 13311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 13321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 13331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 13341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 13351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 13361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 13371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 13381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 13391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 13401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1341bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[] = { getRoot(), AllocSize, getIntPtrConstant(Align) }; 1342f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTs = DAG.getNodeValueTypes(AllocSize.getValueType(), 1343f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner MVT::Other); 1344f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, 2, Ops, 3); 13451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 13461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 13481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 13491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 13501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 13531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 1354edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1355d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 1356d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 1357d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 1358d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 1359d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 1360d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 1361d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 136228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 1363466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng setValue(&I, getLoadFrom(I.getType(), Ptr, I.getOperand(0), 136428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner Root, I.isVolatile())); 136528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 136628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 136728b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 1368466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 136928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile) { 13705fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 13718cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 13724ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 1373466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng L = DAG.getVecLoad(PTy->getNumElements(), PVT, Root, Ptr, 1374466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng DAG.getSrcValue(SV)); 13755fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 1376466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SV, isVolatile); 13775fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1378d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 137928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 1380d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 1381d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 1382d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 138328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 138428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 13851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 13891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 13901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 13911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 1392786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.setRoot(DAG.getStore(getRoot(), Src, Ptr, 1393786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getSrcValue(I.getOperand(1)))); 13941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13960eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// IntrinsicCannotAccessMemory - Return true if the specified intrinsic cannot 13970eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// access memory and has no other side effects at all. 13980eade319cdb72e24c11d068728a98083737c6435Chris Lattnerstatic bool IntrinsicCannotAccessMemory(unsigned IntrinsicID) { 13990eade319cdb72e24c11d068728a98083737c6435Chris Lattner#define GET_NO_MEMORY_INTRINSICS 14000eade319cdb72e24c11d068728a98083737c6435Chris Lattner#include "llvm/Intrinsics.gen" 14010eade319cdb72e24c11d068728a98083737c6435Chris Lattner#undef GET_NO_MEMORY_INTRINSICS 14020eade319cdb72e24c11d068728a98083737c6435Chris Lattner return false; 14030eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 14040eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1405e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// IntrinsicOnlyReadsMemory - Return true if the specified intrinsic doesn't 1406e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// have any side-effects or if it only reads memory. 1407e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattnerstatic bool IntrinsicOnlyReadsMemory(unsigned IntrinsicID) { 1408e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#define GET_SIDE_EFFECT_INFO 1409e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#include "llvm/Intrinsics.gen" 1410e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#undef GET_SIDE_EFFECT_INFO 1411e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner return false; 1412e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner} 1413e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner 14140eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 14150eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 14160eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 14170eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 14187255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner bool HasChain = !IntrinsicCannotAccessMemory(Intrinsic); 1419e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner bool OnlyLoad = HasChain && IntrinsicOnlyReadsMemory(Intrinsic); 14200eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14210eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 1422bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 1423e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { // If this intrinsic has side-effects, chainify it. 1424e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) { 1425e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner // We don't need to serialize loads against other loads. 1426e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(DAG.getRoot()); 1427e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } else { 1428e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(getRoot()); 1429e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 1430e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 14310eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14320eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 14330eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 14340eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14350eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 14360eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 14370eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 14380eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14390eade319cdb72e24c11d068728a98083737c6435Chris Lattner // If this is a vector type, force it to the right packed type. 14400eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (Op.getValueType() == MVT::Vector) { 14410eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *OpTy = cast<PackedType>(I.getOperand(i)->getType()); 14420eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType()); 14430eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14440eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VVT = MVT::getVectorType(EltVT, OpTy->getNumElements()); 14450eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VVT != MVT::Other && "Intrinsic uses a non-legal type?"); 14460eade319cdb72e24c11d068728a98083737c6435Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, VVT, Op); 14470eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14480eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14490eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 14500eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 14510eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 14520eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14530eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14540eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 14550eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 14560eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 14570eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (VT == MVT::Vector) { 14580eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 14590eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 14600eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14610eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 14620eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 14630eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14640eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14650eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 14660eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 14670eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14680eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 14690eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 14700eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1471f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTList = DAG.getNodeValueTypes(VTs); 1472f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner 14730eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 147448b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 147548b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 1476f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTList, VTs.size(), 1477f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 147848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 1479f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTList, VTs.size(), 1480f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 148148b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 1482f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTList, VTs.size(), 1483f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 148448b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 1485e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { 1486e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner SDOperand Chain = Result.getValue(Result.Val->getNumValues()-1); 1487e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) 1488e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner PendingLoads.push_back(Chain); 1489e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner else 1490e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner DAG.setRoot(Chain); 1491e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 14920eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 14930eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (const PackedType *PTy = dyn_cast<PackedType>(I.getType())) { 14940eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EVT = TLI.getValueType(PTy->getElementType()); 14950eade319cdb72e24c11d068728a98083737c6435Chris Lattner Result = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Result, 14960eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getConstant(PTy->getNumElements(), MVT::i32), 14970eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getValueType(EVT)); 14980eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14990eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 15000eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 15010eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 15020eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1503c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 1504c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 1505c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 1506c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 1507c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 1508c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 15090eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 15100eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 15110eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 15120eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 1513c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 1514c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 1515c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 1516c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return 0; 1517c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return 0; 1518c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 1519c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1520c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 1521c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 1522c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1523c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 152403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 152503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 152603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 152703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 152803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 152903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 153003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 153103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 153203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 153303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 153403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 153503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 1536c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 153786cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 1538ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 153943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 1540fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && SPI.getContext() && DebugInfo->Verify(SPI.getContext())) { 1541bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[5]; 154236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 1543bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[0] = getRoot(); 1544bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[1] = getValue(SPI.getLineValue()); 1545bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[2] = getValue(SPI.getColumnValue()); 1546ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 154743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfoDesc *DD = DebugInfo->getDescFor(SPI.getContext()); 1548ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 154943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 155043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1551bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[3] = DAG.getString(CompileUnit->getFileName()); 1552bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[4] = DAG.getString(CompileUnit->getDirectory()); 1553ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 1554bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops, 5)); 155586cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 155643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1557b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 155836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 155943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 156043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 156143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 1562fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && RSI.getContext() && DebugInfo->Verify(RSI.getContext())) { 156343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(RSI.getContext()); 1564bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, getRoot(), 1565bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.getConstant(LabelID, MVT::i32))); 156643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 156743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1568b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 156943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 157043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 157143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 157243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 1573fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && REI.getContext() && DebugInfo->Verify(REI.getContext())) { 157443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionEnd(REI.getContext()); 1575bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, 1576bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 157743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 157843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1579b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 158043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 158143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 158243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 158343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 1584fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && FSI.getSubprogram() && 1585fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey DebugInfo->Verify(FSI.getSubprogram())) { 158643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(FSI.getSubprogram()); 1587bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, 1588bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 158943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 159043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1591b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 159243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 159343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 159443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 159543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 1596bf7637d59028a5d9911769810f537c499e23bb8eJim Laskey if (DebugInfo && DI.getVariable() && DebugInfo->Verify(DI.getVariable())) { 15970892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey SDOperand AddressOp = getValue(DI.getAddress()); 1598bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(AddressOp)) 159943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfo->RecordVariable(DI.getVariable(), FI->getIndex()); 160043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 160143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 160243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 160343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 1604c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 16050b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f32: 16060b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f64: 1607c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 1608c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 1609c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1610c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 16110b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 16120b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 1613c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 1614c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1615c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1616c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 16176ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f32: 16186ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f64: 16196ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner setValue(&I, DAG.getNode(ISD::FPOWI, 16206ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)).getValueType(), 16216ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)), 16226ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(2)))); 16236ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner return 0; 1624c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 1625c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1626c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 1627c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1628c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 16298b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 1630bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 1631f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, 1632f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::i64, MVT::Other), 2, 1633f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Op, 1); 16348b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 16358b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 163651b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 16378b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 1638d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 1639d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 1640d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 1641d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 1642d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 1643d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 1644d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 16450b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 16460b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 16470b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 16480b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 1649c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 1650c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1651c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1652c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 16530b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 16540b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 16550b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 16560b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 1657c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 1658c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1659c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1660c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 16610b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 16620b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 16630b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 16640b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 1665c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 1666c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1667c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1668c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1669140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 1670bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 1671f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, 1672f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(TLI.getPointerTy(), MVT::Other), 2, &Op, 1); 1673140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 1674140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 1675140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 1676140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 167739a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 167839a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 167939a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 1680140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 168139a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 1682ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 1683ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 1684ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 1685c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1686c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 1687c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 1688c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 16891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 169064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 1691c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 1692c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 1693c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 1694c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 1695c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 1696c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 1697c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 1698c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 1699a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (Name[0] == 'c' && (Name == "copysign" || Name == "copysignf")) { 1700a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 1701a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1702a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(1)->getType() && 1703a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(2)->getType()) { 1704a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand LHS = getValue(I.getOperand(1)); 1705a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand RHS = getValue(I.getOperand(2)); 1706a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 1707a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner LHS, RHS)); 1708a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner return; 1709a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 1710a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } else if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 1711c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1712c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1713c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1714c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1715c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 1716c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 1717c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1718c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 1719f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1720f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 172106a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1722c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1723f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 1724f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1725f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1726c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 1727f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1728f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 172906a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1730c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1731f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 1732f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1733f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1734f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1735c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1736ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 1737ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner visitInlineAsm(I); 1738ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 1739c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1740edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 174164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 174264e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 174364e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 174464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 174564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 17461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1747c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 17481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 17491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 17501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 17511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 17521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1753edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 17548e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 17558e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 1756edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1757cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 17589092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 1759adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 17601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 1761cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 1762cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 17631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 17641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1765864635ad7b3046d3042311423071152c613961deChris LattnerSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 17669f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag)const{ 1767864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Val = DAG.getCopyFromReg(Chain, Regs[0], RegVT, Flag); 1768864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 1769864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 1770864635ad7b3046d3042311423071152c613961deChris Lattner 1771864635ad7b3046d3042311423071152c613961deChris Lattner // If the result was expanded, copy from the top part. 1772864635ad7b3046d3042311423071152c613961deChris Lattner if (Regs.size() > 1) { 1773864635ad7b3046d3042311423071152c613961deChris Lattner assert(Regs.size() == 2 && 1774864635ad7b3046d3042311423071152c613961deChris Lattner "Cannot expand to more than 2 elts yet!"); 1775864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Hi = DAG.getCopyFromReg(Chain, Regs[1], RegVT, Flag); 1776693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Chain = Hi.getValue(1); 1777693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Flag = Hi.getValue(2); 17789f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (DAG.getTargetLoweringInfo().isLittleEndian()) 17799f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Val, Hi); 17809f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner else 17819f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Hi, Val); 1782864635ad7b3046d3042311423071152c613961deChris Lattner } 1783864635ad7b3046d3042311423071152c613961deChris Lattner 1784cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Otherwise, if the return value was promoted or extended, truncate it to the 1785864635ad7b3046d3042311423071152c613961deChris Lattner // appropriate type. 1786864635ad7b3046d3042311423071152c613961deChris Lattner if (RegVT == ValueVT) 1787864635ad7b3046d3042311423071152c613961deChris Lattner return Val; 1788864635ad7b3046d3042311423071152c613961deChris Lattner 1789cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (MVT::isInteger(RegVT)) { 1790cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (ValueVT < RegVT) 1791cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 1792cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner else 1793cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::ANY_EXTEND, ValueVT, Val); 1794cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } else { 1795864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::FP_ROUND, ValueVT, Val); 1796cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } 1797864635ad7b3046d3042311423071152c613961deChris Lattner} 1798864635ad7b3046d3042311423071152c613961deChris Lattner 1799c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 1800c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// specified value into the registers specified by this object. This uses 1801c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// Chain/Flag as the input and updates them for the output Chain/Flag. 1802c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 1803a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 1804a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const { 1805c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (Regs.size() == 1) { 1806c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // If there is a single register and the types differ, this must be 1807c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // a promotion. 1808c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (RegVT != ValueVT) { 18090c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (MVT::isInteger(RegVT)) { 18100c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (RegVT < ValueVT) 18110c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::TRUNCATE, RegVT, Val); 18120c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner else 18130c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::ANY_EXTEND, RegVT, Val); 18140c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner } else 1815c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::FP_EXTEND, RegVT, Val); 1816c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1817c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Chain = DAG.getCopyToReg(Chain, Regs[0], Val, Flag); 1818c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 1819c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } else { 18209f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<unsigned> R(Regs); 18219f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (!DAG.getTargetLoweringInfo().isLittleEndian()) 18229f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::reverse(R.begin(), R.end()); 18239f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner 18249f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner for (unsigned i = 0, e = R.size(); i != e; ++i) { 1825c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner SDOperand Part = DAG.getNode(ISD::EXTRACT_ELEMENT, RegVT, Val, 1826a844126c43976387a66dafbe5137a762169f1f34Evan Cheng DAG.getConstant(i, PtrVT)); 18279f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner Chain = DAG.getCopyToReg(Chain, R[i], Part, Flag); 1828c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 1829c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1830c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1831c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 1832864635ad7b3046d3042311423071152c613961deChris Lattner 1833c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 1834c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 1835c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 1836c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 18379f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 1838c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getConstant(Code | (Regs.size() << 3), MVT::i32)); 1839c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 1840c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 1841c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 1842864635ad7b3046d3042311423071152c613961deChris Lattner 1843864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 1844864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 1845864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 1846864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 18479b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 18489b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetLowering &TLI, const MRegisterInfo *MRI) { 1849f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType FoundVT = MVT::Other; 1850f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner const TargetRegisterClass *FoundRC = 0; 18519b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (MRegisterInfo::regclass_iterator RCI = MRI->regclass_begin(), 18529b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = MRI->regclass_end(); RCI != E; ++RCI) { 1853f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType ThisVT = MVT::Other; 1854f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner 18559b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 18569b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 18579b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 18589b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 18599b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 18609b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 1861f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // If we have already found this register in a different register class, 1862f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // choose the one with the largest VT specified. For example, on 1863f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // PowerPC, we favor f64 register classes over f32. 1864f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (FoundVT == MVT::Other || 1865f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::getSizeInBits(FoundVT) < MVT::getSizeInBits(*I)) { 1866f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner ThisVT = *I; 1867f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 1868f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 18699b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 18709b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 18719b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 1872f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (ThisVT == MVT::Other) continue; 18739b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 1874864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 1875864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 1876864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 1877864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 18789b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 18799b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 1880f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (*I == Reg) { 1881f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // We found a matching register class. Keep looking at others in case 1882f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // we find one with larger registers that this physreg is also in. 1883f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundRC = RC; 1884f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundVT = ThisVT; 1885f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 1886f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 1887864635ad7b3046d3042311423071152c613961deChris Lattner } 1888f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner return FoundRC; 1889864635ad7b3046d3042311423071152c613961deChris Lattner} 1890864635ad7b3046d3042311423071152c613961deChris Lattner 1891864635ad7b3046d3042311423071152c613961deChris LattnerRegsForValue SelectionDAGLowering:: 1892864635ad7b3046d3042311423071152c613961deChris LattnerGetRegistersForValue(const std::string &ConstrCode, 1893864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, bool isOutReg, bool isInReg, 1894864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 18954e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 1896864635ad7b3046d3042311423071152c613961deChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 1897864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegForInlineAsmConstraint(ConstrCode, VT); 1898864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 1899864635ad7b3046d3042311423071152c613961deChris Lattner 1900864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumRegs = VT != MVT::Other ? TLI.getNumElements(VT) : 1; 1901864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 1902864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT = VT; 1903864635ad7b3046d3042311423071152c613961deChris Lattner 1904864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 1905864635ad7b3046d3042311423071152c613961deChris Lattner if (VT == MVT::Other) 1906864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 1907cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner 1908cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Get the actual register value type. This is important, because the user 1909cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // may have asked for (e.g.) the AX register in i32 type. We need to 1910cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // remember that AX is actually i16 to get the right extension. 1911cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner RegVT = *PhysReg.second->vt_begin(); 1912864635ad7b3046d3042311423071152c613961deChris Lattner 1913864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 1914864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 1915864635ad7b3046d3042311423071152c613961deChris Lattner 1916864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 1917864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 1918864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 1919864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 1920864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 1921864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 1922864635ad7b3046d3042311423071152c613961deChris Lattner 1923864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 1924864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 1925864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 1926864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 1927864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 1928864635ad7b3046d3042311423071152c613961deChris Lattner } 1929864635ad7b3046d3042311423071152c613961deChris Lattner } 1930864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 1931864635ad7b3046d3042311423071152c613961deChris Lattner } 1932864635ad7b3046d3042311423071152c613961deChris Lattner 1933864635ad7b3046d3042311423071152c613961deChris Lattner // This is a reference to a register class. Allocate NumRegs consecutive, 1934864635ad7b3046d3042311423071152c613961deChris Lattner // available, registers from the class. 1935864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> RegClassRegs = 1936864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegClassForInlineAsmConstraint(ConstrCode, VT); 1937864635ad7b3046d3042311423071152c613961deChris Lattner 19384e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner const MRegisterInfo *MRI = DAG.getTarget().getRegisterInfo(); 19394e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner MachineFunction &MF = *CurMBB->getParent(); 1940864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 1941864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 1942864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 19434e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 1944864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 1945864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 1946864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 1947864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 1948864635ad7b3046d3042311423071152c613961deChris Lattner continue; 1949864635ad7b3046d3042311423071152c613961deChris Lattner } 1950864635ad7b3046d3042311423071152c613961deChris Lattner 19514e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 19524e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 19539b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, MRI); 1954864635ad7b3046d3042311423071152c613961deChris Lattner if (!RC) { 1955864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 1956864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 1957864635ad7b3046d3042311423071152c613961deChris Lattner continue; 19584e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 19594e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 1960864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 1961864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 1962864635ad7b3046d3042311423071152c613961deChris Lattner 1963864635ad7b3046d3042311423071152c613961deChris Lattner // If we allocated enough consecutive 1964864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 1965864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 1966864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 1967864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 1968864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) { 1969864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 1970864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 1971864635ad7b3046d3042311423071152c613961deChris Lattner if (isOutReg) OutputRegs.insert(Reg); // Mark reg used. 1972864635ad7b3046d3042311423071152c613961deChris Lattner if (isInReg) InputRegs.insert(Reg); // Mark reg used. 1973864635ad7b3046d3042311423071152c613961deChris Lattner } 1974864635ad7b3046d3042311423071152c613961deChris Lattner 1975864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, *RC->vt_begin(), VT); 1976864635ad7b3046d3042311423071152c613961deChris Lattner } 19774e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 1978864635ad7b3046d3042311423071152c613961deChris Lattner 1979864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 1980864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(); 19814e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 19824e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 1983864635ad7b3046d3042311423071152c613961deChris Lattner 1984ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 1985ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 1986ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattnervoid SelectionDAGLowering::visitInlineAsm(CallInst &I) { 1987ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner InlineAsm *IA = cast<InlineAsm>(I.getOperand(0)); 1988ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1989ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand AsmStr = DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), 1990ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner MVT::Other); 1991ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1992ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Note, we treat inline asms both with and without side-effects as the same. 1993ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // If an inline asm doesn't have side effects and doesn't access memory, we 1994ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // could not choose to not chain it. 1995ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner bool hasSideEffects = IA->hasSideEffects(); 1996ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 19972cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); 19981efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner std::vector<MVT::ValueType> ConstraintVTs; 1999ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2000ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// AsmNodeOperands - A list of pairs. The first element is a register, the 2001ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// second is a bitfield where bit #0 is set if it is a use and bit #1 is set 2002ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// if it is a def of that register. 2003ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> AsmNodeOperands; 2004ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 2005ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(AsmStr); 2006ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2007ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 2008ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 2009ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 20104e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We fully assign registers here at isel time. This is not optimal, but 20114e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // should work. For register classes that correspond to LLVM classes, we 20124e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // could let the LLVM RA do its thing, but we currently don't. Do a prepass 20134e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // over the constraints, collecting fixed registers that we know we can't use. 20144e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 20151efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner unsigned OpNum = 1; 20164e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 20174e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 20184e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 20192223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 20201efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner MVT::ValueType OpVT; 20211efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 20221efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Compute the value type for each operand and add it to ConstraintVTs. 20231efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner switch (Constraints[i].Type) { 20241efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 20251efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (!Constraints[i].isIndirectOutput) { 20261efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 20271efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getType()); 20281efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 202922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner const Type *OpTy = I.getOperand(OpNum)->getType(); 20301efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(cast<PointerType>(OpTy)->getElementType()); 20311efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 20321efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 20331efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20341efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 20351efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getOperand(OpNum)->getType()); 20361efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 20371efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20381efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 20391efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = MVT::Other; 20401efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20411efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 20421efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 20431efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner ConstraintVTs.push_back(OpVT); 20441efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2045864635ad7b3046d3042311423071152c613961deChris Lattner if (TLI.getRegForInlineAsmConstraint(ConstraintCode, OpVT).first == 0) 2046864635ad7b3046d3042311423071152c613961deChris Lattner continue; // Not assigned a fixed reg. 20471efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2048864635ad7b3046d3042311423071152c613961deChris Lattner // Build a list of regs that this operand uses. This always has a single 2049864635ad7b3046d3042311423071152c613961deChris Lattner // element for promoted/expanded operands. 2050864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = GetRegistersForValue(ConstraintCode, OpVT, 2051864635ad7b3046d3042311423071152c613961deChris Lattner false, false, 2052864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 20534e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 20544e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner switch (Constraints[i].Type) { 20554e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isOutput: 20564e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We can't assign any other output to this register. 2057864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20584e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // If this is an early-clobber output, it cannot be assigned to the same 20594e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // value as the input reg. 20602223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2061864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20624e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 20631efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 20641efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // We can't assign any other input to this register. 2065864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20661efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20674e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isClobber: 20684e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Clobbered regs cannot be used as inputs or outputs. 2069864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 2070864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20714e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 20724e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 20734e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 20742cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 20750f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 20760f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 2077864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 2078864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 20791efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum = 1; 20800f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 20816656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 20822cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 20832cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 20841efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 20852cc2f66c25d9576743026688fdae5ed402726532Chris Lattner switch (Constraints[i].Type) { 20862cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 208722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 208822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 208922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 209022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 209122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (CTy == TargetLowering::C_Memory) { 209222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Memory output. 209322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 209422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 209522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Check that the operand (the address to store to) isn't a float. 209622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 209722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 209822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 209922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!Constraints[i].isIndirectOutput) 210022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 210122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 210222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner OpNum++; // Consumes a call operand. 210322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 210422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Extend/truncate to the right pointer type if needed. 210522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 210622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (InOperandVal.getValueType() < PtrType) 210722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 210822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner else if (InOperandVal.getValueType() > PtrType) 210922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 211022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 211122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 211222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 211322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 211422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(InOperandVal); 211522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 211622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 211722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 211822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Otherwise, this is a register output. 211922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 212022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 2121864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an early-clobber output, or if there is an input 2122864635ad7b3046d3042311423071152c613961deChris Lattner // constraint that matches this, we need to reserve the input register 2123864635ad7b3046d3042311423071152c613961deChris Lattner // so no other inputs allocate to it. 2124864635ad7b3046d3042311423071152c613961deChris Lattner bool UsesInputRegister = false; 2125864635ad7b3046d3042311423071152c613961deChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2126864635ad7b3046d3042311423071152c613961deChris Lattner UsesInputRegister = true; 21272223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 2128864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 2129864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 2130864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = 2131864635ad7b3046d3042311423071152c613961deChris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 2132864635ad7b3046d3042311423071152c613961deChris Lattner true, UsesInputRegister, 2133864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 2134864635ad7b3046d3042311423071152c613961deChris Lattner assert(!Regs.Regs.empty() && "Couldn't allocate output reg!"); 21352cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 21362cc2f66c25d9576743026688fdae5ed402726532Chris Lattner if (!Constraints[i].isIndirectOutput) { 2137864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 21382cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 21392cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 2140864635ad7b3046d3042311423071152c613961deChris Lattner RetValRegs = Regs; 21412cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 214222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner IndirectStoresToEmit.push_back(std::make_pair(Regs, 214322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner I.getOperand(OpNum))); 21442cc2f66c25d9576743026688fdae5ed402726532Chris Lattner OpNum++; // Consumes a call operand. 21452cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 21466656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 21476656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 21486656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 2149c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Regs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, AsmNodeOperands); 21506656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 21516656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 21526656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 215322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 21544e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner OpNum++; // Consumes a call operand. 21553d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 21562223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (isdigit(ConstraintCode[0])) { // Matching constraint? 21572223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 21582223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 21592223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner unsigned OperandNo = atoi(ConstraintCode.c_str()); 21603d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 2161c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 2162c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 2163c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 2164c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 2165c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 2166c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2167c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2168a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner assert(((NumOps & 7) == 2 /*REGDEF*/ || 2169a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner (NumOps & 7) == 4 /*MEM*/) && 2170c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2171c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 2172c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2173c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2174c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2175c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2176c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner assert((NumOps & 7) == 2 /*REGDEF*/ && 2177c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2178c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2179c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 2180c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue MatchedRegs; 2181c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 2182c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 2183c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 2184c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned Reg=cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 2185c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.Regs.push_back(Reg); 2186c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2187c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2188c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Use the produced MatchedRegs object to 2189a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, 2190a844126c43976387a66dafbe5137a762169f1f34Evan Cheng TLI.getPointerTy()); 2191c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 219287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 219387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 219487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 219587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 219687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 219787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 21983d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 219987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (CTy == TargetLowering::C_Other) { 220087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!TLI.isOperandValidForConstraint(InOperandVal, ConstraintCode[0])) 220187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2202c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 220387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 220487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 3 /*IMM*/ | (1 << 3); 220587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 220687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 220787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 220887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } else if (CTy == TargetLowering::C_Memory) { 220987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Memory input. 221087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 221187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Check that the operand isn't a float. 221287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 221387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2214c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 221587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Extend/truncate to the right pointer type if needed. 221687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 221787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (InOperandVal.getValueType() < PtrType) 221887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 221987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner else if (InOperandVal.getValueType() > PtrType) 222087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 222187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 222287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 222387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 222487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 222587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 2226c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 22272223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 222887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 222987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 223087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 223187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 223287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner RegsForValue InRegs = 223387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 223487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner false, true, OutputRegs, InputRegs); 223587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // FIXME: should be match fail. 223687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(!InRegs.Regs.empty() && "Couldn't allocate input reg!"); 223787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 2238a844126c43976387a66dafbe5137a762169f1f34Evan Cheng InRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, TLI.getPointerTy()); 223987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 224087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, AsmNodeOperands); 22416656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 22426656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2243c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 2244c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue ClobberedRegs = 2245c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner GetRegistersForValue(ConstraintCode, MVT::Other, false, false, 2246c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner OutputRegs, InputRegs); 2247c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 2248c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 2249c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (!ClobberedRegs.Regs.empty()) 2250c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner ClobberedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, AsmNodeOperands); 22516656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 22526656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2253c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 22546656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2255ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2256ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 2257ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 2258ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 2259ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2260f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, 2261f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::Other, MVT::Flag), 2, 2262bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &AsmNodeOperands[0], AsmNodeOperands.size()); 2263ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 2264ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22656656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 22666656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 2267864635ad7b3046d3042311423071152c613961deChris Lattner if (!RetValRegs.Regs.empty()) 2268864635ad7b3046d3042311423071152c613961deChris Lattner setValue(&I, RetValRegs.getCopyFromRegs(DAG, Chain, Flag)); 22696656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 22706656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 22716656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 22726656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 22736656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 22746656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 2275864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 22766656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 2277864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, Flag); 2278864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 22796656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2280ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22816656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 2282bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 22836656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 2284786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng OutChains.push_back(DAG.getStore(Chain, StoresToEmit[i].first, 22856656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 22866656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner DAG.getSrcValue(StoresToEmit[i].second))); 22876656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 2288bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, 2289bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 2290ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 2291ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 2292ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2293ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 22951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 22961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 229868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 229968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 230068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 230168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 230268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 23031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 2305a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(I.getType()->getElementType()); 23061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 23071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 23081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 2310a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson Args.push_back(std::make_pair(Src, TLI.getTargetData()->getIntPtrType())); 2311cf5734dddd66af9388a171b44996505ede47feedChris Lattner 2312cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2313adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 2314cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 2315cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 2316cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 2317cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 23181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 23211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 23221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 2323a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson TLI.getTargetData()->getIntPtrType())); 23241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 2325cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2326adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 2327cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 2328cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 23291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2331025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 2332025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 2333025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 2334025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 2335025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 2336025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 2337025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 2338025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 2339025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 2340025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 2341025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 2342025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 2343025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 2344025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 234539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 2346acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 2347acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2348acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 234939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 235039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 23511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 2352acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 2353acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 2354acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 2355acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 2356acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 23571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 2360acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 2361acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2362acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 23631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 2366acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 2367acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2368acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 2369acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 2370acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 23711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2373fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// TargetLowering::LowerArguments - This is the default LowerArguments 2374fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// implementation, which just inserts a FORMAL_ARGUMENTS node. FIXME: When all 2375f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// targets are migrated to using FORMAL_ARGUMENTS, this hook should be 2376f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// integrated into SDISel. 2377fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattnerstd::vector<SDOperand> 2378fdfded55888e35b76bb70231a5bb2f60877c2f6aChris LattnerTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { 2379fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. 2380fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<SDOperand> Ops; 23818c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner Ops.push_back(DAG.getRoot()); 2382fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.getCallingConv(), getPointerTy())); 2383fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.isVarArg(), getPointerTy())); 2384fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2385fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add one result value for each formal argument. 2386fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<MVT::ValueType> RetVals; 2387fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { 2388fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2389fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2390fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2391fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2392fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2393fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(VT); 2394fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2395fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: 2396fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(getTypeToTransformTo(VT)); 2397fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2398fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2399fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2400fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be broken up into small 2401fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the destination type is and how many small 2402fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it turns into. 2403fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2404fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2405fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (unsigned i = 0; i != NumVals; ++i) 2406fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(NVT); 2407fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2408fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2409fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2410fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumElems = cast<PackedType>(I->getType())->getNumElements(); 2411fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner const Type *EltTy = cast<PackedType>(I->getType())->getElementType(); 2412f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 2413fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2414fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2415fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2416fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2417fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(TVT); 2418fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2419fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2420fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2421fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2422fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2423fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2424fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 24253b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng 24268c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner RetVals.push_back(MVT::Other); 2427fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2428fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Create the node. 2429f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDNode *Result = DAG.getNode(ISD::FORMAL_ARGUMENTS, 2430f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(RetVals), RetVals.size(), 2431bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()).Val; 24328c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner 24338c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner DAG.setRoot(SDOperand(Result, Result->getNumValues()-1)); 2434fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2435fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Set up the return result vector. 2436fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.clear(); 2437fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned i = 0; 2438fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { 2439fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2440fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2441fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2442fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2443fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2444fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(SDOperand(Result, i++)); 2445fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2446fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: { 2447fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Op(Result, i++); 2448fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (MVT::isInteger(VT)) { 2449fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned AssertOp = I->getType()->isSigned() ? ISD::AssertSext 2450fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner : ISD::AssertZext; 2451fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(AssertOp, Op.getValueType(), Op, DAG.getValueType(VT)); 2452fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::TRUNCATE, VT, Op); 2453fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2454fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 2455fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::FP_ROUND, VT, Op); 2456fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2457fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(Op); 2458fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2459fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2460fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2461fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2462fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be reassembled from small 2463fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the source elt type is and how many small 2464fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it is. 2465fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2466fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2467fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (NumVals == 2) { 2468fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Lo = SDOperand(Result, i++); 2469fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Hi = SDOperand(Result, i++); 2470fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2471fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (!isLittleEndian()) 2472fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::swap(Lo, Hi); 2473fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2474fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Lo, Hi)); 2475fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2476fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Value scalarized into many values. Unimp for now. 2477fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Cannot expand i64 -> i16 yet!"); 2478fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2479fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2480fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2481fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2482020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const PackedType *PTy = cast<PackedType>(I->getType()); 2483020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng unsigned NumElems = PTy->getNumElements(); 2484020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const Type *EltTy = PTy->getElementType(); 2485f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 2486fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2487fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2488fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2489d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2490020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng SDOperand N = SDOperand(Result, i++); 2491020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng // Handle copies from generic vectors to registers. 2492d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 2493d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 2494d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 2495d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner Ops.push_back(N); 2496d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner } else { 2497fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2498da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2499fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2500fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2501fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2502fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2503fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2504fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner return Ops; 2505fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner} 2506fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2507f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2508f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// TargetLowering::LowerCallTo - This is the default LowerCallTo 2509f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// implementation, which just inserts an ISD::CALL node, which is later custom 2510f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// lowered by the target to something concrete. FIXME: When all targets are 2511f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// migrated to using ISD::CALL, this hook should be integrated into SDISel. 2512f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattnerstd::pair<SDOperand, SDOperand> 2513f4ec817299a4187044a6162c2f520772b3ad69a0Chris LattnerTargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg, 2514f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned CallingConv, bool isTailCall, 2515f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Callee, 2516f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ArgListTy &Args, SelectionDAG &DAG) { 2517be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<SDOperand, 32> Ops; 2518f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Chain); // Op#0 - Chain 2519f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(CallingConv, getPointerTy())); // Op#1 - CC 2520f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isVarArg, getPointerTy())); // Op#2 - VarArg 2521f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isTailCall, getPointerTy())); // Op#3 - Tail 2522f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Callee); 2523f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2524f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Handle all of the outgoing arguments. 2525f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) { 2526f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(Args[i].second); 2527f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Op = Args[i].first; 2528f6d62c2e2a53e3ebf2e25f0891e5f1a0b772b368Evan Cheng bool isSigned = Args[i].second->isSigned(); 2529f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 2530f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 2531f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 2532f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 2533d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2534f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2535f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 2536f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (MVT::isInteger(VT)) { 2537f6d62c2e2a53e3ebf2e25f0891e5f1a0b772b368Evan Cheng unsigned ExtOp = isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; 2538f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ExtOp, getTypeToTransformTo(VT), Op); 2539f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2540f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 2541f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, getTypeToTransformTo(VT), Op); 2542f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2543f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 2544d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2545f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2546f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 2547f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 2548f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be broken down into small 2549f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 2550f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 2551f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2552f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2553f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (NumVals == 2) { 2554f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Op, 2555f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getConstant(0, getPointerTy())); 2556f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Op, 2557f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getConstant(1, getPointerTy())); 2558f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (!isLittleEndian()) 2559f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner std::swap(Lo, Hi); 2560f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2561f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Lo); 2562d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2563f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Hi); 2564d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2565f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2566f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Value scalarized into many values. Unimp for now. 2567f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(0 && "Cannot expand i64 -> i16 yet!"); 2568f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2569f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2570da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 2571da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 2572da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const PackedType *PTy = cast<PackedType>(Args[i].second); 2573da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 2574da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 2575da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 2576da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 2577da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 2578da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 25791b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 25801b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner // Insert a VBIT_CONVERT of the MVT::Vector type to the packed type. 25811b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, TVT, Op); 25821b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Ops.push_back(Op); 2583d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 25841b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner } else { 2585da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call args yet!"); 2586da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2587da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 2588f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2589f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2590f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2591f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2592f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2593f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Figure out the result value types. 2594be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<MVT::ValueType, 4> RetTys; 2595f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2596f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTy != Type::VoidTy) { 2597f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 2598f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 2599f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 2600f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 2601f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(VT); 2602f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2603f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 2604f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(getTypeToTransformTo(VT)); 2605f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2606f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 2607f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 2608f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be reassembled from small 2609f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 2610f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 2611f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2612f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2613f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0; i != NumVals; ++i) 2614f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(NVT); 2615f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2616da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 2617da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 2618da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const PackedType *PTy = cast<PackedType>(RetTy); 2619da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 2620da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 2621da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 2622da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 2623da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 2624da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2625da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2626da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner RetTys.push_back(TVT); 2627da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 2628da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call results yet!"); 2629da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2630da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 2631f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2632f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2633f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2634f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2635f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(MVT::Other); // Always has a chain. 2636f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2637f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Finally, create the CALL node. 2638be384162c68641233deba8702666af51bdfd4b83Chris Lattner SDOperand Res = DAG.getNode(ISD::CALL, 2639be384162c68641233deba8702666af51bdfd4b83Chris Lattner DAG.getVTList(&RetTys[0], RetTys.size()), 2640be384162c68641233deba8702666af51bdfd4b83Chris Lattner &Ops[0], Ops.size()); 2641f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2642f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // This returns a pair of operands. The first element is the 2643f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // return value for the function (if RetTy is not VoidTy). The second 2644f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // element is the outgoing token chain. 2645f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand ResVal; 2646f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() != 1) { 2647f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 2648f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() == 2) { 2649f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = Res; 2650f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2651f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this value was promoted, truncate it down. 2652f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (ResVal.getValueType() != VT) { 2653da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (VT == MVT::Vector) { 2654da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBITCONVERT to convert from the packed result type to the 2655da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // MVT::Vector type. 2656da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = cast<PackedType>(RetTy)->getNumElements(); 2657da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = cast<PackedType>(RetTy)->getElementType(); 2658da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 2659da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 2660da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 2661da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2662da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2663da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBIT_CONVERT of the FORMAL_ARGUMENTS to a 2664da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // "N x PTyElementVT" MVT::Vector type. 2665da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner ResVal = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, ResVal, 2666d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 2667d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 2668da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 2669da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2670da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 2671da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else if (MVT::isInteger(VT)) { 2672f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned AssertOp = RetTy->isSigned() ? 2673f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ISD::AssertSext : ISD::AssertZext; 2674f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(AssertOp, ResVal.getValueType(), ResVal, 2675f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getValueType(VT)); 2676f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::TRUNCATE, VT, ResVal); 2677f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2678f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT)); 2679f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::FP_ROUND, VT, ResVal); 2680f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2681f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2682f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else if (RetTys.size() == 3) { 2683f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::BUILD_PAIR, VT, 2684f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Res.getValue(0), Res.getValue(1)); 2685f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2686f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2687f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(0 && "Case not handled yet!"); 2688f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2689f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2690f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2691f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner return std::make_pair(ResVal, Res.getValue(Res.Val->getNumValues()-1)); 2692f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner} 2693f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2694f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2695f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 269639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 269739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 2698f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner// 2699f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner// FIXME: Change this to insert a FRAMEADDR/RETURNADDR node, and have that be 2700f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner// expanded to 0 if the target wants. 270139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 270239ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 270339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 270439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 27051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 27061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 270750381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 2708171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 2709171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 2710d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 2711171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 2712171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 27130aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 27140aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 27150aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 27160aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 27170aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 27180aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 27190aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 272039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 272139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 272239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 2723a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 272439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 272539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 272639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 27271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 272874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 27291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 27301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 2731a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 27321db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 27331db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 27341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 27351db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 27361db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 27371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 27381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 27391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 27401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 27411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 27421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 27431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 27441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 27451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 27461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 27471db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 27481db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 27491db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 27501db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 27511db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 27521db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 27531db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 27541db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 27551db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 27561db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 27571db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 275874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 275974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 276074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 276174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 276274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 276374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 276474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng MVT::ValueType CurVT = VT; 276574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 276674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng unsigned MSB = getSizeInBits(VT) / 8; 276774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 276874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 276974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 277074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Val = (Val << 8) | Str[Offset]; 277174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 277274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 277374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 277474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 277574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 27761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 27771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 27781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 27791db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 27801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 27811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 27821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 2783c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 278480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 278580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 2786c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 2787c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 2788c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 27891db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 27901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 27911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 27921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 27931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 27941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 27951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 27961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 27971db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 27981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 27991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 28001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 28011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 28021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 28031db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 28041db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 28051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 28061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 28071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 28081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 28091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 281080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 281180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 281280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 281380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 28141db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 281580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 281680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 281780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 2818dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 28191db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 28201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 28211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 28221db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 28231db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 28241db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 282580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 282680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 282780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 282880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 28291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 28301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 28311db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 283280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 283380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 28341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 28351db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 28367041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 28371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 28381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 28391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 28401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 28411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 28421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 28431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 28441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 28451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 28461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 28471db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 28481db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 2849bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 28501db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 2851ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 28521db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 2853c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 2854c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 285580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 28561db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 28571db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 28581db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 28591db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 2860a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 2861786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng SDOperand Store = DAG.getStore(getRoot(), Value, 2862864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 2863864635ad7b3046d3042311423071152c613961deChris Lattner DAG.getSrcValue(I.getOperand(1), Offset)); 2864c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 2865c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 2866c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2867c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2868c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 2869c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2870c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 2871c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 2872c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 2873c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 2874cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 287574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 287674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 2877cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 287874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 287974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 288074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 288174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 288274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 288374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 288474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 2885cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 288674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 288774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 288874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 2889cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (GV) { 28900937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 2891cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 2892cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 2893cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 2894cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 2895cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 289674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 289774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 2898c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 2899c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 2900c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 290174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 290274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 2903cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 290474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 290574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 290674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 2907786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 2908786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 2909786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getSrcValue(I.getOperand(1), DstOff)); 291074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 291174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 291274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 2913466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng I.getOperand(2), SrcOff); 291474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 291574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 2916786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 2917786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 2918786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getSrcValue(I.getOperand(1), DstOff)); 291974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 2920c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 292174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 292274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 29231db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 29241db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 2925c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 29261db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 29271db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 2928c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 2929c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 2930bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 2931bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size())); 2932c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 2933c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 29341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 29351db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 2936bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, getRoot(), Op1, Op2, Op3, Op4)); 29371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 29381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 29397041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 29407041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 29417041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 29421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 29431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 29441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 29451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 29461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2947495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 294836b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 294936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 2950495a0b51915eb763576874f29192820b731edc22Chris Lattner} 29511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2952c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 29537e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// OptimizeNoopCopyExpression - We have determined that the specified cast 29547e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// instruction is a noop copy (e.g. it's casting from one pointer type to 29557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// another, int->uint, or int->sbyte on PPC. 2956903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// 2957903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// Return true if any changes are made. 2958903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeNoopCopyExpression(CastInst *CI) { 29597e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *DefBB = CI->getParent(); 29607e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29617e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner /// InsertedCasts - Only insert a cast in each block once. 29627e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner std::map<BasicBlock*, CastInst*> InsertedCasts; 29637e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 2964903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = false; 29657e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end(); 29667e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UI != E; ) { 29677e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Use &TheUse = UI.getUse(); 29687e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *User = cast<Instruction>(*UI); 29697e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29707e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Figure out which BB this cast is used in. For PHI's this is the 29717e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // appropriate predecessor block. 29727e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *UserBB = User->getParent(); 29737e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(User)) { 29747e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner unsigned OpVal = UI.getOperandNo()/2; 29757e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UserBB = PN->getIncomingBlock(OpVal); 29767e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 29777e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29787e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Preincrement use iterator so we don't invalidate it. 29797e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner ++UI; 29807e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29817e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this user is in the same block as the cast, don't change the cast. 29827e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (UserBB == DefBB) continue; 29837e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29847e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If we have already inserted a cast into this block, use it. 29857e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner CastInst *&InsertedCast = InsertedCasts[UserBB]; 29867e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29877e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (!InsertedCast) { 29887e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock::iterator InsertPt = UserBB->begin(); 29897e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 29907e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29917e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner InsertedCast = 29927e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 2993903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = true; 29947e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 29957e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 29967e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Replace a use of the cast with a use of the new casat. 29977e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner TheUse = InsertedCast; 29987e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 2999903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3000903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If we removed all uses, nuke the cast. 3001903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->use_empty()) 3002903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner CI->eraseFromParent(); 3003903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3004903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return MadeChange; 30057e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner} 3006c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3007903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 3008903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// casting to the type of GEPI. 3009f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattnerstatic Instruction *InsertGEPComputeCode(Instruction *&V, BasicBlock *BB, 3010f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *GEPI, Value *Ptr, 3011f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Value *PtrOffset) { 3012903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (V) return V; // Already computed. 3013903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3014903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner BasicBlock::iterator InsertPt; 3015903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (BB == GEPI->getParent()) { 3016903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If insert into the GEP's block, insert right after the GEP. 3017903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = GEPI; 3018903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ++InsertPt; 3019903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3020903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 3021903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = BB->begin(); 3022903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 3023903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3024903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3025903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 3026903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // BB so that there is only one value live across basic blocks (the cast 3027903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // operand). 3028903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 3029903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 3030903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr = new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 3031903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3032903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Add the offset, cast it to the right type. 3033903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 3034f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner return V = new CastInst(Ptr, GEPI->getType(), "", InsertPt); 3035903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3036903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3037903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// ReplaceUsesOfGEPInst - Replace all uses of RepPtr with inserted code to 3038903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// compute its value. The RepPtr value can be computed with Ptr+PtrOffset. One 3039903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// trivial way of doing this would be to evaluate Ptr+PtrOffset in RepPtr's 3040903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// block, then ReplaceAllUsesWith'ing everything. However, we would prefer to 3041903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// sink PtrOffset into user blocks where doing so will likely allow us to fold 3042903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// the constant add into a load or store instruction. Additionally, if a user 3043903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// is a pointer-pointer cast, we look through it to find its users. 3044903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic void ReplaceUsesOfGEPInst(Instruction *RepPtr, Value *Ptr, 3045903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Constant *PtrOffset, BasicBlock *DefBB, 3046903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GetElementPtrInst *GEPI, 3047f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> &InsertedExprs) { 3048903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (!RepPtr->use_empty()) { 3049903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Instruction *User = cast<Instruction>(RepPtr->use_back()); 3050903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3051903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If the user is a Pointer-Pointer cast, recurse. 3052903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (isa<CastInst>(User) && isa<PointerType>(User->getType())) { 3053903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(User, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3054903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3055903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Drop the use of RepPtr. The cast is dead. Don't delete it now, else we 3056903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // could invalidate an iterator. 3057903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->setOperand(0, UndefValue::get(RepPtr->getType())); 3058903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner continue; 3059903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3060903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3061903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a load of the pointer, or a store through the pointer, emit 3062903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // the increment into the load/store block. 3063f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *NewVal; 3064903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (isa<LoadInst>(User) || 3065903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner (isa<StoreInst>(User) && User->getOperand(0) != RepPtr)) { 3066903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 3067903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->getParent(), GEPI, 3068903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3069903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3070903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this use is not foldable into the addressing mode, use a version 3071903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // emitted in the GEP block. 3072903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 3073903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3074903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3075903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3076f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner if (GEPI->getType() != RepPtr->getType()) { 3077f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner BasicBlock::iterator IP = NewVal; 3078f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner ++IP; 3079f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner NewVal = new CastInst(NewVal, RepPtr->getType(), "", IP); 3080f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner } 3081903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->replaceUsesOfWith(RepPtr, NewVal); 3082903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3083903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3084903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3085903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3086c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 3087c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 3088c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 3089c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 3090c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 3091c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 3092903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeGEPExpression(GetElementPtrInst *GEPI, 3093a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD) { 3094c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 3095c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 3096c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 3097c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 3098c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 3099c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 3100c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 3101c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 3102c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3103c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3104c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3105903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!isUsedOutsideDefBB) return false; 3106c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3107c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 3108c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 3109c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 3110903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool hasVariableIndex = false; 3111c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 3112c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 3113903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) { 3114c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue()) { 3115c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 3116c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3117c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3118903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3119903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner hasVariableIndex = true; 3120903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3121c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3122903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3123903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a "GEP X, 0, 0, 0", turn this into a cast. 3124903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !hasVariableIndex) { 3125903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Value *NC = new CastInst(GEPI->getOperand(0), GEPI->getType(), 3126903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->getName(), GEPI); 3127903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->replaceAllUsesWith(NC); 3128903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->eraseFromParent(); 3129903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 3130903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3131903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 31323802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 3133903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) 3134903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return false; 3135c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3136c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 3137c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 3138c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 3139a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const Type *UIntPtrTy = TD->getIntPtrType(); 3140c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr = new CastInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 3141c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 3142c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3143c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 3144c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 3145c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 3146c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 3147c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 3148c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 3149a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson ConstantOffset += TD->getStructLayout(StTy)->MemberOffsets[Field]; 3150c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 3151c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 3152c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 3153c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3154c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 3155c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 3156c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue() == 0) continue; 3157c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3158c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 3159a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson ConstantOffset += (int64_t)TD->getTypeSize(Ty)*CSI->getValue(); 3160c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner else 3161a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson ConstantOffset+=TD->getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 3162c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 3163c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3164c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3165c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 3166c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3167c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 3168c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = new CastInst(Idx, UIntPtrTy, "", GEPI); 3169c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3170a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 3171c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 3172c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 3173c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *SizeCst = ConstantUInt::get(UIntPtrTy, ElementSize); 3174c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3175c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 3176c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 3177c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 3178c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3179c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3180c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3181c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 3182c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 3183c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *PtrOffset = ConstantUInt::get(UIntPtrTy, ConstantOffset); 3184c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3185c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 3186c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 3187c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 3188c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 3189c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 3190c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 3191c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 3192c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 3193f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> InsertedExprs; 3194903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(GEPI, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3195c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3196c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 3197c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 3198903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3199903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 3200c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 3201c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 320257f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// SplitCritEdgesForPHIConstants - If this block has any PHI nodes with 320357f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// constant operands, and if any of the edges feeding the PHI node are 320457f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// critical, split them so that the assignments of a constant to a register 320557f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// will not be executed on a path that isn't relevant. 320657f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattnervoid SelectionDAGISel::SplitCritEdgesForPHIConstants(BasicBlock *BB) { 320757f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner PHINode *PN; 320857f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner BasicBlock::iterator BBI = BB->begin(); 320957f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner while ((PN = dyn_cast<PHINode>(BBI++))) { 321057f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 321157f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 321257f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 321357f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner } 321457f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner} 321557f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner 321657f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner 32171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 32181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 32191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 32201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 32211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3222c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // First, split all critical edges for PHI nodes with incoming values that are 3223c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constants, this way the load of the constant into a vreg will not be placed 3224c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // into MBBs that are used some other way. 3225c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 32267e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // In this pass we also look for GEP and cast instructions that are used 32277e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // across basic blocks and rewrite them to improve basic-block-at-a-time 32287e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // selection. 32297e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // 3230c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 3231903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = true; 3232903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (MadeChange) { 3233903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = false; 323436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 323557f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner // If this block has any PHI nodes with constant operands, and if any of the 323657f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner // edges feeding the PHI node are critical, split them. 323757f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner if (isa<PHINode>(BB->begin())) 323857f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner SplitCritEdgesForPHIConstants(BB); 3239c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 324057f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) { 32417e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *I = BBI++; 32427e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) { 3243903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeGEPExpression(GEPI, TLI.getTargetData()); 32447e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } else if (CastInst *CI = dyn_cast<CastInst>(I)) { 3245c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // If the source of the cast is a constant, then this should have 3246c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // already been constant folded. The only reason NOT to constant fold 3247c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // it is if something (e.g. LSR) was careful to place the constant 3248c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // evaluation in a block other than then one that uses it (e.g. to hoist 3249c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // the address of globals out of a loop). If this is the case, we don't 3250c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // want to forward-subst the cast. 3251c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner if (isa<Constant>(CI->getOperand(0))) 3252c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner continue; 3253c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner 32547e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is a noop copy, sink it into user blocks to reduce the number 32557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // of virtual registers that must be created and coallesced. 32567e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType SrcVT = TLI.getValueType(CI->getOperand(0)->getType()); 32577e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType DstVT = TLI.getValueType(CI->getType()); 32587e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32597e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // This is an fp<->int conversion? 32607e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (MVT::isInteger(SrcVT) != MVT::isInteger(DstVT)) 32617e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner continue; 32627e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32637e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is an extension, it will be a zero or sign extension, which 32647e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // isn't a noop. 32657e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT < DstVT) continue; 32667e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32677e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If these values will be promoted, find out what they will be promoted 32687e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // to. This helps us consider truncates on PPC as noop copies when they 32697e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // are. 32707e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(SrcVT) == TargetLowering::Promote) 32717e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner SrcVT = TLI.getTypeToTransformTo(SrcVT); 32727e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(DstVT) == TargetLowering::Promote) 32737e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner DstVT = TLI.getTypeToTransformTo(DstVT); 32747e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32757e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If, after promotion, these are the same types, this is a noop copy. 32767e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT == DstVT) 3277903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeNoopCopyExpression(CI); 32787e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 32797e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 328036b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 3281903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3282c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 32831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 32841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 32851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 32861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 3287edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 32881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 32891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 32901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 32911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3292ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 3293ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 3294f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 329518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 3296d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 329718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 3298d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 3299d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 3300d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 3301d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 3302d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 3303d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SelectionDAG &DAG = SDL.DAG; 3304d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 3305d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 33061c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } else if (SrcVT == MVT::Vector) { 330770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Handle copies from generic vectors to registers. 330870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 330970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NE = TLI.getPackedTypeBreakdown(cast<PackedType>(V->getType()), 331070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT, PTyLegalElementVT); 33111c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 331270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Insert a VBIT_CONVERT of the input vector to a "N x PTyElementVT" 331370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // MVT::Vector type. 331470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Op, 331570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getConstant(NE, MVT::i32), 331670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getValueType(PTyElementVT)); 331770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 331870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Loop over all of the elements of the resultant vector, 331970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // VEXTRACT_VECTOR_ELT'ing them, converting them to PTyLegalElementVT, then 332070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // copying them into output registers. 3321bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 332270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Root = SDL.getRoot(); 332370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 332470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Elt = DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, PTyElementVT, 3325a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(i, TLI.getPointerTy())); 332670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 332770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are legal. 332870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 332970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyLegalElementVT > PTyElementVT) { 333070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are promoted. 333170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyLegalElementVT)) 333270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::FP_EXTEND, PTyLegalElementVT, Elt); 333370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 333470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::ANY_EXTEND, PTyLegalElementVT, Elt); 333570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 333670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 333770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are expanded. 333870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // The src value is expanded into multiple registers. 333970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 3340a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(0, TLI.getPointerTy())); 334170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 3342a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(1, TLI.getPointerTy())); 334370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Lo)); 334470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Hi)); 334570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 33461c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } 3347bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, 3348bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 3349d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 3350d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 3351fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 3352fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 3353fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 3354fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 3355d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 3356d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 3357d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 3358d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 3359a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(0, TLI.getPointerTy())); 3360d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 3361a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(1, TLI.getPointerTy())); 3362d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo); 3363d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 3364d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 33651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 33661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3367068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 3368068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 3369068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 33701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 3371068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 33720afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 3373bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 3374bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 3375bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3376bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 3377bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 3378bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 3379bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 3380bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 3381f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 3382bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 3383bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 3384bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 3385bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 3386bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 3387bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 3388bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 33890afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 3390bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3391bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 3392966454129dc62260df1f438f0243f6877dcd185cChris Lattner // FIXME: this should insert code into the DAG! 3393bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 3394068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 3395068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3396068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 3397068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 3398f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 3399068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 3400068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3401068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 3402edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3403bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 3404bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 3405bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 34061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 34081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 34091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 34111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 34121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 34131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 3414f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 34151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 34161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 34171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 3418f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 3419ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 34201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 3421ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3422ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 34231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 34241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 34261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 34271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 34281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 34291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 34301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 3431edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 34321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 34341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 3435d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 34361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 34371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 34381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 34391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 34401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 3441d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (!isa<PHINode>(SuccBB->begin())) continue; 3442d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 34431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 34441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 34451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 34471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 34481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 34491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 3450f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 3451f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 3452f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 3453f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 3454f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 3455f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 3456f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 3457f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 3458ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3459ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 3460f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 3461f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 3462f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 3463f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 3464ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 3465edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 3466ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 3467ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 3468ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 3469ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3470ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 3471ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 34721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3473edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3474f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 3475f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 34767e02151ce2686687446ba7293e66d6b096106e68Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 34777e02151ce2686687446ba7293e66d6b096106e68Chris Lattner unsigned NumElements; 34787e02151ce2686687446ba7293e66d6b096106e68Chris Lattner if (VT != MVT::Vector) 34797e02151ce2686687446ba7293e66d6b096106e68Chris Lattner NumElements = TLI.getNumElements(VT); 34807e02151ce2686687446ba7293e66d6b096106e68Chris Lattner else { 34817e02151ce2686687446ba7293e66d6b096106e68Chris Lattner MVT::ValueType VT1,VT2; 34827e02151ce2686687446ba7293e66d6b096106e68Chris Lattner NumElements = 34837e02151ce2686687446ba7293e66d6b096106e68Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 34847e02151ce2686687446ba7293e66d6b096106e68Chris Lattner VT1, VT2); 34857e02151ce2686687446ba7293e66d6b096106e68Chris Lattner } 3486f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 3487f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 34881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 34891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 34901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 34911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3492ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 34935a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 34947436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 34957436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 34967436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 34977436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 34987436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 34997436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 35007436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 35017436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 35027436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 35037436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 35047436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 35057436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 3506bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 3507bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &UnorderedChains[0], UnorderedChains.size())); 3508ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 3509ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 35101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 35111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 3512a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 3513f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 351437efe6764568a3829fee26aba532283131d1a104Nate Begeman // lowering, as well as any jump table information. 3515f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 3516f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 351737efe6764568a3829fee26aba532283131d1a104Nate Begeman JT = SDL.JT; 3518f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3519a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 3520a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 35211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 35221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3523f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 3524af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 3525af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(false); 35262300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 35271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 35281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 3529f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 35301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 35311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 3532ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 3533f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 35341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 35351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 3536f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3537af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 3538af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(true); 35392300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 3540a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 3541552c4a849422ad91fa9988255ae35aebbf3acf7bEvan Cheng 3542a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 3543a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 35441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 3545f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 35461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 35471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 3548f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 3549f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3550f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 3551f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 3552f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 3553f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 3554f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 3555f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 3556f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3557f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 3558f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 3559f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 35601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3561f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 3562f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 3563f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3564f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3565a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 35661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 356737efe6764568a3829fee26aba532283131d1a104Nate Begeman if (SwitchCases.empty() && JT.Reg == 0) { 3568f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 3569f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 3570f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 3571f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 357209e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 3573f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 3574f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3575f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 35761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3577f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 35789453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 35799453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 35809453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 358137efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.Reg) { 358237efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(SwitchCases.empty() && "Cannot have jump table and lowered switch"); 358337efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 358437efe6764568a3829fee26aba532283131d1a104Nate Begeman CurDAG = &SDAG; 358537efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 35869453eea49bca1c3904047db495855c93e001d1cdNate Begeman MachineBasicBlock *RangeBB = BB; 358737efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 358837efe6764568a3829fee26aba532283131d1a104Nate Begeman BB = JT.MBB; 358937efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.setCurrentBasicBlock(BB); 359037efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 359137efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.visitJumpTable(JT); 359237efe6764568a3829fee26aba532283131d1a104Nate Begeman SDAG.setRoot(SDL.getRoot()); 359337efe6764568a3829fee26aba532283131d1a104Nate Begeman CodeGenAndEmitDAG(SDAG); 359437efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 359537efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 359637efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 359737efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 359837efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 359937efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 3600f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (PHIBB == JT.Default) { 360109e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 3602f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(RangeBB); 3603f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 3604f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (BB->succ_end() != std::find(BB->succ_begin(),BB->succ_end(), PHIBB)) { 360509e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 3606f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(BB); 360737efe6764568a3829fee26aba532283131d1a104Nate Begeman } 360837efe6764568a3829fee26aba532283131d1a104Nate Begeman } 360937efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 361037efe6764568a3829fee26aba532283131d1a104Nate Begeman } 361137efe6764568a3829fee26aba532283131d1a104Nate Begeman 3612f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 3613f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 3614d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 3615f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 3616f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 3617f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 3618d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3619f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 3620f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 3621f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 3622d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3623f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 3624f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 3625f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 3626f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 3627d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3628d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Handle any PHI nodes in successors of this chunk, as if we were coming 3629d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // from the original BB before switch expansion. Note that PHI nodes can 3630d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // occur multiple times in PHINodesToUpdate. We have to be very careful to 3631d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // handle them the right number of times. 3632d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner while ((BB = SwitchCases[i].LHSBB)) { // Handle LHS and RHS. 3633d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (MachineBasicBlock::iterator Phi = BB->begin(); 3634d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi != BB->end() && Phi->getOpcode() == TargetInstrInfo::PHI; ++Phi){ 3635d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // This value for this PHI node is recorded in PHINodesToUpdate, get it. 3636d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned pn = 0; ; ++pn) { 3637d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner assert(pn != PHINodesToUpdate.size() && "Didn't find PHI entry!"); 3638d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (PHINodesToUpdate[pn].first == Phi) { 3639d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addRegOperand(PHINodesToUpdate[pn].second, false); 3640d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addMachineBasicBlockOperand(SwitchCases[i].ThisBB); 3641d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner break; 3642d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 3643d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 3644f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3645d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3646d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Don't process RHS if same block as LHS. 3647d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (BB == SwitchCases[i].RHSBB) 3648d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner SwitchCases[i].RHSBB = 0; 3649d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3650d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // If we haven't handled the RHS, do so now. Otherwise, we're done. 3651d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner SwitchCases[i].LHSBB = SwitchCases[i].RHSBB; 3652d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner SwitchCases[i].RHSBB = 0; 3653f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3654d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner assert(SwitchCases[i].LHSBB == 0 && SwitchCases[i].RHSBB == 0); 3655a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 36561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 3657a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 365813ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 3659a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 3660a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 3661a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 3662a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 3663a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 366413ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 3665eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterScheduler::FunctionPassCtor Ctor = RegisterScheduler::getDefault(); 366613ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 366713ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 3668eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = ISHeuristic; 36699373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey RegisterScheduler::setDefault(Ctor); 36704ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 367113ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 36729ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey ScheduleDAG *SL = Ctor(this, &DAG, BB); 3673a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 3674cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 3675a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 36760e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 367703fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 36789ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim LaskeyHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 36799ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey return new HazardRecognizer(); 36809ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey} 36819ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 36829ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 36830e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 36840e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 36850e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 36860e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 36870e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 36880e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 36890e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 36900e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 36910e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 36920e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 36930e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 36940e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 36950e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 36960e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 36970e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 36980e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 36990e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 37000e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 37010e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 37020e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 37030e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 37040e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 37050e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 37060e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 37070e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 37080e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::cerr << "Could not match memory address. Inline asm failure!\n"; 37090e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 37100e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 37110e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 37120e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 37130e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(DAG.getConstant(4/*MEM*/ | (SelOps.size() << 3), MVT::i32)); 37140e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 37150e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 37160e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 37170e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 37180e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 37190e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 37200e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 37210e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 37220e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 3723