SelectionDAGISel.cpp revision dd433210797bc13513989a033e488d4e19442723
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" 15c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey#include "llvm/Analysis/AliasAnalysis.h" 163cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng#include "llvm/Analysis/LoopInfo.h" 171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 18a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng#include "llvm/CodeGen/ScheduleDAG.h" 19adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Constants.h" 211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 2336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner#include "llvm/GlobalVariable.h" 24ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner#include "llvm/InlineAsm.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 2743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey#include "llvm/IntrinsicInst.h" 2844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey#include "llvm/CodeGen/MachineModuleInfo.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 3137efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 33eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey#include "llvm/CodeGen/SchedulerRegistry.h" 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 36fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 373f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner#include "llvm/Target/TargetAsmInfo.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 43124729155d860a0850eb4ef2a7cea4145e13a057Vladimir Prus#include "llvm/Target/TargetOptions.h" 44495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 457c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 47a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 487e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 51da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 527944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 53a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 54a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 55a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 56a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 57a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 587944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 595e46a19ec848cd4fc9649bd5170c43d9e657668cChris Lattnerstatic const bool ViewISelDAGs = 0, ViewSchedDAGs = 0; 607944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 617944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 62eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 63eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 64eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// RegisterScheduler class - Track the registration of instruction schedulers. 65eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 66eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 67eb577ba3b815a1fa4627b060dd2345d17abf672dJim LaskeyMachinePassRegistry RegisterScheduler::Registry; 68eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 69eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 70eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 71eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// ISHeuristic command line option for instruction schedulers. 72eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 73eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 744ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Chengnamespace { 75eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey cl::opt<RegisterScheduler::FunctionPassCtor, false, 76eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterPassParser<RegisterScheduler> > 7713ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey ISHeuristic("sched", 783700f90c19f51deae00f85b80d31e1f7fbda1f99Chris Lattner cl::init(&createDefaultScheduler), 7913ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey cl::desc("Instruction schedulers available:")); 8013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 819ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey static RegisterScheduler 829373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey defaultListDAGScheduler("default", " Best scheduler for the target", 839373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey createDefaultScheduler); 844ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng} // namespace 854ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 86864635ad7b3046d3042311423071152c613961deChris Lattnernamespace { 87864635ad7b3046d3042311423071152c613961deChris Lattner /// RegsForValue - This struct represents the physical registers that a 88864635ad7b3046d3042311423071152c613961deChris Lattner /// particular value is assigned and the type information about the value. 89864635ad7b3046d3042311423071152c613961deChris Lattner /// This is needed because values can be promoted into larger registers and 90864635ad7b3046d3042311423071152c613961deChris Lattner /// expanded into multiple smaller registers than the value. 919525528a7dc5462b6374d38c81ba5c07b11741feChris Lattner struct VISIBILITY_HIDDEN RegsForValue { 92864635ad7b3046d3042311423071152c613961deChris Lattner /// Regs - This list hold the register (for legal and promoted values) 93864635ad7b3046d3042311423071152c613961deChris Lattner /// or register set (for expanded values) that the value should be assigned 94864635ad7b3046d3042311423071152c613961deChris Lattner /// to. 95864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 96864635ad7b3046d3042311423071152c613961deChris Lattner 97864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT - The value type of each register. 98864635ad7b3046d3042311423071152c613961deChris Lattner /// 99864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 100864635ad7b3046d3042311423071152c613961deChris Lattner 101864635ad7b3046d3042311423071152c613961deChris Lattner /// ValueVT - The value type of the LLVM value, which may be promoted from 102864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT or made from merging the two expanded parts. 103864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT; 104864635ad7b3046d3042311423071152c613961deChris Lattner 105864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue() : RegVT(MVT::Other), ValueVT(MVT::Other) {} 106864635ad7b3046d3042311423071152c613961deChris Lattner 107864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(unsigned Reg, MVT::ValueType regvt, MVT::ValueType valuevt) 108864635ad7b3046d3042311423071152c613961deChris Lattner : RegVT(regvt), ValueVT(valuevt) { 109864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 110864635ad7b3046d3042311423071152c613961deChris Lattner } 111864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(const std::vector<unsigned> ®s, 112864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType regvt, MVT::ValueType valuevt) 113864635ad7b3046d3042311423071152c613961deChris Lattner : Regs(regs), RegVT(regvt), ValueVT(valuevt) { 114864635ad7b3046d3042311423071152c613961deChris Lattner } 115864635ad7b3046d3042311423071152c613961deChris Lattner 116864635ad7b3046d3042311423071152c613961deChris Lattner /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from 117864635ad7b3046d3042311423071152c613961deChris Lattner /// this value and returns the result as a ValueVT value. This uses 118864635ad7b3046d3042311423071152c613961deChris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 119864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand getCopyFromRegs(SelectionDAG &DAG, 1209f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const; 121c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 122c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 123c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// specified value into the registers specified by this object. This uses 124c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 125c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 126a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 127a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const; 128c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 129c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// AddInlineAsmOperands - Add this value to the specified inlineasm node 130c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// operand list. This adds the code marker and includes the number of 131c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// values added into it. 132c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 1339f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const; 134864635ad7b3046d3042311423071152c613961deChris Lattner }; 135864635ad7b3046d3042311423071152c613961deChris Lattner} 1364ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 1371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 1381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 1399373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// createDefaultScheduler - This creates an instruction scheduler appropriate 1409373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// for the target. 1419373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey ScheduleDAG* createDefaultScheduler(SelectionDAGISel *IS, 1429373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey SelectionDAG *DAG, 1439373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey MachineBasicBlock *BB) { 1449373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering &TLI = IS->getTargetLowering(); 1459373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1469373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) { 1479373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createTDListDAGScheduler(IS, DAG, BB); 1489373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } else { 1499373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey assert(TLI.getSchedulingPreference() == 1509373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering::SchedulingForRegPressure && "Unknown sched type!"); 1519373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createBURRListDAGScheduler(IS, DAG, BB); 1529373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1539373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1549373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1559373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1569373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey //===--------------------------------------------------------------------===// 1571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 1581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 159f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 160f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 1611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 1621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 1631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 1651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 1671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 1691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 1701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 1749f24ad79ce32200b06499ef638b502fc1c36ed04Chris Lattner DenseMap<const Value*, unsigned> ValueMap; 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 184571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 185571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner /// isExportedInst - Return true if the specified value is an instruction 186571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner /// exported from its block. 187571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner bool isExportedInst(const Value *V) { 188571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return ValueMap.count(V); 189571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 190edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1913c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned CreateRegForValue(const Value *V); 1923c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 1931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 202f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// PHI nodes or outside of the basic block that defines it, or used by a 203f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// switch instruction, which may expand to multiple basic blocks. 2041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 2051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 208f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI) || 209571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // FIXME: Remove switchinst special case. 210f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman isa<SwitchInst>(*UI)) 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 2121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 2131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 215bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 216f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// entry block, return true. This includes arguments used by switches, since 217f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the switch may expand into multiple basic blocks. 218bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 219bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 220bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 221f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != Entry || isa<SwitchInst>(*UI)) 222bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 223bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 224bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 225bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 227edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 2281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 2291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 230bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 231bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 23216ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 23316ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 234bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 235bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 2361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 237bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 238bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 239bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 2402aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 2411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 243b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (ConstantInt *CUI = dyn_cast<ConstantInt>(AI->getArraySize())) { 2441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 245a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 246ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 247d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner std::max((unsigned)TLI.getTargetData()->getPrefTypeAlignment(Ty), 248ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 249a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 250b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer TySize *= CUI->getZExtValue(); // Get total allocated size. 251d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 2521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 253f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 2541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2562aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 2572aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 2591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 2601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 2611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 2662aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 2671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 2681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 2691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 2701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 2721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 2748c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner for (BasicBlock::iterator I = BB->begin();(PN = dyn_cast<PHINode>(I)); ++I){ 2758c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (PN->use_empty()) continue; 2768c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 2778c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 2788c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned NumElements; 2798c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (VT != MVT::Vector) 2808c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner NumElements = TLI.getNumElements(VT); 2818c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner else { 2828c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT1,VT2; 2838c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner NumElements = 2849d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer TLI.getVectorTypeBreakdown(cast<VectorType>(PN->getType()), 2858c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner VT1, VT2); 286f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2878c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned PHIReg = ValueMap[PN]; 2888c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner assert(PHIReg && "PHI node does not have an assigned virtual register!"); 289c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo *TII = TLI.getTargetMachine().getInstrInfo(); 2908c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner for (unsigned i = 0; i != NumElements; ++i) 291c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(MBB, TII->get(TargetInstrInfo::PHI), PHIReg+i); 2928c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 2931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2963c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// CreateRegForValue - Allocate the appropriate number of virtual registers of 2973c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// the correctly promoted or expanded types. Assign these registers 2983c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// consecutive vreg numbers and return the first assigned number. 2993c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattnerunsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) { 3003c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 3013c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3023c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The number of multiples of registers that we need, to, e.g., split up 3033c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // a <2 x int64> -> 4 x i32 registers. 3043c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumVectorRegs = 1; 3053c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 306ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // If this is a vector type, figure out what type it will decompose into 3073c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // and how many of the elements it will use. 3083c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (VT == MVT::Vector) { 3099d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(V->getType()); 3103c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumElts = PTy->getNumElements(); 3113c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType EltTy = TLI.getValueType(PTy->getElementType()); 3123c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3133c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // Divide the input until we get to a supported size. This will always 3143c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // end with a scalar if the target doesn't support vectors. 3153c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (NumElts > 1 && !TLI.isTypeLegal(getVectorType(EltTy, NumElts))) { 3163c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumElts >>= 1; 3173c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumVectorRegs <<= 1; 3183c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3196cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner if (NumElts == 1) 3206cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = EltTy; 3216cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner else 3226cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = getVectorType(EltTy, NumElts); 3233c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3243c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3253c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The common case is that we will only create one register for this 3263c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // value. If we have that case, create and return the virtual register. 3273c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NV = TLI.getNumElements(VT); 3283c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (NV == 1) { 3293c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If we are promoting this value, pick the next largest supported type. 3303c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType PromotedType = TLI.getTypeToTransformTo(VT); 3313c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned Reg = MakeReg(PromotedType); 3323c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a vector of supported or promoted types (e.g. 4 x i16), 3333c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // create all of the registers. 3343c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NumVectorRegs; ++i) 3353c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg(PromotedType); 3363c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return Reg; 3373c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3383c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3393c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this value is represented with multiple target registers, make sure 3403c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // to create enough consecutive registers of the right (smaller) type. 3419f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng VT = TLI.getTypeToExpandTo(VT); 3429f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned R = MakeReg(VT); 3433c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NV*NumVectorRegs; ++i) 3449f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MakeReg(VT); 3453c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return R; 3463c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner} 3471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 3491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 3501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 3511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 3521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 3531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 3541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 3551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 3561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3570da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner DenseMap<const Value*, SDOperand> NodeMap; 3581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 359d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 360d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 361d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 362d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 363d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 364d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 365f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Case - A pair of values to record the Value for a switch case, and the 366f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// case's target basic block. 367f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<Constant*, MachineBasicBlock*> Case; 368f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::vector<Case>::iterator CaseItr; 369f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<CaseItr, CaseItr> CaseRange; 370f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 371f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseRec - A struct with ctor used in lowering switches to a binary tree 372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// of conditional branches. 373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseRec { 374f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec(MachineBasicBlock *bb, Constant *lt, Constant *ge, CaseRange r) : 375f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseBB(bb), LT(lt), GE(ge), Range(r) {} 376f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 377f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseBB - The MBB in which to emit the compare and branch 378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *CaseBB; 379f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// LT, GE - If nonzero, we know the current case value must be less-than or 380f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// greater-than-or-equal-to these Constants. 381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *LT; 382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *GE; 383f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Range - A pair of iterators representing the range of case values to be 384f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// processed at this point in the binary search tree. 385f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange Range; 386f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 387b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 388b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov typedef std::vector<CaseRec> CaseRecVector; 389f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 390f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// The comparison function for sorting Case values. 391f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 392f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman bool operator () (const Case& C1, const Case& C2) { 39347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer assert(isa<ConstantInt>(C1.first) && isa<ConstantInt>(C2.first)); 394ae4f99d8430f06cfbc316f231e404201d288ef94Chris Lattner return cast<const ConstantInt>(C1.first)->getSExtValue() < 395ae4f99d8430f06cfbc316f231e404201d288ef94Chris Lattner cast<const ConstantInt>(C2.first)->getSExtValue(); 396f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 397f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 398f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 4001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 4011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 4021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 4031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 405a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD; 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 407f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 408f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 409f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 4103a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov /// JTCases - Vector of JumpTable structures used to communicate 4113a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov /// SwitchInst code generation information. 4123a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov std::vector<SelectionDAGISel::JumpTableBlock> JTCases; 413f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 4151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 419edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 4201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 4213a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov FuncInfo(funcinfo) { 4221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 424a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 425a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 426a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 427d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 428d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 429edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 430d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 431d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 432d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 433d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 434d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 435d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 436d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 437d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 438bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, 439bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &PendingLoads[0], PendingLoads.size()); 440d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 441d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 442d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 443a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 444a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 445571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand CopyValueToVirtualRegister(Value *V, unsigned Reg); 446571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 4471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4501e7aa5c209109d07af30c8a2e9bfd82cf3824246Chris Lattner // Note: this doesn't use InstVisitor, because it has to work with 4511e7aa5c209109d07af30c8a2e9bfd82cf3824246Chris Lattner // ConstantExpr's in addition to instructions. 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 46428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 465466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 46628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile); 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 472199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4740da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner void setValue(const Value *V, SDOperand NewN) { 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4770da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner N = NewN; 4781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4794e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 480864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue GetRegistersForValue(const std::string &ConstrCode, 481864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, 482864635ad7b3046d3042311423071152c613961deChris Lattner bool OutReg, bool InReg, 483864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 484864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &InputRegs); 485f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 486571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void FindMergedConditions(Value *Cond, MachineBasicBlock *TBB, 487571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, MachineBasicBlock *CurBB, 488571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc); 4898c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner bool isExportableFromCurrentBlock(Value *V, const BasicBlock *FromBB); 490571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void ExportFromCurrentBlock(Value *V); 4911da20a71d1bbabc472f281208be77475550be751Jim Laskey void LowerCallTo(Instruction &I, 4921da20a71d1bbabc472f281208be77475550be751Jim Laskey const Type *CalledValueTy, unsigned CallingConv, 4931da20a71d1bbabc472f281208be77475550be751Jim Laskey bool IsTailCall, SDOperand Callee, unsigned OpIdx); 494735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 4951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 4961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 4971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 498f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 4991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 5001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 501b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Helpers for visitSwitch 502dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov bool handleSmallSwitchRange(CaseRec& CR, 503b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 504b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 505b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default); 506dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov bool handleJTSwitchCase(CaseRec& CR, 507b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 508b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 509b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default); 510dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov bool handleBTSplitSwitchCase(CaseRec& CR, 511b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 512b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 513b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default); 514f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 51537efe6764568a3829fee26aba532283131d1a104Nate Begeman void visitJumpTable(SelectionDAGISel::JumpTable &JT); 5163a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov void visitJumpTableHeader(SelectionDAGISel::JumpTable &JT, 5173a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAGISel::JumpTableHeader &JTH); 518f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 5191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 520b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey void visitInvoke(InvokeInst &I); 521183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey void visitInvoke(InvokeInst &I, bool AsTerminator); 522b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey void visitUnwind(UnwindInst &I); 5231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 52424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitScalarBinary(User &I, unsigned OpCode); 52524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitVectorBinary(User &I, unsigned OpCode); 52624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitEitherBinary(User &I, unsigned ScalarOp, unsigned VectorOp); 527e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 5285fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 5299d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (isa<VectorType>(I.getType())) 53024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, ISD::VADD); 53124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer else if (I.getType()->isFloatingPoint()) 53224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::FADD); 5331628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 53424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::ADD); 53501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 536b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 5371628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitMul(User &I) { 5389d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (isa<VectorType>(I.getType())) 53924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, ISD::VMUL); 54024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer else if (I.getType()->isFloatingPoint()) 54124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::FMUL); 5421628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 54324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::MUL); 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 54524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitURem(User &I) { visitScalarBinary(I, ISD::UREM); } 54624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitSRem(User &I) { visitScalarBinary(I, ISD::SREM); } 54724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitFRem(User &I) { visitScalarBinary(I, ISD::FREM); } 54824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitUDiv(User &I) { visitEitherBinary(I, ISD::UDIV, ISD::VUDIV); } 54924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitSDiv(User &I) { visitEitherBinary(I, ISD::SDIV, ISD::VSDIV); } 55024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitFDiv(User &I) { visitEitherBinary(I, ISD::FDIV, ISD::VSDIV); } 55124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitAnd (User &I) { visitEitherBinary(I, ISD::AND, ISD::VAND ); } 55224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitOr (User &I) { visitEitherBinary(I, ISD::OR, ISD::VOR ); } 55324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitXor (User &I) { visitEitherBinary(I, ISD::XOR, ISD::VXOR ); } 55424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitShl (User &I) { visitShift(I, ISD::SHL); } 5553822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer void visitLShr(User &I) { visitShift(I, ISD::SRL); } 5563822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer void visitAShr(User &I) { visitShift(I, ISD::SRA); } 55745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer void visitICmp(User &I); 55845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer void visitFCmp(User &I); 5593da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Visit the conversion instructions 5603da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitTrunc(User &I); 5613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitZExt(User &I); 5623da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitSExt(User &I); 5633da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPTrunc(User &I); 5643da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPExt(User &I); 5653da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPToUI(User &I); 5663da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPToSI(User &I); 5673da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitUIToFP(User &I); 5683da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitSIToFP(User &I); 5693da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitPtrToInt(User &I); 5703da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitIntToPtr(User &I); 5713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitBitCast(User &I); 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5732bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5742bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 5753e104b11168da4692b69cc6b236c1da22adff959Chris Lattner void visitShuffleVector(User &I); 576c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 587ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner void visitInlineAsm(CallInst &I); 588c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 5890eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 5901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 5921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 5931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 5941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 5951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5967041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 5971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 5991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 6001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 6011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 6031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 6041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 6051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 6071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 6081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 609199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 610199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 611199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 612199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 613199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 614199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 615199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 616199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 617199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 6180da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner SDOperand N1 = NodeMap[V]; 6190da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner assert(N1.Val && "visit didn't populate the ValueMap!"); 6200da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner return N1; 621199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 622199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 623199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 624199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 625199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 6269d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (!isa<VectorType>(VTy)) 62723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 62823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 629b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR of undef nodes. 6309d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(VTy); 63123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 63223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 63323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 634bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 63523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 63623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 63723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 63823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 63923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 640bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, 641bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 642199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 643199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 6449d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer } else if (const VectorType *PTy = dyn_cast<VectorType>(VTy)) { 645199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 646199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 647199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 648199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 649199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 650199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // the packed constant. 651bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 6529d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) { 6532bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 6542bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 655199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 656199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 657199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 658199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 659199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 660199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 661199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 662199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 663199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 664199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 665b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR node with generic Vector type. 66623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 66723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 6680da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner return NodeMap[V] = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, &Ops[0], 6690da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner Ops.size()); 670199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 671199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 6726b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng return N = DAG.getConstant(cast<ConstantInt>(C)->getZExtValue(),VT); 673199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 674199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 675199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 676199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 677199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 678199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 679199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 680199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 681199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 682199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 683251db1890c1fe03d02ee878ada8129537844d031Chris Lattner unsigned InReg = FuncInfo.ValueMap[V]; 684251db1890c1fe03d02ee878ada8129537844d031Chris Lattner assert(InReg && "Value not in map!"); 685199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 686199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // If this type is not legal, make it so now. 68770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) { 6889f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (TLI.getTypeAction(VT) == TargetLowering::Expand) { 68970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Source must be expanded. This input value is actually coming from the 690251db1890c1fe03d02ee878ada8129537844d031Chris Lattner // register pair InReg and InReg+1. 6919f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType DestVT = TLI.getTypeToExpandTo(VT); 6929f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = TLI.getNumElements(VT); 6939f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 6949f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (NumVals == 1) 6959f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getNode(ISD::BIT_CONVERT, VT, N); 6969f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng else { 6979f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng assert(NumVals == 2 && "1 to 4 (and more) expansion not implemented!"); 6989f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 6999f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 7009f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng } 7019f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng } else { 7029f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 7039f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 7049f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (TLI.getTypeAction(VT) == TargetLowering::Promote) // Promotion case 7059f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = MVT::isFloatingPoint(VT) 7069f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng ? DAG.getNode(ISD::FP_ROUND, VT, N) 7079f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng : DAG.getNode(ISD::TRUNCATE, VT, N); 708199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 70970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 71070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Otherwise, if this is a vector, make it available as a generic vector 71170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // here. 71270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 7139d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(VTy); 7149d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer unsigned NE = TLI.getVectorTypeBreakdown(PTy, PTyElementVT, 71570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyLegalElementVT); 71670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 71770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Build a VBUILD_VECTOR with the input registers. 718bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 71970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 72070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the value types are legal, just VBUILD the CopyFromReg nodes. 72170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) 72270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 72370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT)); 72470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyElementVT < PTyLegalElementVT) { 72570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was promoted, use TRUNCATE of FP_ROUND as appropriate. 72670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 72770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 72870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 72970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyElementVT)) 73070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::FP_ROUND, PTyElementVT, Op); 73170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 73270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::TRUNCATE, PTyElementVT, Op); 73370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(Op); 73470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 73570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 73670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was expanded, use BUILD_PAIR. 73770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner assert((NE & 1) == 0 && "Must expand into a multiple of 2 elements!"); 73870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE/2; ++i) { 73970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op0 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 74070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 74170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op1 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 74270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 74370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Op0, Op1)); 74470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 74570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 74670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 74770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getConstant(NE, MVT::i32)); 74870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getValueType(PTyLegalElementVT)); 749bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, &Ops[0], Ops.size()); 7502e2ef9535070bb352601482cceac1140c1158cddChris Lattner 7512e2ef9535070bb352601482cceac1140c1158cddChris Lattner // Finally, use a VBIT_CONVERT to make this available as the appropriate 7522e2ef9535070bb352601482cceac1140c1158cddChris Lattner // vector type. 7532e2ef9535070bb352601482cceac1140c1158cddChris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 7542e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getConstant(PTy->getNumElements(), 7552e2ef9535070bb352601482cceac1140c1158cddChris Lattner MVT::i32), 7562e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getValueType(TLI.getValueType(PTy->getElementType()))); 757199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 758199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 759199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 760199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 761199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 762199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 7631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 7641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 765a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 7661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 7671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 768bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> NewValues; 769ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 770ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 771ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 772ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman 773ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // If this is an integer return value, we need to promote it ourselves to 774ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // the full width of a register, since LegalizeOp will use ANY_EXTEND rather 775ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // than sign/zero. 7768e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // FIXME: C calling convention requires the return type to be promoted to 7778e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // at least 32-bit. But this is not necessary for non-C calling conventions. 778ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (MVT::isInteger(RetOp.getValueType()) && 779ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp.getValueType() < MVT::i64) { 780ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman MVT::ValueType TmpVT; 781ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 782ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = TLI.getTypeToTransformTo(MVT::i32); 783ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 784ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = MVT::i32; 78547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer const FunctionType *FTy = I.getParent()->getParent()->getFunctionType(); 786bcca3405bd6698af82eeed20e24744d0625aa1b3Reid Spencer ISD::NodeType ExtendKind = ISD::ANY_EXTEND; 7878c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer if (FTy->paramHasAttr(0, FunctionType::SExtAttribute)) 7888c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer ExtendKind = ISD::SIGN_EXTEND; 78947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer if (FTy->paramHasAttr(0, FunctionType::ZExtAttribute)) 79047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ExtendKind = ISD::ZERO_EXTEND; 791376dd212f9142cd0f0b03e0b6296b2df7208bb9aReid Spencer RetOp = DAG.getNode(ExtendKind, TmpVT, RetOp); 792ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 793ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(RetOp); 79447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer NewValues.push_back(DAG.getConstant(false, MVT::i32)); 7951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 796bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, 797bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &NewValues[0], NewValues.size())); 7981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 800571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// ExportFromCurrentBlock - If this condition isn't known to be exported from 801571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// the current basic block, add it to ValueMap now so that we'll get a 802571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// CopyTo/FromReg. 803571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::ExportFromCurrentBlock(Value *V) { 804571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // No need to export constants. 805571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (!isa<Instruction>(V) && !isa<Argument>(V)) return; 806571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 807571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Already exported? 808571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (FuncInfo.isExportedInst(V)) return; 809571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 810571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg = FuncInfo.InitializeRegForValue(V); 811571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner PendingLoads.push_back(CopyValueToVirtualRegister(V, Reg)); 812571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 813571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 8148c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattnerbool SelectionDAGLowering::isExportableFromCurrentBlock(Value *V, 8158c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner const BasicBlock *FromBB) { 8168c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // The operands of the setcc have to be in this block. We don't know 8178c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // how to export them from some other block. 8188c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Instruction *VI = dyn_cast<Instruction>(V)) { 8198c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Can export from current BB. 8208c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (VI->getParent() == FromBB) 8218c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 8228c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8238c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Is already exported, noop. 8248c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return FuncInfo.isExportedInst(V); 8258c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 8268c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8278c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // If this is an argument, we can export it if the BB is the entry block or 8288c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // if it is already exported. 8298c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (isa<Argument>(V)) { 8308c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (FromBB == &FromBB->getParent()->getEntryBlock()) 8318c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 8328c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8338c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Otherwise, can only export this if it is already exported. 8348c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return FuncInfo.isExportedInst(V); 8358c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 8368c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8378c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Otherwise, constants can always be exported. 8388c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 8398c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner} 8408c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8416a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattnerstatic bool InBlock(const Value *V, const BasicBlock *BB) { 8426a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner if (const Instruction *I = dyn_cast<Instruction>(V)) 8436a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner return I->getParent() == BB; 8446a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner return true; 8456a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner} 8466a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner 847571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// FindMergedConditions - If Cond is an expression like 848571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::FindMergedConditions(Value *Cond, 849571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TBB, 850571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, 851571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *CurBB, 852571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc) { 853571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this node is not part of the or/and tree, emit it as a branch. 854e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Instruction *BOp = dyn_cast<Instruction>(Cond); 855571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 856e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) || 857e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() || 8586a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner BOp->getParent() != CurBB->getBasicBlock() || 8596a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) || 8606a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) { 861571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner const BasicBlock *BB = CurBB->getBasicBlock(); 862571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 863e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // If the leaf of the tree is a comparison, merge the condition into 864e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // the caseblock. 865e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if ((isa<ICmpInst>(Cond) || isa<FCmpInst>(Cond)) && 866e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // The operands of the cmp have to be in this block. We don't know 8675a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner // how to export them from some other block. If this is the first block 8685a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner // of the sequence, no exporting is needed. 8695a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner (CurBB == CurMBB || 8705a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner (isExportableFromCurrentBlock(BOp->getOperand(0), BB) && 8715a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner isExportableFromCurrentBlock(BOp->getOperand(1), BB)))) { 872e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer BOp = cast<Instruction>(Cond); 873e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode Condition; 874e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *IC = dyn_cast<ICmpInst>(Cond)) { 875e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (IC->getPredicate()) { 876e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: assert(0 && "Unknown icmp predicate opcode!"); 877e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_EQ: Condition = ISD::SETEQ; break; 878e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_NE: Condition = ISD::SETNE; break; 879e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLE: Condition = ISD::SETLE; break; 880e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULE: Condition = ISD::SETULE; break; 881e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGE: Condition = ISD::SETGE; break; 882e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGE: Condition = ISD::SETUGE; break; 883e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLT: Condition = ISD::SETLT; break; 884e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULT: Condition = ISD::SETULT; break; 885e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGT: Condition = ISD::SETGT; break; 886e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGT: Condition = ISD::SETUGT; break; 887e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 888e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else if (FCmpInst *FC = dyn_cast<FCmpInst>(Cond)) { 889e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode FPC, FOC; 890e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (FC->getPredicate()) { 891e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: assert(0 && "Unknown fcmp predicate opcode!"); 892e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: FOC = FPC = ISD::SETFALSE; break; 893e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OEQ: FOC = ISD::SETEQ; FPC = ISD::SETOEQ; break; 894e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGT: FOC = ISD::SETGT; FPC = ISD::SETOGT; break; 895e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGE: FOC = ISD::SETGE; FPC = ISD::SETOGE; break; 896e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLT: FOC = ISD::SETLT; FPC = ISD::SETOLT; break; 897e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLE: FOC = ISD::SETLE; FPC = ISD::SETOLE; break; 898e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ONE: FOC = ISD::SETNE; FPC = ISD::SETONE; break; 899e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ORD: FOC = ISD::SETEQ; FPC = ISD::SETO; break; 900e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNO: FOC = ISD::SETNE; FPC = ISD::SETUO; break; 901e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UEQ: FOC = ISD::SETEQ; FPC = ISD::SETUEQ; break; 902e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGT: FOC = ISD::SETGT; FPC = ISD::SETUGT; break; 903e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGE: FOC = ISD::SETGE; FPC = ISD::SETUGE; break; 904e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULT: FOC = ISD::SETLT; FPC = ISD::SETULT; break; 905e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULE: FOC = ISD::SETLE; FPC = ISD::SETULE; break; 906e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNE: FOC = ISD::SETNE; FPC = ISD::SETUNE; break; 907e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: FOC = FPC = ISD::SETTRUE; break; 908e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 909e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FiniteOnlyFPMath()) 910e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FOC; 911e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else 912e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FPC; 913e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else { 9140da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner Condition = ISD::SETEQ; // silence warning. 915e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer assert(0 && "Unknown compare instruction"); 916571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 917571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 918571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SelectionDAGISel::CaseBlock CB(Condition, BOp->getOperand(0), 919571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOperand(1), TBB, FBB, CurBB); 920571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 921571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 922571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 923571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 924571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Create a CaseBlock record representing this branch. 9256b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng SelectionDAGISel::CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(), 926571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner TBB, FBB, CurBB); 927571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 928571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 929571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 930571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 931d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 932d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Create TmpBB after CurBB. 933571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineFunction::iterator BBI = CurBB; 934571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TmpBB = new MachineBasicBlock(CurBB->getBasicBlock()); 935571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner CurBB->getParent()->getBasicBlockList().insert(++BBI, TmpBB); 936571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 937d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner if (Opc == Instruction::Or) { 938d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X | Y as: 939d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TBB 940d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp TmpBB 941d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 942d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 943d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 944d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 945571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 946d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 947d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, Opc); 948d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 949d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 950d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 951d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } else { 952d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner assert(Opc == Instruction::And && "Unknown merge op!"); 953d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X & Y as: 954d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TmpBB 955d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 956d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 957d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 958d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 959d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 960d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // This requires creation of TmpBB after CurBB. 961d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 962d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 963d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, Opc); 964d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 965d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 966d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 967d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } 968571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 969571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 970df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// If the set of cases should be emitted as a series of branches, return true. 971df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// If we should emit this as a bunch of and/or'd together conditions, return 972df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// false. 973df19f27d039fd791c73e39f4134319debc75db4fChris Lattnerstatic bool 974df19f27d039fd791c73e39f4134319debc75db4fChris LattnerShouldEmitAsBranches(const std::vector<SelectionDAGISel::CaseBlock> &Cases) { 975df19f27d039fd791c73e39f4134319debc75db4fChris Lattner if (Cases.size() != 2) return true; 976df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 9770ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // If this is two comparisons of the same values or'd or and'd together, they 9780ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // will get folded into a single comparison, so don't emit two blocks. 9790ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner if ((Cases[0].CmpLHS == Cases[1].CmpLHS && 9800ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner Cases[0].CmpRHS == Cases[1].CmpRHS) || 9810ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner (Cases[0].CmpRHS == Cases[1].CmpLHS && 9820ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner Cases[0].CmpLHS == Cases[1].CmpRHS)) { 9830ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner return false; 9840ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner } 9850ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 986df19f27d039fd791c73e39f4134319debc75db4fChris Lattner return true; 987df19f27d039fd791c73e39f4134319debc75db4fChris Lattner} 988df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 9891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 9901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 9911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 9921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 9941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 9951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 9961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 9971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 9981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 10001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 10011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 1002a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1003dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 100457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 100557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // Update machine-CFG edges. 100657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(Succ0MBB); 100757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 100857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner return; 100957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner } 101057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 101157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // If this condition is one of the special cases we handle, do special stuff 101257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // now. 101357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Value *CondVal = I.getCondition(); 101457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 1015571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1016571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this is a series of conditions that are or'd or and'd together, emit 1017571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // this as a sequence of branches instead of setcc's with and/or operations. 1018571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // For example, instead of something like: 1019571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 1020571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // C = seteq 1021571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 1022571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // F = setle 1023571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // or C, F 1024571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jnz foo 1025571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Emit: 1026571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 1027571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // je foo 1028571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 1029571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jle foo 1030571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // 1031571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) { 1032571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BOp->hasOneUse() && 1033d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner (BOp->getOpcode() == Instruction::And || 1034571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOpcode() == Instruction::Or)) { 1035571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FindMergedConditions(BOp, Succ0MBB, Succ1MBB, CurMBB, BOp->getOpcode()); 10360ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // If the compares in later blocks need to use values not currently 10370ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // exported from this block, export them now. This block should always 10380ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // be the first entry. 10390ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner assert(SwitchCases[0].ThisBB == CurMBB && "Unexpected lowering!"); 10400ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1041df19f27d039fd791c73e39f4134319debc75db4fChris Lattner // Allow some cases to be rejected. 1042df19f27d039fd791c73e39f4134319debc75db4fChris Lattner if (ShouldEmitAsBranches(SwitchCases)) { 1043df19f27d039fd791c73e39f4134319debc75db4fChris Lattner for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) { 1044df19f27d039fd791c73e39f4134319debc75db4fChris Lattner ExportFromCurrentBlock(SwitchCases[i].CmpLHS); 1045df19f27d039fd791c73e39f4134319debc75db4fChris Lattner ExportFromCurrentBlock(SwitchCases[i].CmpRHS); 1046df19f27d039fd791c73e39f4134319debc75db4fChris Lattner } 1047df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 1048df19f27d039fd791c73e39f4134319debc75db4fChris Lattner // Emit the branch for this block. 1049df19f27d039fd791c73e39f4134319debc75db4fChris Lattner visitSwitchCase(SwitchCases[0]); 1050df19f27d039fd791c73e39f4134319debc75db4fChris Lattner SwitchCases.erase(SwitchCases.begin()); 1051df19f27d039fd791c73e39f4134319debc75db4fChris Lattner return; 10525a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner } 10535a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner 10540ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // Okay, we decided not to do this, remove any inserted MBB's and clear 10550ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // SwitchCases. 10560ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) 10570ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner CurMBB->getParent()->getBasicBlockList().erase(SwitchCases[i].ThisBB); 10580ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1059df19f27d039fd791c73e39f4134319debc75db4fChris Lattner SwitchCases.clear(); 1060571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 1061571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 10622452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner 10632452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Create a CaseBlock record representing this branch. 10646b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng SelectionDAGISel::CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(), 10652452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner Succ0MBB, Succ1MBB, CurMBB); 10662452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Use visitSwitchCase to actually insert the fast branch sequence for this 10672452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // cond branch. 10682452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner visitSwitchCase(CB); 10691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1071f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 1072f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 1073f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 107457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand Cond; 107557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand CondLHS = getValue(CB.CmpLHS); 107657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 1077571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Build the setcc now, fold "(X == true)" to X and "(X == false)" to !X to 1078571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // handle common cases produced by branch lowering. 10796b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng if (CB.CmpRHS == ConstantInt::getTrue() && CB.CC == ISD::SETEQ) 108057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Cond = CondLHS; 10816b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng else if (CB.CmpRHS == ConstantInt::getFalse() && CB.CC == ISD::SETEQ) { 1082571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand True = DAG.getConstant(1, CondLHS.getValueType()); 1083571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Cond = DAG.getNode(ISD::XOR, CondLHS.getValueType(), CondLHS, True); 1084571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } else 1085571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Cond = DAG.getSetCC(MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC); 10863a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 1087f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 1088f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 1089f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1090f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1091f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 1092f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 1093f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1094f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 1095f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 109657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.TrueBB == NextBlock) { 109757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner std::swap(CB.TrueBB, CB.FalseBB); 1098f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 1099f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 1100f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1101f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 110257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.TrueBB)); 110357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.FalseBB == NextBlock) 1104f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 1105f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 1106f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 110757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.FalseBB))); 1108f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 110957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.TrueBB); 111057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.FalseBB); 1111f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1112f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 11133a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov/// visitJumpTable - Emit JumpTable node in the current MBB 111437efe6764568a3829fee26aba532283131d1a104Nate Begemanvoid SelectionDAGLowering::visitJumpTable(SelectionDAGISel::JumpTable &JT) { 111537efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code for the jump table 11163a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov assert(JT.Reg != -1UL && "Should lower JT Header first!"); 111737efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType PTy = TLI.getPointerTy(); 11183d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng SDOperand Index = DAG.getCopyFromReg(getRoot(), JT.Reg, PTy); 11193d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng SDOperand Table = DAG.getJumpTable(JT.JTI, PTy); 11203d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng DAG.setRoot(DAG.getNode(ISD::BR_JT, MVT::Other, Index.getValue(1), 11213d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Table, Index)); 11223d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng return; 112337efe6764568a3829fee26aba532283131d1a104Nate Begeman} 112437efe6764568a3829fee26aba532283131d1a104Nate Begeman 11253a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov/// visitJumpTableHeader - This function emits necessary code to produce index 11263a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov/// in the JumpTable from switch case. 11273a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikovvoid SelectionDAGLowering::visitJumpTableHeader(SelectionDAGISel::JumpTable &JT, 11283a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAGISel::JumpTableHeader &JTH) { 11293a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Subtract the lowest switch case value from the value being switched on 11303a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // and conditional branch to default mbb if the result is greater than the 11313a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // difference between smallest and largest cases. 11323a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand SwitchOp = getValue(JTH.SValue); 11333a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov MVT::ValueType VT = SwitchOp.getValueType(); 11343a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 11353a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getConstant(JTH.First, VT)); 11363a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11373a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // The SDNode we just created, which holds the value being switched on 11383a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // minus the the smallest case value, needs to be copied to a virtual 11393a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // register so it can be used as an index into the jump table in a 11403a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // subsequent basic block. This value may be smaller or larger than the 11413a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // target's pointer type, and therefore require extension or truncating. 11423a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (VT > TLI.getPointerTy()) 11433a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SwitchOp = DAG.getNode(ISD::TRUNCATE, TLI.getPointerTy(), SUB); 11443a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov else 11453a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SwitchOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), SUB); 11463a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11473a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov unsigned JumpTableReg = FuncInfo.MakeReg(TLI.getPointerTy()); 11483a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand CopyTo = DAG.getCopyToReg(getRoot(), JumpTableReg, SwitchOp); 11493a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JT.Reg = JumpTableReg; 11503a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11513a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Emit the range check for the jump table, and branch to the default 11523a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // block for the switch statement if the value being switched on exceeds 11533a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // the largest case in the switch. 11543a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand CMP = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 11553a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getConstant(JTH.Last-JTH.First,VT), 11563a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov ISD::SETUGT); 11573a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11583a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Set NextBlock to be the MBB immediately after the current one, if any. 11593a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // This is used to avoid emitting unnecessary branches to the next block. 11603a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 11613a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov MachineFunction::iterator BBI = CurMBB; 11623a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 11633a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov NextBlock = BBI; 11643a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11653a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, CMP, 11663a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getBasicBlock(JT.Default)); 11673a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11683a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (JT.MBB == NextBlock) 11693a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.setRoot(BrCond); 11703a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov else 11713a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 11723a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getBasicBlock(JT.MBB))); 11733a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov} 11743a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 11753a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 1176b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskeyvoid SelectionDAGLowering::visitInvoke(InvokeInst &I) { 1177183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey assert(0 && "Should never be visited directly"); 1178183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey} 1179183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskeyvoid SelectionDAGLowering::visitInvoke(InvokeInst &I, bool AsTerminator) { 1180b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey // Retrieve successors. 1181b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)]; 1182b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineBasicBlock *LandingPad = FuncInfo.MBBMap[I.getSuccessor(1)]; 1183b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 1184183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey if (!AsTerminator) { 1185183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Mark landing pad so that it doesn't get deleted in branch folding. 1186183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey LandingPad->setIsLandingPad(); 1187183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 1188183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Insert a label before the invoke call to mark the try range. 1189183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // This can be used to detect deletion of the invoke via the 1190183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // MachineModuleInfo. 1191183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 1192183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey unsigned BeginLabel = MMI->NextLabelID(); 1193183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 1194183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey DAG.getConstant(BeginLabel, MVT::i32))); 1195183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 1196183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey LowerCallTo(I, I.getCalledValue()->getType(), 1197183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey I.getCallingConv(), 1198183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey false, 1199183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey getValue(I.getOperand(0)), 1200183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 3); 1201183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 1202183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Insert a label before the invoke call to mark the try range. 1203183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // This can be used to detect deletion of the invoke via the 1204183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // MachineModuleInfo. 1205183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey unsigned EndLabel = MMI->NextLabelID(); 1206183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 1207183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey DAG.getConstant(EndLabel, MVT::i32))); 1208183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 1209183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Inform MachineModuleInfo of range. 1210183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey MMI->addInvoke(LandingPad, BeginLabel, EndLabel); 1211183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 1212183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Update successor info 1213183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey CurMBB->addSuccessor(Return); 1214183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey CurMBB->addSuccessor(LandingPad); 1215183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey } else { 1216183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Drop into normal successor. 1217183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1218183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey DAG.getBasicBlock(Return))); 1219183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey } 1220b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey} 1221b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 1222b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskeyvoid SelectionDAGLowering::visitUnwind(UnwindInst &I) { 1223b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey} 1224b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 1225b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// handleSmaaSwitchCaseRange - Emit a series of specific tests (suitable for 1226b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// small case ranges). 1227dd433210797bc13513989a033e488d4e19442723Anton Korobeynikovbool SelectionDAGLowering::handleSmallSwitchRange(CaseRec& CR, 1228b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 1229b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 1230b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default) { 1231dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Case& BackCase = *(CR.Range.second-1); 1232dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1233dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // Size is the number of Cases represented by this range. 1234dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov unsigned Size = CR.Range.second - CR.Range.first; 1235dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if (Size >=3) 1236dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return false; 1237dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1238b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 1239b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 1240b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 1241b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1242b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Figure out which block is immediately after the current one. 1243b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 1244b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 1245b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1246b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 1247b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov NextBlock = BBI; 1248b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1249b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // TODO: If any two of the cases has the same destination, and if one value 1250b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // is the same as the other, but has one bit unset that the other has set, 1251b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // use bit manipulation to do two compares at once. For example: 1252b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // "if (X == 6 || X == 4)" -> "if ((X|2) == 6)" 1253b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1254b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Rearrange the case blocks so that the last one falls through if possible. 1255b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (NextBlock && Default != NextBlock && BackCase.second != NextBlock) { 1256b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // The last case block won't fall through into 'NextBlock' if we emit the 1257b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // branches in this order. See if rearranging a case value would help. 1258b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second-1; I != E; ++I) { 1259b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (I->second == NextBlock) { 1260b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov std::swap(*I, BackCase); 1261b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov break; 1262b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1263b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1264b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1265b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1266b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a CaseBlock record representing a conditional branch to 1267b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the Case's target mbb if the value being switched on SV is equal 1268b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // to C. 1269b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *CurBlock = CR.CaseBB; 1270b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++I) { 1271b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *FallThrough; 1272b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (I != E-1) { 1273b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FallThrough = new MachineBasicBlock(CurBlock->getBasicBlock()); 1274b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, FallThrough); 1275b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1276b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // If the last case doesn't match, go to the default block. 1277b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FallThrough = Default; 1278b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1279b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1280b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, I->first, 1281b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov I->second, FallThrough, CurBlock); 1282b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1283b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // If emitting the first comparison, just call visitSwitchCase to emit the 1284b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // code into the current block. Otherwise, push the CaseBlock onto the 1285b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // vector to be later processed by SDISel, and insert the node's MBB 1286b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // before the next MBB. 1287b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (CurBlock == CurMBB) 1288b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov visitSwitchCase(CB); 1289b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov else 1290b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SwitchCases.push_back(CB); 1291b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1292b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurBlock = FallThrough; 1293b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1294dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1295dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return true; 1296b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov} 1297b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1298b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// handleJTSwitchCase - Emit jumptable for current switch case range 1299dd433210797bc13513989a033e488d4e19442723Anton Korobeynikovbool SelectionDAGLowering::handleJTSwitchCase(CaseRec& CR, 1300b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 1301b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 1302b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default) { 1303dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Case& FrontCase = *CR.Range.first; 1304dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Case& BackCase = *(CR.Range.second-1); 1305dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1306dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // Size is the number of Cases represented by this range. 1307dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov unsigned Size = CR.Range.second - CR.Range.first; 1308dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1309dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov uint64_t First = cast<ConstantInt>(FrontCase.first)->getSExtValue(); 1310dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov uint64_t Last = cast<ConstantInt>(BackCase.first)->getSExtValue(); 1311dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1312dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if ((!TLI.isOperationLegal(ISD::BR_JT, MVT::Other) && 1313dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov !TLI.isOperationLegal(ISD::BRIND, MVT::Other)) || 1314dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Size <= 5) 1315dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return false; 1316dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1317dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov double Density = (double)Size / (double)((Last - First) + 1ULL); 1318dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if (Density < 0.3125) 1319dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return false; 1320dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1321b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 1322b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 1323dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 1324b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1325b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Figure out which block is immediately after the current one. 1326b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 1327b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 1328b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1329b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 1330b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov NextBlock = BBI; 1331b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1332b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock(); 1333b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1334b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a new basic block to hold the code for loading the address 1335b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // of the jump table, and jumping to it. Update successor information; 1336b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // we will either branch to the default case for the switch, or the jump 1337b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // table. 1338b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *JumpTableBB = new MachineBasicBlock(LLVMBB); 1339b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, JumpTableBB); 1340b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CR.CaseBB->addSuccessor(Default); 1341b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CR.CaseBB->addSuccessor(JumpTableBB); 1342b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1343b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Build a vector of destination BBs, corresponding to each target 1344b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // of the jump table. If the value of the jump table slot corresponds to 1345b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // a case statement, push the case's BB onto the vector, otherwise, push 1346b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the default BB. 1347b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov std::vector<MachineBasicBlock*> DestBBs; 1348b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov int64_t TEI = First; 1349b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++TEI) 1350b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (cast<ConstantInt>(I->first)->getSExtValue() == TEI) { 1351b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov DestBBs.push_back(I->second); 1352b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov ++I; 1353b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1354b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov DestBBs.push_back(Default); 1355b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1356b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1357b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Update successor info. Add one edge to each unique successor. 1358b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Vector bool would be better, but vector<bool> is really slow. 1359b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov std::vector<unsigned char> SuccsHandled; 1360b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SuccsHandled.resize(CR.CaseBB->getParent()->getNumBlockIDs()); 1361b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1362b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(), 1363b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov E = DestBBs.end(); I != E; ++I) { 1364b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (!SuccsHandled[(*I)->getNumber()]) { 1365b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SuccsHandled[(*I)->getNumber()] = true; 1366b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov JumpTableBB->addSuccessor(*I); 1367b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1368b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1369b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1370b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a jump table index for this jump table, or return an existing 1371b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // one. 1372b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov unsigned JTI = CurMF->getJumpTableInfo()->getJumpTableIndex(DestBBs); 1373b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1374b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Set the jump table information so that we can codegen it as a second 1375b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // MachineBasicBlock 1376b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SelectionDAGISel::JumpTable JT(-1UL, JTI, JumpTableBB, Default); 1377b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SelectionDAGISel::JumpTableHeader JTH(First, Last, SV, CR.CaseBB, 1378b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov (CR.CaseBB == CurMBB)); 1379b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (CR.CaseBB == CurMBB) 1380b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov visitJumpTableHeader(JT, JTH); 1381b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1382b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov JTCases.push_back(SelectionDAGISel::JumpTableBlock(JTH, JT)); 1383b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1384dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return true; 1385b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov} 1386b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1387b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// handleBTSplitSwitchCase - emit comparison and split binary search tree into 1388b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// 2 subtrees. 1389dd433210797bc13513989a033e488d4e19442723Anton Korobeynikovbool SelectionDAGLowering::handleBTSplitSwitchCase(CaseRec& CR, 1390b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 1391b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 1392b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default) { 1393b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 1394b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 1395b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 1396b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1397b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Figure out which block is immediately after the current one. 1398b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 1399b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 1400b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1401b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 1402b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov NextBlock = BBI; 1403b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1404b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Case& FrontCase = *CR.Range.first; 1405b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Case& BackCase = *(CR.Range.second-1); 1406b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock(); 1407b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1408b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Size is the number of Cases represented by this range. 1409b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov unsigned Size = CR.Range.second - CR.Range.first; 1410b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1411b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov uint64_t First = cast<ConstantInt>(FrontCase.first)->getSExtValue(); 1412b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov uint64_t Last = cast<ConstantInt>(BackCase.first)->getSExtValue(); 1413b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov double Density = 0; 1414b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseItr Pivot; 1415b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1416b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Select optimal pivot, maximizing sum density of LHS and RHS. This will 1417b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // (heuristically) allow us to emit JumpTable's later. 1418b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov unsigned LSize = 1; 1419b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov unsigned RSize = Size-1; 1420b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, J=I+1, E = CR.Range.second; 1421b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov J!=E; ++I, ++J, ++LSize, --RSize) { 1422b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov uint64_t LEnd = cast<ConstantInt>(I->first)->getSExtValue(); 1423b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov uint64_t RBegin = cast<ConstantInt>(J->first)->getSExtValue(); 1424b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov double LDensity = (double)LSize / (double)((LEnd - First) + 1ULL); 1425b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov double RDensity = (double)RSize / (double)((Last - RBegin) + 1ULL); 1426b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (Density < (LDensity + RDensity)) { 1427b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Pivot = J; 1428b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Density = LDensity + RDensity; 1429b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1430b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1431b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1432b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRange LHSR(CR.Range.first, Pivot); 1433b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRange RHSR(Pivot, CR.Range.second); 1434b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Constant *C = Pivot->first; 1435b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *FalseBB = 0, *TrueBB = 0; 1436b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1437b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // We know that we branch to the LHS if the Value being switched on is 1438b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // less than the Pivot value, C. We use this to optimize our binary 1439b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // tree a bit, by recognizing that if SV is greater than or equal to the 1440b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // LHS's Case Value, and that Case Value is exactly one less than the 1441b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Pivot's Value, then we can branch directly to the LHS's Target, 1442b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // rather than creating a leaf node for it. 1443b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if ((LHSR.second - LHSR.first) == 1 && 1444b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov LHSR.first->first == CR.GE && 1445b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov cast<ConstantInt>(C)->getZExtValue() == 1446b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov (cast<ConstantInt>(CR.GE)->getZExtValue() + 1ULL)) { 1447b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov TrueBB = LHSR.first->second; 1448b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1449b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov TrueBB = new MachineBasicBlock(LLVMBB); 1450b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, TrueBB); 1451b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov WorkList.push_back(CaseRec(TrueBB, C, CR.GE, LHSR)); 1452b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1453b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1454b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Similar to the optimization above, if the Value being switched on is 1455b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // known to be less than the Constant CR.LT, and the current Case Value 1456b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // is CR.LT - 1, then we can branch directly to the target block for 1457b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the current Case Value, rather than emitting a RHS leaf node for it. 1458b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if ((RHSR.second - RHSR.first) == 1 && CR.LT && 1459b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov cast<ConstantInt>(RHSR.first->first)->getZExtValue() == 1460b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov (cast<ConstantInt>(CR.LT)->getZExtValue() - 1ULL)) { 1461b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FalseBB = RHSR.first->second; 1462b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1463b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FalseBB = new MachineBasicBlock(LLVMBB); 1464b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, FalseBB); 1465b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov WorkList.push_back(CaseRec(FalseBB,CR.LT,C,RHSR)); 1466b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1467b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1468b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a CaseBlock record representing a conditional branch to 1469b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the LHS node if the value being switched on SV is less than C. 1470b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Otherwise, branch to LHS. 1471b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SelectionDAGISel::CaseBlock CB(ISD::SETLT, SV, C, TrueBB, FalseBB, 1472b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CR.CaseBB); 1473b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1474b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (CR.CaseBB == CurMBB) 1475b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov visitSwitchCase(CB); 1476b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov else 1477b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SwitchCases.push_back(CB); 1478dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1479dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return true; 1480b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov} 1481b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 14823a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikovvoid SelectionDAGLowering::visitSwitch(SwitchInst &I) { 1483f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 1484f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1485f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1486c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1487d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *Default = FuncInfo.MBBMap[I.getDefaultDest()]; 1488d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1489f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 1490f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 1491f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (I.getNumOperands() == 2) { 1492f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 1493c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1494f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 1495d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (Default != NextBlock) 1496f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1497d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner DAG.getBasicBlock(Default))); 1498c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1499d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurMBB->addSuccessor(Default); 1500f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 1501f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1502f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1503f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 1504f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 1505f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 1506f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<Case> Cases; 1507c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1508f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 1; i < I.getNumSuccessors(); ++i) { 1509f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *SMBB = FuncInfo.MBBMap[I.getSuccessor(i)]; 1510f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cases.push_back(Case(I.getSuccessorValue(i), SMBB)); 1511f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1512f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::sort(Cases.begin(), Cases.end(), CaseCmp()); 1513f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1514f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 1515f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 1516f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 1517f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Value *SV = I.getOperand(0); 151837efe6764568a3829fee26aba532283131d1a104Nate Begeman 15193a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Push the initial CaseRec onto the worklist 1520b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector WorkList; 15213a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov WorkList.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 15223a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 15233a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov while (!WorkList.empty()) { 15243a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Grab a record representing a case range to process off the worklist 15253a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CaseRec CR = WorkList.back(); 15263a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov WorkList.pop_back(); 15273a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 15283a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // If the range has few cases (two or less) emit a series of specific 15293a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // tests. 1530dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if (handleSmallSwitchRange(CR, WorkList, SV, Default)) 1531dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov continue; 1532dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 15333a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // If the switch has more than 5 blocks, and at least 31.25% dense, and the 15343a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // target supports indirect branches, then emit a jump table rather than 15353a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // lowering the switch to a binary tree of conditional branches. 1536dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if (handleJTSwitchCase(CR, WorkList, SV, Default)) 1537dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov continue; 1538dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1539dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // Emit binary tree. We need to pick a pivot, and push left and right ranges 1540dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // onto the worklist. Leafs are handled via handleSmallSwitchRange() call. 1541dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov handleBTSplitSwitchCase(CR, WorkList, SV, Default); 1542f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1543f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1544f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 15453a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 1546b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 1547b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 154824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer const Type *Ty = I.getType(); 15499d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (isa<VectorType>(Ty)) { 155024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, ISD::VSUB); 155124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer } else if (Ty->isFloatingPoint()) { 155201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 155301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 155401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 155501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 155601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 155701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 155824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::FSUB); 15591628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer } else 156024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::SUB); 1561b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 1562b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 156324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencervoid SelectionDAGLowering::visitScalarBinary(User &I, unsigned OpCode) { 15641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 15651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 156624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer 156724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer setValue(&I, DAG.getNode(OpCode, Op1.getValueType(), Op1, Op2)); 15681628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer} 15691628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 157024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencervoid 157124d6da5fedcf39891f7d8c5b031c01324b3db545Reid SpencerSelectionDAGLowering::visitVectorBinary(User &I, unsigned OpCode) { 15729d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer assert(isa<VectorType>(I.getType())); 15739d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *Ty = cast<VectorType>(I.getType()); 157424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer SDOperand Typ = DAG.getValueType(TLI.getValueType(Ty->getElementType())); 157524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer 157624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer setValue(&I, DAG.getNode(OpCode, MVT::Vector, 157724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer getValue(I.getOperand(0)), 157824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer getValue(I.getOperand(1)), 157924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer DAG.getConstant(Ty->getNumElements(), MVT::i32), 158024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer Typ)); 158124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer} 15821628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 158324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencervoid SelectionDAGLowering::visitEitherBinary(User &I, unsigned ScalarOp, 158424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer unsigned VectorOp) { 15859d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (isa<VectorType>(I.getType())) 158624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, VectorOp); 158724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer else 158824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ScalarOp); 1589e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 15902c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1591e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 1592e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 1593e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 1594e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 1595832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer if (TLI.getShiftAmountTy() < Op2.getValueType()) 1596832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer Op2 = DAG.getNode(ISD::TRUNCATE, TLI.getShiftAmountTy(), Op2); 1597832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer else if (TLI.getShiftAmountTy() > Op2.getValueType()) 1598832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 1599e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 16001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 16011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 160345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencervoid SelectionDAGLowering::visitICmp(User &I) { 1604e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE; 1605e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *IC = dyn_cast<ICmpInst>(&I)) 1606e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = IC->getPredicate(); 1607e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else if (ConstantExpr *IC = dyn_cast<ConstantExpr>(&I)) 1608e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = ICmpInst::Predicate(IC->getPredicate()); 1609e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 1610e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 161145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer ISD::CondCode Opcode; 1612e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 161345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_EQ : Opcode = ISD::SETEQ; break; 161445fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_NE : Opcode = ISD::SETNE; break; 161545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_UGT : Opcode = ISD::SETUGT; break; 161645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_UGE : Opcode = ISD::SETUGE; break; 161745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_ULT : Opcode = ISD::SETULT; break; 161845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_ULE : Opcode = ISD::SETULE; break; 161945fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SGT : Opcode = ISD::SETGT; break; 162045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SGE : Opcode = ISD::SETGE; break; 162145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SLT : Opcode = ISD::SETLT; break; 162245fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SLE : Opcode = ISD::SETLE; break; 162345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer default: 162445fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer assert(!"Invalid ICmp predicate value"); 162545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer Opcode = ISD::SETEQ; 162645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer break; 162745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer } 162845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 162945fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer} 163045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer 163145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencervoid SelectionDAGLowering::visitFCmp(User &I) { 1632e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE; 1633e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FCmpInst *FC = dyn_cast<FCmpInst>(&I)) 1634e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = FC->getPredicate(); 1635e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else if (ConstantExpr *FC = dyn_cast<ConstantExpr>(&I)) 1636e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = FCmpInst::Predicate(FC->getPredicate()); 1637e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 1638e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 1639e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode Condition, FOC, FPC; 1640e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 1641e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: FOC = FPC = ISD::SETFALSE; break; 1642e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OEQ: FOC = ISD::SETEQ; FPC = ISD::SETOEQ; break; 1643e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGT: FOC = ISD::SETGT; FPC = ISD::SETOGT; break; 1644e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGE: FOC = ISD::SETGE; FPC = ISD::SETOGE; break; 1645e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLT: FOC = ISD::SETLT; FPC = ISD::SETOLT; break; 1646e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLE: FOC = ISD::SETLE; FPC = ISD::SETOLE; break; 1647e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ONE: FOC = ISD::SETNE; FPC = ISD::SETONE; break; 1648e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ORD: FOC = ISD::SETEQ; FPC = ISD::SETO; break; 1649e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNO: FOC = ISD::SETNE; FPC = ISD::SETUO; break; 1650e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UEQ: FOC = ISD::SETEQ; FPC = ISD::SETUEQ; break; 1651e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGT: FOC = ISD::SETGT; FPC = ISD::SETUGT; break; 1652e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGE: FOC = ISD::SETGE; FPC = ISD::SETUGE; break; 1653e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULT: FOC = ISD::SETLT; FPC = ISD::SETULT; break; 1654e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULE: FOC = ISD::SETLE; FPC = ISD::SETULE; break; 1655e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNE: FOC = ISD::SETNE; FPC = ISD::SETUNE; break; 1656e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: FOC = FPC = ISD::SETTRUE; break; 165745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer default: 165845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer assert(!"Invalid FCmp predicate value"); 1659e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer FOC = FPC = ISD::SETFALSE; 166045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer break; 166145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer } 1662e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FiniteOnlyFPMath()) 1663e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FOC; 1664e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else 1665e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FPC; 1666e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Condition)); 16671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 16701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 16711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 16721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 16739d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (!isa<VectorType>(I.getType())) { 1674b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 1675b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner TrueVal, FalseVal)); 1676b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } else { 1677b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::VSELECT, MVT::Vector, Cond, TrueVal, FalseVal, 1678b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-2), 1679b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-1))); 1680b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } 16811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16833da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 16843da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitTrunc(User &I) { 16853da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // TruncInst cannot be a no-op cast because sizeof(src) > sizeof(dest). 16863da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 16873da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 16883da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 16893da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16903da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 16913da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitZExt(User &I) { 16923da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // ZExt cannot be a no-op cast because sizeof(src) < sizeof(dest). 16933da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // ZExt also can't be a cast to bool for same reason. So, nothing much to do 16943da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 16953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 16963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 16973da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16983da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 16993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitSExt(User &I) { 17003da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // SExt cannot be a no-op cast because sizeof(src) < sizeof(dest). 17013da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // SExt also can't be a cast to bool for same reason. So, nothing much to do 17023da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17033da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17043da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 17053da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17063da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17073da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPTrunc(User &I) { 17083da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPTrunc is never a no-op cast, no need to check 17093da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17103da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17113da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N)); 17123da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17133da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17143da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPExt(User &I){ 17153da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPTrunc is never a no-op cast, no need to check 17163da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17173da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17183da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 17193da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17213da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPToUI(User &I) { 17223da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPToUI is never a no-op cast, no need to check 17233da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17243da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 17263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPToSI(User &I) { 17293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPToSI is never a no-op cast, no need to check 17303da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17313da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17323da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 17333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17343da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17353da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitUIToFP(User &I) { 17363da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // UIToFP is never a no-op cast, no need to check 17373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 17403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17413da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17423da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitSIToFP(User &I){ 17433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // UIToFP is never a no-op cast, no need to check 17443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 17473da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitPtrToInt(User &I) { 17503da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // What to do depends on the size of the integer and the size of the pointer. 17513da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // We can either truncate, zero extend, or no-op, accordingly. 17521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 1753e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 175428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17553da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand Result; 17563da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (MVT::getSizeInBits(DestVT) < MVT::getSizeInBits(SrcVT)) 17573da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Result = DAG.getNode(ISD::TRUNCATE, DestVT, N); 17583da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 17593da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Note: ZERO_EXTEND can handle cases where the sizes are equal too 17603da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Result = DAG.getNode(ISD::ZERO_EXTEND, DestVT, N); 17613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, Result); 17623da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17643da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitIntToPtr(User &I) { 17653da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // What to do depends on the size of the integer and the size of the pointer. 17663da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // We can either truncate, zero extend, or no-op, accordingly. 17673da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17683da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType SrcVT = N.getValueType(); 17693da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 17703da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (MVT::getSizeInBits(DestVT) < MVT::getSizeInBits(SrcVT)) 17713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 17723da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 17733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Note: ZERO_EXTEND can handle cases where the sizes are equal too 17743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 17753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17773da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitBitCast(User &I) { 17783da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 17793da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 1780e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner if (DestVT == MVT::Vector) { 17813da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // This is a cast to a vector from something else. 17823da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Get information about the output vector. 17839d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *DestTy = cast<VectorType>(I.getType()); 1784e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 1785e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N, 1786e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getConstant(DestTy->getNumElements(),MVT::i32), 1787e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getValueType(EltVT))); 17883da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return; 17893da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer } 17903da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType SrcVT = N.getValueType(); 17913da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (SrcVT == MVT::Vector) { 17923da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // This is a cast from a vctor to something else. 17933da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Get information about the input vector. 1794e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N)); 17953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return; 17961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 17973da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 17983da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // BitCast assures us that source and destination are the same size so this 17993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // is either a BIT_CONVERT or a no-op. 18003da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (DestVT != N.getValueType()) 18013da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::BIT_CONVERT, DestVT, N)); // convert types 18023da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 18033da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, N); // noop cast. 18041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 18051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 18062bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 1807c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1808c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 1809c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1810c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 1811c7029805ef35ce9805931067b841e6af11db382eChris Lattner 18122332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Num = *(InVec.Val->op_end()-2); 18132332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 18142332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner setValue(&I, DAG.getNode(ISD::VINSERT_VECTOR_ELT, MVT::Vector, 18152332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner InVec, InVal, InIdx, Num, Typ)); 1816c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 1817c7029805ef35ce9805931067b841e6af11db382eChris Lattner 18182bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 1819384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1820384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1821384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 1822384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 1823384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner setValue(&I, DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, 1824384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 1825384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 1826c7029805ef35ce9805931067b841e6af11db382eChris Lattner 18273e104b11168da4692b69cc6b236c1da22adff959Chris Lattnervoid SelectionDAGLowering::visitShuffleVector(User &I) { 18283e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V1 = getValue(I.getOperand(0)); 18293e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V2 = getValue(I.getOperand(1)); 18303e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Mask = getValue(I.getOperand(2)); 18313e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 18323e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Num = *(V1.Val->op_end()-2); 18333e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Typ = *(V2.Val->op_end()-1); 18343e104b11168da4692b69cc6b236c1da22adff959Chris Lattner setValue(&I, DAG.getNode(ISD::VVECTOR_SHUFFLE, MVT::Vector, 18353e104b11168da4692b69cc6b236c1da22adff959Chris Lattner V1, V2, Mask, Num, Typ)); 18363e104b11168da4692b69cc6b236c1da22adff959Chris Lattner} 18373e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 18383e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 18391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 18401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 18411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 18421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 18431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 18441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 18451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 1846c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 1847b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 18481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 18491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 1850b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner uint64_t Offset = TD->getStructLayout(StTy)->getElementOffset(Field); 18511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 1852dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 18531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 18541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 18551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 18561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 18577c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 18587c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 18597c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 1860b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 186147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer uint64_t Offs = 18620d630d220414b02fed6873555bb46795a682174bEvan Cheng TD->getTypeSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 18637c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 18647c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 18657c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 18667c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 18677c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 1868a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 18697c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 18707c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 18717c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 18727c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 18737c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 187447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 18757c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 18767c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 18777c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 18787c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 18797c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 18807c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 18817c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 18827c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 18836b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 18841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 18857c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 18861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 18877c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 18887c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 18897c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 18907c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 18911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 18921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 18931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 18941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 18951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 18961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 18971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 18981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 18991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 19001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 19011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 1903a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 190458092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner unsigned Align = 1905d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner std::max((unsigned)TLI.getTargetData()->getPrefTypeAlignment(Ty), 190658092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner I.getAlignment()); 19071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 190968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 191068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 191168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 191268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 191368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 19141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 191568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 19161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 19171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 19191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 19201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 19211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 19221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 19231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 19241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 19251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 19261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 19271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 19281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 19291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 19301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 19311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 19321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 19331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1934bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[] = { getRoot(), AllocSize, getIntPtrConstant(Align) }; 1935f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTs = DAG.getNodeValueTypes(AllocSize.getValueType(), 1936f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner MVT::Other); 1937f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, 2, Ops, 3); 19380da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner setValue(&I, DSA); 19390da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner DAG.setRoot(DSA.getValue(1)); 19401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 19421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 19431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 19441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 19451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 19471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 1948edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1949d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 1950d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 1951d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 1952d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 1953d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 1954d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 1955d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 195628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 1957466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng setValue(&I, getLoadFrom(I.getType(), Ptr, I.getOperand(0), 195828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner Root, I.isVolatile())); 195928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 196028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 196128b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 1962466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 196328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile) { 19645fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 19659d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) { 19664ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 1967466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng L = DAG.getVecLoad(PTy->getNumElements(), PVT, Root, Ptr, 1968466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng DAG.getSrcValue(SV)); 19695fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 19700b4f80ee898c1e85242482e4cb363e6bfe0a133bEvan Cheng L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SV, 0, isVolatile); 19715fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1972d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 197328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 1974d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 1975d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 1976d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 197728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 197828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 19791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 19801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 19831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 19841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 19851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 19860b4f80ee898c1e85242482e4cb363e6bfe0a133bEvan Cheng DAG.setRoot(DAG.getStore(getRoot(), Src, Ptr, I.getOperand(1), 0, 19878b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.isVolatile())); 19881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 19891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 19900eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// IntrinsicCannotAccessMemory - Return true if the specified intrinsic cannot 19910eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// access memory and has no other side effects at all. 19920eade319cdb72e24c11d068728a98083737c6435Chris Lattnerstatic bool IntrinsicCannotAccessMemory(unsigned IntrinsicID) { 19930eade319cdb72e24c11d068728a98083737c6435Chris Lattner#define GET_NO_MEMORY_INTRINSICS 19940eade319cdb72e24c11d068728a98083737c6435Chris Lattner#include "llvm/Intrinsics.gen" 19950eade319cdb72e24c11d068728a98083737c6435Chris Lattner#undef GET_NO_MEMORY_INTRINSICS 19960eade319cdb72e24c11d068728a98083737c6435Chris Lattner return false; 19970eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 19980eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1999e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// IntrinsicOnlyReadsMemory - Return true if the specified intrinsic doesn't 2000e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// have any side-effects or if it only reads memory. 2001e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattnerstatic bool IntrinsicOnlyReadsMemory(unsigned IntrinsicID) { 2002e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#define GET_SIDE_EFFECT_INFO 2003e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#include "llvm/Intrinsics.gen" 2004e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#undef GET_SIDE_EFFECT_INFO 2005e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner return false; 2006e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner} 2007e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner 20080eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 20090eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 20100eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 20110eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 20127255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner bool HasChain = !IntrinsicCannotAccessMemory(Intrinsic); 2013e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner bool OnlyLoad = HasChain && IntrinsicOnlyReadsMemory(Intrinsic); 20140eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20150eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 2016bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 2017e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { // If this intrinsic has side-effects, chainify it. 2018e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) { 2019e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner // We don't need to serialize loads against other loads. 2020e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(DAG.getRoot()); 2021e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } else { 2022e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(getRoot()); 2023e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 2024e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 20250eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20260eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 20270eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 20280eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20290eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 20300eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 20310eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 20320eade319cdb72e24c11d068728a98083737c6435Chris Lattner 2033ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // If this is a vector type, force it to the right vector type. 20340eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (Op.getValueType() == MVT::Vector) { 20359d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *OpTy = cast<VectorType>(I.getOperand(i)->getType()); 20360eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType()); 20370eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20380eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VVT = MVT::getVectorType(EltVT, OpTy->getNumElements()); 20390eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VVT != MVT::Other && "Intrinsic uses a non-legal type?"); 20400eade319cdb72e24c11d068728a98083737c6435Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, VVT, Op); 20410eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 20420eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20430eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 20440eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 20450eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 20460eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 20470eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20480eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 20490eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 20500eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 20510eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (VT == MVT::Vector) { 20529d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *DestTy = cast<VectorType>(I.getType()); 20530eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 20540eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20550eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 20560eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 20570eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 20580eade319cdb72e24c11d068728a98083737c6435Chris Lattner 20590eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 20600eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 20610eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 20620eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 20630eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 20640eade319cdb72e24c11d068728a98083737c6435Chris Lattner 2065f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTList = DAG.getNodeValueTypes(VTs); 2066f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner 20670eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 206848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 206948b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 2070f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTList, VTs.size(), 2071f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 207248b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 2073f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTList, VTs.size(), 2074f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 207548b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 2076f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTList, VTs.size(), 2077f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 207848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 2079e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { 2080e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner SDOperand Chain = Result.getValue(Result.Val->getNumValues()-1); 2081e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) 2082e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner PendingLoads.push_back(Chain); 2083e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner else 2084e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner DAG.setRoot(Chain); 2085e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 20860eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 20879d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (const VectorType *PTy = dyn_cast<VectorType>(I.getType())) { 20880eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EVT = TLI.getValueType(PTy->getElementType()); 20890eade319cdb72e24c11d068728a98083737c6435Chris Lattner Result = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Result, 20900eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getConstant(PTy->getNumElements(), MVT::i32), 20910eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getValueType(EVT)); 20920eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 20930eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 20940eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 20950eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 20960eade319cdb72e24c11d068728a98083737c6435Chris Lattner 2097c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 2098c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 2099c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 2100c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 2101c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 2102c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 21030eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 21040eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 21050eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 21060eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 2107c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 2108c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 2109c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 2110bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case Intrinsic::returnaddress: 2111bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman setValue(&I, DAG.getNode(ISD::RETURNADDR, TLI.getPointerTy(), 2112bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman getValue(I.getOperand(1)))); 2113bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman return 0; 2114bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case Intrinsic::frameaddress: 2115bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman setValue(&I, DAG.getNode(ISD::FRAMEADDR, TLI.getPointerTy(), 2116bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman getValue(I.getOperand(1)))); 2117bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman return 0; 2118c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 2119d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov return "_setjmp"+!TLI.usesUnderscoreSetJmp(); 2120c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 2121c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 2122d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov return "_longjmp"+!TLI.usesUnderscoreLongJmp(); 2123c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 212403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 212503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 212603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 212703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 212803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 212903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 213003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 213103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 213203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 213303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 213403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 213503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 2136c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 213786cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 213844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 213943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 214044c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && SPI.getContext() && MMI->Verify(SPI.getContext())) { 2141bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[5]; 214236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 2143bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[0] = getRoot(); 2144bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[1] = getValue(SPI.getLineValue()); 2145bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[2] = getValue(SPI.getColumnValue()); 2146ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 214744c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey DebugInfoDesc *DD = MMI->getDescFor(SPI.getContext()); 2148ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 214943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 215043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2151bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[3] = DAG.getString(CompileUnit->getFileName()); 2152bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[4] = DAG.getString(CompileUnit->getDirectory()); 2153ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 2154bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops, 5)); 215586cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 215643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2157b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 215836ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 215943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 216044c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 216143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 216244c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && RSI.getContext() && MMI->Verify(RSI.getContext())) { 216344c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionStart(RSI.getContext()); 21641ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 2165bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.getConstant(LabelID, MVT::i32))); 216643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 216743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2168b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 216943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 217043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 217144c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 217243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 217344c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && REI.getContext() && MMI->Verify(REI.getContext())) { 217444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionEnd(REI.getContext()); 21751ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, 2176bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 217743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 217843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2179b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 218043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 218143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 218244c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 218343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 218444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && FSI.getSubprogram() && 218544c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MMI->Verify(FSI.getSubprogram())) { 218644c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionStart(FSI.getSubprogram()); 21871ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, 2188bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 218943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 219043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2191b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 219243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 219343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 219444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 219543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 219644c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && DI.getVariable() && MMI->Verify(DI.getVariable())) { 21970892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey SDOperand AddressOp = getValue(DI.getAddress()); 2198bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(AddressOp)) 219944c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MMI->RecordVariable(DI.getVariable(), FI->getIndex()); 220043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 220143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 220243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 220343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 2204c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 2205b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey case Intrinsic::eh_exception: { 2206b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 2207b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2208735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (MMI) { 2209735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Add a label to mark the beginning of the landing pad. Deletion of the 2210735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // landing pad can thus be detected via the MachineModuleInfo. 2211735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey unsigned LabelID = MMI->addLandingPad(CurMBB); 2212735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, DAG.getEntryNode(), 2213735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.getConstant(LabelID, MVT::i32))); 2214735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2215735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Mark exception register as live in. 2216735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey unsigned Reg = TLI.getExceptionAddressRegister(); 2217735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (Reg) CurMBB->addLiveIn(Reg); 2218735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2219735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Insert the EXCEPTIONADDR instruction. 2220735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDVTList VTs = DAG.getVTList(TLI.getPointerTy(), MVT::Other); 2221735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Ops[1]; 2222735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Ops[0] = DAG.getRoot(); 2223735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Op = DAG.getNode(ISD::EXCEPTIONADDR, VTs, Ops, 1); 2224735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey setValue(&I, Op); 2225735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(Op.getValue(1)); 22267a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey } else { 222764ce0ca90d358da4984a089404dc2dabe45d05f1Jim Laskey setValue(&I, DAG.getConstant(0, TLI.getPointerTy())); 2228735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey } 2229b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey return 0; 2230b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2231b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 22320b4711bd94e0723735848ad999bccfb1fb61eeb9Jim Laskey case Intrinsic::eh_selector: 22330b4711bd94e0723735848ad999bccfb1fb61eeb9Jim Laskey case Intrinsic::eh_filter:{ 2234b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 2235b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2236735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (MMI) { 2237735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Inform the MachineModuleInfo of the personality for this landing pad. 2238cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(2)); 2239cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey assert(CE && CE->getOpcode() == Instruction::BitCast && 2240cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey isa<Function>(CE->getOperand(0)) && 2241cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey "Personality should be a function"); 2242cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey MMI->addPersonality(CurMBB, cast<Function>(CE->getOperand(0))); 22430b4711bd94e0723735848ad999bccfb1fb61eeb9Jim Laskey if (Intrinsic == Intrinsic::eh_filter) 22440b4711bd94e0723735848ad999bccfb1fb61eeb9Jim Laskey MMI->setIsFilterLandingPad(CurMBB); 2245b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2246735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Gather all the type infos for this landing pad and pass them along to 2247735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // MachineModuleInfo. 2248735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey std::vector<GlobalVariable *> TyInfo; 2249735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey for (unsigned i = 3, N = I.getNumOperands(); i < N; ++i) { 2250cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i)); 2251cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey if (CE && CE->getOpcode() == Instruction::BitCast && 2252cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey isa<GlobalVariable>(CE->getOperand(0))) { 2253cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey TyInfo.push_back(cast<GlobalVariable>(CE->getOperand(0))); 2254cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey } else { 2255cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand(i)); 2256cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey assert(CI && CI->getZExtValue() == 0 && 2257cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey "TypeInfo must be a global variable typeinfo or NULL"); 2258cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey TyInfo.push_back(NULL); 2259735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey } 2260735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey } 2261735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey MMI->addCatchTypeInfo(CurMBB, TyInfo); 2262735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2263735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Mark exception selector register as live in. 2264735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey unsigned Reg = TLI.getExceptionSelectorRegister(); 2265735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (Reg) CurMBB->addLiveIn(Reg); 2266735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2267735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Insert the EHSELECTION instruction. 226864ce0ca90d358da4984a089404dc2dabe45d05f1Jim Laskey SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other); 2269735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Ops[2]; 2270735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Ops[0] = getValue(I.getOperand(1)); 2271735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Ops[1] = getRoot(); 2272735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Op = DAG.getNode(ISD::EHSELECTION, VTs, Ops, 2); 2273735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey setValue(&I, Op); 2274735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(Op.getValue(1)); 22757a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey } else { 227664ce0ca90d358da4984a089404dc2dabe45d05f1Jim Laskey setValue(&I, DAG.getConstant(0, MVT::i32)); 2277b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2278b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2279b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey return 0; 2280b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2281b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2282b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey case Intrinsic::eh_typeid_for: { 2283b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 2284735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2285735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (MMI) { 2286735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Find the type id for the given typeinfo. 2287735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey GlobalVariable *GV = NULL; 2288cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(1)); 2289cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey if (CE && CE->getOpcode() == Instruction::BitCast && 2290cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey isa<GlobalVariable>(CE->getOperand(0))) { 2291cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey GV = cast<GlobalVariable>(CE->getOperand(0)); 2292cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey } else { 2293cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand(1)); 2294cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey assert(CI && CI->getZExtValue() == 0 && 2295cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey "TypeInfo must be a global variable typeinfo or NULL"); 2296cbfdb7b871ddb383c9b323d4b9fba112ad500214Jim Laskey GV = NULL; 2297b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2298735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2299735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey unsigned TypeID = MMI->getTypeIDFor(GV); 2300735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey setValue(&I, DAG.getConstant(TypeID, MVT::i32)); 23017a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey } else { 23027a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey setValue(&I, DAG.getConstant(0, MVT::i32)); 2303b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2304b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2305b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey return 0; 2306b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2307b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 23080b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 23090b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 2310c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 2311c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2312c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2313c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 23146ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f32: 23156ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f64: 23166ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner setValue(&I, DAG.getNode(ISD::FPOWI, 23176ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)).getValueType(), 23186ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)), 23196ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(2)))); 23206ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner return 0; 2321c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 2322c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2323c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 2324c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2325c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 23268b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 2327bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 2328f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, 2329f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::i64, MVT::Other), 2, 2330f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Op, 1); 23318b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 23328b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 233351b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 23348b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 2335d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 2336d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 2337d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 2338d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 2339d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 2340d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 2341d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 23420b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 23430b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 23440b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 23450b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 2346c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 2347c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2348c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2349c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 23500b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 23510b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 23520b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 23530b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 2354c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 2355c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2356c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2357c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 23580b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 23590b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 23600b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 23610b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 2362c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 2363c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2364c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2365c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2366140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 2367bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 2368f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, 2369f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(TLI.getPointerTy(), MVT::Other), 2, &Op, 1); 2370140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 2371140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 2372140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 2373140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 237439a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 237539a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 237639a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 2377140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 237839a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 2379ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 2380ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 2381ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 2382c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 2383c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 2384c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 2385c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 23861da20a71d1bbabc472f281208be77475550be751Jim Laskeyvoid SelectionDAGLowering::LowerCallTo(Instruction &I, 23871da20a71d1bbabc472f281208be77475550be751Jim Laskey const Type *CalledValueTy, 23881da20a71d1bbabc472f281208be77475550be751Jim Laskey unsigned CallingConv, 23891da20a71d1bbabc472f281208be77475550be751Jim Laskey bool IsTailCall, 2390735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Callee, unsigned OpIdx) { 23911da20a71d1bbabc472f281208be77475550be751Jim Laskey const PointerType *PT = cast<PointerType>(CalledValueTy); 2392735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 2393735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2394735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey TargetLowering::ArgListTy Args; 2395735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey TargetLowering::ArgListEntry Entry; 2396735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Args.reserve(I.getNumOperands()); 2397735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey for (unsigned i = OpIdx, e = I.getNumOperands(); i != e; ++i) { 2398735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Value *Arg = I.getOperand(i); 2399735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand ArgNode = getValue(Arg); 2400735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Entry.Node = ArgNode; Entry.Ty = Arg->getType(); 2401d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Entry.isSExt = FTy->paramHasAttr(i, FunctionType::SExtAttribute); 2402d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Entry.isZExt = FTy->paramHasAttr(i, FunctionType::ZExtAttribute); 2403735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Entry.isInReg = FTy->paramHasAttr(i, FunctionType::InRegAttribute); 2404735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Entry.isSRet = FTy->paramHasAttr(i, FunctionType::StructRetAttribute); 2405735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Args.push_back(Entry); 2406735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey } 2407735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2408735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey std::pair<SDOperand,SDOperand> Result = 2409735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey TLI.LowerCallTo(getRoot(), I.getType(), 2410735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey FTy->paramHasAttr(0,FunctionType::SExtAttribute), 24111da20a71d1bbabc472f281208be77475550be751Jim Laskey FTy->isVarArg(), CallingConv, IsTailCall, 2412735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Callee, Args, DAG); 2413735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (I.getType() != Type::VoidTy) 2414735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey setValue(&I, Result.first); 2415735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(Result.second); 2416735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey} 2417735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2418735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 24191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 242064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 2421c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 24225cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (F->isDeclaration()) 2423c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 2424c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 2425c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 2426c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 2427c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 2428c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 2429a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (Name[0] == 'c' && (Name == "copysign" || Name == "copysignf")) { 2430a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 2431a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 2432a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(1)->getType() && 2433a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(2)->getType()) { 2434a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand LHS = getValue(I.getOperand(1)); 2435a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand RHS = getValue(I.getOperand(2)); 2436a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 2437a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner LHS, RHS)); 2438a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner return; 2439a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 2440a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } else if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 2441c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 2442c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 2443c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 2444c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2445c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 2446c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 2447c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 2448c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 2449f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 2450f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 245106a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 2452c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2453f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 2454f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 2455f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2456c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 2457f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 2458f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 245906a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 2460c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2461f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 2462f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 2463f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2464f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2465c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 2466ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 2467ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner visitInlineAsm(I); 2468ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 2469c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 2470edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 247164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 247264e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 247364e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 247464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 247564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 2476735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 24771da20a71d1bbabc472f281208be77475550be751Jim Laskey LowerCallTo(I, I.getCalledValue()->getType(), 24781da20a71d1bbabc472f281208be77475550be751Jim Laskey I.getCallingConv(), 24791da20a71d1bbabc472f281208be77475550be751Jim Laskey I.isTailCall(), 24801da20a71d1bbabc472f281208be77475550be751Jim Laskey Callee, 24811da20a71d1bbabc472f281208be77475550be751Jim Laskey 1); 24821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 24831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2484735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2485864635ad7b3046d3042311423071152c613961deChris LattnerSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 24869f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag)const{ 2487864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Val = DAG.getCopyFromReg(Chain, Regs[0], RegVT, Flag); 2488864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 2489864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 2490864635ad7b3046d3042311423071152c613961deChris Lattner 2491864635ad7b3046d3042311423071152c613961deChris Lattner // If the result was expanded, copy from the top part. 2492864635ad7b3046d3042311423071152c613961deChris Lattner if (Regs.size() > 1) { 2493864635ad7b3046d3042311423071152c613961deChris Lattner assert(Regs.size() == 2 && 2494864635ad7b3046d3042311423071152c613961deChris Lattner "Cannot expand to more than 2 elts yet!"); 2495864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Hi = DAG.getCopyFromReg(Chain, Regs[1], RegVT, Flag); 2496693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Chain = Hi.getValue(1); 2497693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Flag = Hi.getValue(2); 24989f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (DAG.getTargetLoweringInfo().isLittleEndian()) 24999f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Val, Hi); 25009f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner else 25019f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Hi, Val); 2502864635ad7b3046d3042311423071152c613961deChris Lattner } 2503864635ad7b3046d3042311423071152c613961deChris Lattner 2504cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Otherwise, if the return value was promoted or extended, truncate it to the 2505864635ad7b3046d3042311423071152c613961deChris Lattner // appropriate type. 2506864635ad7b3046d3042311423071152c613961deChris Lattner if (RegVT == ValueVT) 2507864635ad7b3046d3042311423071152c613961deChris Lattner return Val; 2508864635ad7b3046d3042311423071152c613961deChris Lattner 25095df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner if (MVT::isVector(RegVT)) { 25105df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner assert(ValueVT == MVT::Vector && "Unknown vector conversion!"); 25115df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner return DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Val, 25125df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner DAG.getConstant(MVT::getVectorNumElements(RegVT), 25135df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner MVT::i32), 25145df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner DAG.getValueType(MVT::getVectorBaseType(RegVT))); 25155df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner } 25165df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner 2517cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (MVT::isInteger(RegVT)) { 2518cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (ValueVT < RegVT) 2519cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 2520cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner else 2521cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::ANY_EXTEND, ValueVT, Val); 2522cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } 25235df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner 25245df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner assert(MVT::isFloatingPoint(RegVT) && MVT::isFloatingPoint(ValueVT)); 25255df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner return DAG.getNode(ISD::FP_ROUND, ValueVT, Val); 2526864635ad7b3046d3042311423071152c613961deChris Lattner} 2527864635ad7b3046d3042311423071152c613961deChris Lattner 2528c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 2529c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// specified value into the registers specified by this object. This uses 2530c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// Chain/Flag as the input and updates them for the output Chain/Flag. 2531c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 2532a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 2533a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const { 2534c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (Regs.size() == 1) { 2535c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // If there is a single register and the types differ, this must be 2536c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // a promotion. 2537c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (RegVT != ValueVT) { 25385df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner if (MVT::isVector(RegVT)) { 25395df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner assert(Val.getValueType() == MVT::Vector &&"Not a vector-vector cast?"); 25405df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner Val = DAG.getNode(ISD::VBIT_CONVERT, RegVT, Val); 25415df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner } else if (MVT::isInteger(RegVT)) { 25420c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (RegVT < ValueVT) 25430c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::TRUNCATE, RegVT, Val); 25440c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner else 25450c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::ANY_EXTEND, RegVT, Val); 25460c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner } else 2547c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::FP_EXTEND, RegVT, Val); 2548c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2549c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Chain = DAG.getCopyToReg(Chain, Regs[0], Val, Flag); 2550c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 2551c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } else { 25529f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<unsigned> R(Regs); 25539f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (!DAG.getTargetLoweringInfo().isLittleEndian()) 25549f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::reverse(R.begin(), R.end()); 25559f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner 25569f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner for (unsigned i = 0, e = R.size(); i != e; ++i) { 2557c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner SDOperand Part = DAG.getNode(ISD::EXTRACT_ELEMENT, RegVT, Val, 2558a844126c43976387a66dafbe5137a762169f1f34Evan Cheng DAG.getConstant(i, PtrVT)); 25599f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner Chain = DAG.getCopyToReg(Chain, R[i], Part, Flag); 2560c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 2561c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2562c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2563c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 2564864635ad7b3046d3042311423071152c613961deChris Lattner 2565c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 2566c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 2567c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 2568c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 25699f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 2570c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getConstant(Code | (Regs.size() << 3), MVT::i32)); 2571c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 2572c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 2573c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 2574864635ad7b3046d3042311423071152c613961deChris Lattner 2575864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 2576864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 2577864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 2578864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 25799b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 25809b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetLowering &TLI, const MRegisterInfo *MRI) { 2581f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType FoundVT = MVT::Other; 2582f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner const TargetRegisterClass *FoundRC = 0; 25839b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (MRegisterInfo::regclass_iterator RCI = MRI->regclass_begin(), 25849b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = MRI->regclass_end(); RCI != E; ++RCI) { 2585f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType ThisVT = MVT::Other; 2586f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner 25879b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 25889b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 25899b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 25909b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 25919b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 25929b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 2593f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // If we have already found this register in a different register class, 2594f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // choose the one with the largest VT specified. For example, on 2595f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // PowerPC, we favor f64 register classes over f32. 2596f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (FoundVT == MVT::Other || 2597f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::getSizeInBits(FoundVT) < MVT::getSizeInBits(*I)) { 2598f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner ThisVT = *I; 2599f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 2600f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 26019b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 26029b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 26039b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 2604f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (ThisVT == MVT::Other) continue; 26059b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 2606864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 2607864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 2608864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 2609864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 26109b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 26119b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 2612f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (*I == Reg) { 2613f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // We found a matching register class. Keep looking at others in case 2614f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // we find one with larger registers that this physreg is also in. 2615f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundRC = RC; 2616f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundVT = ThisVT; 2617f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 2618f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 2619864635ad7b3046d3042311423071152c613961deChris Lattner } 2620f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner return FoundRC; 2621864635ad7b3046d3042311423071152c613961deChris Lattner} 2622864635ad7b3046d3042311423071152c613961deChris Lattner 2623864635ad7b3046d3042311423071152c613961deChris LattnerRegsForValue SelectionDAGLowering:: 2624864635ad7b3046d3042311423071152c613961deChris LattnerGetRegistersForValue(const std::string &ConstrCode, 2625864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, bool isOutReg, bool isInReg, 2626864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 26274e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 2628864635ad7b3046d3042311423071152c613961deChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 2629864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegForInlineAsmConstraint(ConstrCode, VT); 2630864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 2631864635ad7b3046d3042311423071152c613961deChris Lattner 2632864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumRegs = VT != MVT::Other ? TLI.getNumElements(VT) : 1; 2633864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 2634864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT = VT; 2635864635ad7b3046d3042311423071152c613961deChris Lattner 26362a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // If this is a constraint for a specific physical register, like {r17}, 26372a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // assign it now. 2638864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 2639864635ad7b3046d3042311423071152c613961deChris Lattner if (VT == MVT::Other) 2640864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 2641cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner 2642cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Get the actual register value type. This is important, because the user 2643cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // may have asked for (e.g.) the AX register in i32 type. We need to 2644cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // remember that AX is actually i16 to get the right extension. 2645cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner RegVT = *PhysReg.second->vt_begin(); 2646864635ad7b3046d3042311423071152c613961deChris Lattner 2647864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 2648864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 2649864635ad7b3046d3042311423071152c613961deChris Lattner 2650864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 2651864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 2652864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 2653864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 2654864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 2655864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 2656864635ad7b3046d3042311423071152c613961deChris Lattner 2657864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 2658864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 2659864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 2660864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 2661864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 2662864635ad7b3046d3042311423071152c613961deChris Lattner } 2663864635ad7b3046d3042311423071152c613961deChris Lattner } 2664864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 2665864635ad7b3046d3042311423071152c613961deChris Lattner } 2666864635ad7b3046d3042311423071152c613961deChris Lattner 26672a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Otherwise, if this was a reference to an LLVM register class, create vregs 26682a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // for this reference. 26692a821601f1db665fbb825727aacf1a54d17b91efChris Lattner std::vector<unsigned> RegClassRegs; 26702a821601f1db665fbb825727aacf1a54d17b91efChris Lattner if (PhysReg.second) { 26712a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // If this is an early clobber or tied register, our regalloc doesn't know 26722a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // how to maintain the constraint. If it isn't, go ahead and create vreg 26732a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // and let the regalloc do the right thing. 26742a821601f1db665fbb825727aacf1a54d17b91efChris Lattner if (!isOutReg || !isInReg) { 26752a821601f1db665fbb825727aacf1a54d17b91efChris Lattner if (VT == MVT::Other) 26762a821601f1db665fbb825727aacf1a54d17b91efChris Lattner ValueVT = *PhysReg.second->vt_begin(); 26772a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegVT = *PhysReg.second->vt_begin(); 26782a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 26792a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Create the appropriate number of virtual registers. 26802a821601f1db665fbb825727aacf1a54d17b91efChris Lattner SSARegMap *RegMap = DAG.getMachineFunction().getSSARegMap(); 26812a821601f1db665fbb825727aacf1a54d17b91efChris Lattner for (; NumRegs; --NumRegs) 26822a821601f1db665fbb825727aacf1a54d17b91efChris Lattner Regs.push_back(RegMap->createVirtualRegister(PhysReg.second)); 26832a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 26842a821601f1db665fbb825727aacf1a54d17b91efChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 26852a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } 26862a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 26872a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Otherwise, we can't allocate it. Let the code below figure out how to 26882a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // maintain these constraints. 26892a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegClassRegs.assign(PhysReg.second->begin(), PhysReg.second->end()); 26902a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 26912a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } else { 26922a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // This is a reference to a register class that doesn't directly correspond 26932a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // to an LLVM register class. Allocate NumRegs consecutive, available, 26942a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // registers from the class. 26952a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegClassRegs = TLI.getRegClassForInlineAsmConstraint(ConstrCode, VT); 26962a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } 2697864635ad7b3046d3042311423071152c613961deChris Lattner 26984e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner const MRegisterInfo *MRI = DAG.getTarget().getRegisterInfo(); 26994e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner MachineFunction &MF = *CurMBB->getParent(); 2700864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 2701864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 2702864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 27034e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 2704864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 2705864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 2706864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 2707864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 2708864635ad7b3046d3042311423071152c613961deChris Lattner continue; 2709864635ad7b3046d3042311423071152c613961deChris Lattner } 2710864635ad7b3046d3042311423071152c613961deChris Lattner 27114e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 27124e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 27139b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, MRI); 2714864635ad7b3046d3042311423071152c613961deChris Lattner if (!RC) { 2715864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 2716864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 2717864635ad7b3046d3042311423071152c613961deChris Lattner continue; 27184e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 27194e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 2720864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 2721864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 2722864635ad7b3046d3042311423071152c613961deChris Lattner 2723864635ad7b3046d3042311423071152c613961deChris Lattner // If we allocated enough consecutive 2724864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 2725864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 2726864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 2727864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 2728864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) { 2729864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 2730864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 2731864635ad7b3046d3042311423071152c613961deChris Lattner if (isOutReg) OutputRegs.insert(Reg); // Mark reg used. 2732864635ad7b3046d3042311423071152c613961deChris Lattner if (isInReg) InputRegs.insert(Reg); // Mark reg used. 2733864635ad7b3046d3042311423071152c613961deChris Lattner } 2734864635ad7b3046d3042311423071152c613961deChris Lattner 2735864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, *RC->vt_begin(), VT); 2736864635ad7b3046d3042311423071152c613961deChris Lattner } 27374e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 2738864635ad7b3046d3042311423071152c613961deChris Lattner 2739864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 2740864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(); 27414e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 27424e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 2743367f109ba954239a348c624a3331422bfdb31d03Chris Lattner/// getConstraintGenerality - Return an integer indicating how general CT is. 2744367f109ba954239a348c624a3331422bfdb31d03Chris Lattnerstatic unsigned getConstraintGenerality(TargetLowering::ConstraintType CT) { 2745367f109ba954239a348c624a3331422bfdb31d03Chris Lattner switch (CT) { 2746367f109ba954239a348c624a3331422bfdb31d03Chris Lattner default: assert(0 && "Unknown constraint type!"); 2747367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Other: 2748367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Unknown: 2749367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 0; 2750367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Register: 2751367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 1; 2752367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_RegisterClass: 2753367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 2; 2754367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Memory: 2755367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 3; 2756367f109ba954239a348c624a3331422bfdb31d03Chris Lattner } 2757367f109ba954239a348c624a3331422bfdb31d03Chris Lattner} 2758367f109ba954239a348c624a3331422bfdb31d03Chris Lattner 2759367f109ba954239a348c624a3331422bfdb31d03Chris Lattnerstatic std::string GetMostGeneralConstraint(std::vector<std::string> &C, 2760367f109ba954239a348c624a3331422bfdb31d03Chris Lattner const TargetLowering &TLI) { 2761367f109ba954239a348c624a3331422bfdb31d03Chris Lattner assert(!C.empty() && "Must have at least one constraint"); 2762367f109ba954239a348c624a3331422bfdb31d03Chris Lattner if (C.size() == 1) return C[0]; 2763367f109ba954239a348c624a3331422bfdb31d03Chris Lattner 2764367f109ba954239a348c624a3331422bfdb31d03Chris Lattner std::string *Current = &C[0]; 2765367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // If we have multiple constraints, try to pick the most general one ahead 2766367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // of time. This isn't a wonderful solution, but handles common cases. 27674234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner TargetLowering::ConstraintType Flavor = TLI.getConstraintType(Current[0]); 2768367f109ba954239a348c624a3331422bfdb31d03Chris Lattner for (unsigned j = 1, e = C.size(); j != e; ++j) { 27694234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner TargetLowering::ConstraintType ThisFlavor = TLI.getConstraintType(C[j]); 2770367f109ba954239a348c624a3331422bfdb31d03Chris Lattner if (getConstraintGenerality(ThisFlavor) > 2771367f109ba954239a348c624a3331422bfdb31d03Chris Lattner getConstraintGenerality(Flavor)) { 2772367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // This constraint letter is more general than the previous one, 2773367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // use it. 2774367f109ba954239a348c624a3331422bfdb31d03Chris Lattner Flavor = ThisFlavor; 2775367f109ba954239a348c624a3331422bfdb31d03Chris Lattner Current = &C[j]; 2776367f109ba954239a348c624a3331422bfdb31d03Chris Lattner } 2777367f109ba954239a348c624a3331422bfdb31d03Chris Lattner } 2778367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return *Current; 2779367f109ba954239a348c624a3331422bfdb31d03Chris Lattner} 2780367f109ba954239a348c624a3331422bfdb31d03Chris Lattner 2781864635ad7b3046d3042311423071152c613961deChris Lattner 2782ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 2783ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 2784ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattnervoid SelectionDAGLowering::visitInlineAsm(CallInst &I) { 2785ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner InlineAsm *IA = cast<InlineAsm>(I.getOperand(0)); 2786ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2787ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand AsmStr = DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), 2788ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner MVT::Other); 2789ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 27902cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); 27911efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner std::vector<MVT::ValueType> ConstraintVTs; 2792ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2793ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// AsmNodeOperands - A list of pairs. The first element is a register, the 2794ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// second is a bitfield where bit #0 is set if it is a use and bit #1 is set 2795ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// if it is a def of that register. 2796ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> AsmNodeOperands; 2797ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 2798ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(AsmStr); 2799ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2800ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 2801ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 2802ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 28034e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We fully assign registers here at isel time. This is not optimal, but 28044e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // should work. For register classes that correspond to LLVM classes, we 28054e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // could let the LLVM RA do its thing, but we currently don't. Do a prepass 28064e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // over the constraints, collecting fixed registers that we know we can't use. 28074e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 28081efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner unsigned OpNum = 1; 28094e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 2810367f109ba954239a348c624a3331422bfdb31d03Chris Lattner std::string ConstraintCode = 2811367f109ba954239a348c624a3331422bfdb31d03Chris Lattner GetMostGeneralConstraint(Constraints[i].Codes, TLI); 28122223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 28131efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner MVT::ValueType OpVT; 28141efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 28151efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Compute the value type for each operand and add it to ConstraintVTs. 28161efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner switch (Constraints[i].Type) { 28171efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 28181efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (!Constraints[i].isIndirectOutput) { 28191efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 28201efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getType()); 28211efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 282222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner const Type *OpTy = I.getOperand(OpNum)->getType(); 28231efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(cast<PointerType>(OpTy)->getElementType()); 28241efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 28251efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 28261efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 28271efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 28281efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getOperand(OpNum)->getType()); 28291efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 28301efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 28311efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 28321efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = MVT::Other; 28331efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 28341efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 28351efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 28361efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner ConstraintVTs.push_back(OpVT); 28371efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2838864635ad7b3046d3042311423071152c613961deChris Lattner if (TLI.getRegForInlineAsmConstraint(ConstraintCode, OpVT).first == 0) 2839864635ad7b3046d3042311423071152c613961deChris Lattner continue; // Not assigned a fixed reg. 28401efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2841864635ad7b3046d3042311423071152c613961deChris Lattner // Build a list of regs that this operand uses. This always has a single 2842864635ad7b3046d3042311423071152c613961deChris Lattner // element for promoted/expanded operands. 2843864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = GetRegistersForValue(ConstraintCode, OpVT, 2844864635ad7b3046d3042311423071152c613961deChris Lattner false, false, 2845864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 28464e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 28474e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner switch (Constraints[i].Type) { 28484e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isOutput: 28494e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We can't assign any other output to this register. 2850864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 28514e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // If this is an early-clobber output, it cannot be assigned to the same 28524e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // value as the input reg. 28532223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2854864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 28554e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 28561efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 28571efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // We can't assign any other input to this register. 2858864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 28591efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 28604e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isClobber: 28614e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Clobbered regs cannot be used as inputs or outputs. 2862864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 2863864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 28644e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 28654e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 28664e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 28672cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 28680f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 28690f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 2870864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 2871864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 28721efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum = 1; 28730f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 28746656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 2875367f109ba954239a348c624a3331422bfdb31d03Chris Lattner std::string ConstraintCode = 2876367f109ba954239a348c624a3331422bfdb31d03Chris Lattner GetMostGeneralConstraint(Constraints[i].Codes, TLI); 28771efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 28782cc2f66c25d9576743026688fdae5ed402726532Chris Lattner switch (Constraints[i].Type) { 28792cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 288022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 288122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 28824234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner CTy = TLI.getConstraintType(ConstraintCode); 288322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 288422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (CTy == TargetLowering::C_Memory) { 288522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Memory output. 288622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 288722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 288822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Check that the operand (the address to store to) isn't a float. 288922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 289022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 289122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 289222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!Constraints[i].isIndirectOutput) 289322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 289422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 289522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner OpNum++; // Consumes a call operand. 289622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 289722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Extend/truncate to the right pointer type if needed. 289822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 289922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (InOperandVal.getValueType() < PtrType) 290022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 290122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner else if (InOperandVal.getValueType() > PtrType) 290222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 290322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 290422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 290522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 290622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 290722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(InOperandVal); 290822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 290922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 291022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 291122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Otherwise, this is a register output. 291222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 291322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 2914864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an early-clobber output, or if there is an input 2915864635ad7b3046d3042311423071152c613961deChris Lattner // constraint that matches this, we need to reserve the input register 2916864635ad7b3046d3042311423071152c613961deChris Lattner // so no other inputs allocate to it. 2917864635ad7b3046d3042311423071152c613961deChris Lattner bool UsesInputRegister = false; 2918864635ad7b3046d3042311423071152c613961deChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2919864635ad7b3046d3042311423071152c613961deChris Lattner UsesInputRegister = true; 29202223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 2921864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 2922864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 2923864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = 2924864635ad7b3046d3042311423071152c613961deChris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 2925864635ad7b3046d3042311423071152c613961deChris Lattner true, UsesInputRegister, 2926864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 2927d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner if (Regs.Regs.empty()) { 2928832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Couldn't allocate output reg for contraint '" 2929832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << ConstraintCode << "'!\n"; 2930d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner exit(1); 2931d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner } 29322cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 29332cc2f66c25d9576743026688fdae5ed402726532Chris Lattner if (!Constraints[i].isIndirectOutput) { 2934864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 29352cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 29362cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 2937864635ad7b3046d3042311423071152c613961deChris Lattner RetValRegs = Regs; 29382cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 293922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner IndirectStoresToEmit.push_back(std::make_pair(Regs, 294022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner I.getOperand(OpNum))); 29412cc2f66c25d9576743026688fdae5ed402726532Chris Lattner OpNum++; // Consumes a call operand. 29422cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 29436656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 29446656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 29456656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 2946c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Regs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, AsmNodeOperands); 29476656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 29486656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 29496656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 295022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 29514e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner OpNum++; // Consumes a call operand. 29523d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 29532223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (isdigit(ConstraintCode[0])) { // Matching constraint? 29542223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 29552223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 29562223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner unsigned OperandNo = atoi(ConstraintCode.c_str()); 29573d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 2958c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 2959c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 2960c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 2961c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 2962c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 2963c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2964c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2965a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner assert(((NumOps & 7) == 2 /*REGDEF*/ || 2966a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner (NumOps & 7) == 4 /*MEM*/) && 2967c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2968c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 2969c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2970c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2971c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2972c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2973527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner if ((NumOps & 7) == 2 /*REGDEF*/) { 2974527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 2975527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner RegsForValue MatchedRegs; 2976527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 2977527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 2978527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 2979527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner unsigned Reg = 2980527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 2981527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.Regs.push_back(Reg); 2982527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner } 2983c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2984527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner // Use the produced MatchedRegs object to 2985527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, 2986527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner TLI.getPointerTy()); 2987527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 2988527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner break; 2989527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner } else { 2990527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner assert((NumOps & 7) == 4/*MEM*/ && "Unknown matching constraint!"); 2991527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner assert(0 && "matching constraints for memory operands unimp"); 2992c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 299387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 299487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 299587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 299687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 29974234f57fa02b1f04a9f52a7b3c2aa22d32ac521cChris Lattner CTy = TLI.getConstraintType(ConstraintCode); 29983d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 299987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (CTy == TargetLowering::C_Other) { 300053069fbbae2558a3138df24776448791fea3aceeChris Lattner InOperandVal = TLI.isOperandValidForConstraint(InOperandVal, 300153069fbbae2558a3138df24776448791fea3aceeChris Lattner ConstraintCode[0], DAG); 300253069fbbae2558a3138df24776448791fea3aceeChris Lattner if (!InOperandVal.Val) { 3003832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Invalid operand for inline asm constraint '" 3004832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << ConstraintCode << "'!\n"; 300553069fbbae2558a3138df24776448791fea3aceeChris Lattner exit(1); 300653069fbbae2558a3138df24776448791fea3aceeChris Lattner } 3007c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 300887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 300987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 3 /*IMM*/ | (1 << 3); 301087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 301187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 301287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 301387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } else if (CTy == TargetLowering::C_Memory) { 301487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Memory input. 301587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 30166dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner // If the operand is a float, spill to a constant pool entry to get its 30176dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner // address. 30186dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner if (ConstantFP *Val = dyn_cast<ConstantFP>(I.getOperand(OpNum-1))) 30196dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner InOperandVal = DAG.getConstantPool(Val, TLI.getPointerTy()); 30206dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner 3021b4ddac9bf7b9d4aa7267702f375647b370ad32f4Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) { 30226dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner cerr << "Match failed, cannot handle this yet!\n"; 30236dfc6806bf4091cc736312a3ceca6225f81ef63eChris Lattner InOperandVal.Val->dump(); 3024b4ddac9bf7b9d4aa7267702f375647b370ad32f4Chris Lattner exit(1); 3025b4ddac9bf7b9d4aa7267702f375647b370ad32f4Chris Lattner } 3026c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 302787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Extend/truncate to the right pointer type if needed. 302887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 302987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (InOperandVal.getValueType() < PtrType) 303087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 303187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner else if (InOperandVal.getValueType() > PtrType) 303287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 303387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 303487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 303587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 303687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 303787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 3038c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 30392223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 304087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 304187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 304287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 304387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 304487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner RegsForValue InRegs = 304587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 304687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner false, true, OutputRegs, InputRegs); 304787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // FIXME: should be match fail. 304887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(!InRegs.Regs.empty() && "Couldn't allocate input reg!"); 304987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 3050a844126c43976387a66dafbe5137a762169f1f34Evan Cheng InRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, TLI.getPointerTy()); 305187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 305287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, AsmNodeOperands); 30536656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 30546656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3055c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 3056c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue ClobberedRegs = 3057c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner GetRegistersForValue(ConstraintCode, MVT::Other, false, false, 3058c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner OutputRegs, InputRegs); 3059c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 3060c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 3061c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (!ClobberedRegs.Regs.empty()) 3062c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner ClobberedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, AsmNodeOperands); 30636656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 30646656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3065c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 30666656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3067ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3068ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 3069ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 3070ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 3071ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3072f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, 3073f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::Other, MVT::Flag), 2, 3074bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &AsmNodeOperands[0], AsmNodeOperands.size()); 3075ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 3076ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 30776656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 30786656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 3079864635ad7b3046d3042311423071152c613961deChris Lattner if (!RetValRegs.Regs.empty()) 3080864635ad7b3046d3042311423071152c613961deChris Lattner setValue(&I, RetValRegs.getCopyFromRegs(DAG, Chain, Flag)); 30816656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 30826656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 30836656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 30846656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 30856656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 30866656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 3087864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 30886656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 3089864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, Flag); 3090864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 30916656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3092ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 30936656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 3094bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 30956656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 3096786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng OutChains.push_back(DAG.getStore(Chain, StoresToEmit[i].first, 30976656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 30988b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoresToEmit[i].second, 0)); 30996656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 3100bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, 3101bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 3102ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 3103ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 3104ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3105ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 31061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 31071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 31081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 31091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 311068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 311168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 311268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 311368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 311468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 31151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 31161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 3117a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(I.getType()->getElementType()); 31181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 31191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 31201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 312147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 312247857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 312347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = Src; 312447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Ty = TLI.getTargetData()->getIntPtrType(); 312547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 3126cf5734dddd66af9388a171b44996505ede47feedChris Lattner 3127cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 312847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), I.getType(), false, false, CallingConv::C, true, 3129cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 3130cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 3131cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 3132cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 31331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 31351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 313647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 313747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 313847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = getValue(I.getOperand(0)); 313947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Ty = TLI.getTargetData()->getIntPtrType(); 314047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 31411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 3142cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 314347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), Type::VoidTy, false, false, CallingConv::C, true, 3144cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 3145cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 31461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3148025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 3149025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 3150025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 3151025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 3152025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 3153025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 3154025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 3155832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "If a target marks an instruction with " 3156832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << "'usesCustomDAGSchedInserter', it must implement " 3157832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << "TargetLowering::InsertAtEndOfBasicBlock!\n"; 3158025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 3159025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 3160025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 3161025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 316239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 3163acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 3164acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 3165acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 316639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 316739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 31681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 3169acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 3170acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 3171acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 3172acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 3173acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 31741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 31761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 3177acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 3178acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 3179acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 31801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 31821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 3183acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 3184acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 3185acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 3186acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 3187acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 31881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3190b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// ExpandScalarFormalArgs - Recursively expand the formal_argument node, either 3191b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// bit_convert it or join a pair of them with a BUILD_PAIR when appropriate. 3192b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Chengstatic SDOperand ExpandScalarFormalArgs(MVT::ValueType VT, SDNode *Arg, 3193b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng unsigned &i, SelectionDAG &DAG, 3194b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng TargetLowering &TLI) { 3195b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (TLI.getTypeAction(VT) != TargetLowering::Expand) 3196b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return SDOperand(Arg, i++); 3197b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 3198b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng MVT::ValueType EVT = TLI.getTypeToTransformTo(VT); 3199b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng unsigned NumVals = MVT::getSizeInBits(VT) / MVT::getSizeInBits(EVT); 3200b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (NumVals == 1) { 3201b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return DAG.getNode(ISD::BIT_CONVERT, VT, 3202b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng ExpandScalarFormalArgs(EVT, Arg, i, DAG, TLI)); 3203b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else if (NumVals == 2) { 3204b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Lo = ExpandScalarFormalArgs(EVT, Arg, i, DAG, TLI); 3205b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Hi = ExpandScalarFormalArgs(EVT, Arg, i, DAG, TLI); 3206b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (!TLI.isLittleEndian()) 3207b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng std::swap(Lo, Hi); 3208b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return DAG.getNode(ISD::BUILD_PAIR, VT, Lo, Hi); 3209b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else { 3210b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // Value scalarized into many values. Unimp for now. 3211b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng assert(0 && "Cannot expand i64 -> i16 yet!"); 3212b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } 3213b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return SDOperand(); 3214b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng} 3215b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 3216fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// TargetLowering::LowerArguments - This is the default LowerArguments 3217fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// implementation, which just inserts a FORMAL_ARGUMENTS node. FIXME: When all 3218f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// targets are migrated to using FORMAL_ARGUMENTS, this hook should be 3219f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// integrated into SDISel. 3220fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattnerstd::vector<SDOperand> 3221fdfded55888e35b76bb70231a5bb2f60877c2f6aChris LattnerTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { 3222b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov const FunctionType *FTy = F.getFunctionType(); 3223fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. 3224fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<SDOperand> Ops; 32258c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner Ops.push_back(DAG.getRoot()); 3226fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.getCallingConv(), getPointerTy())); 3227fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.isVarArg(), getPointerTy())); 3228fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 3229fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add one result value for each formal argument. 3230fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<MVT::ValueType> RetVals; 32316aa279dc8b5a05499b2cd158f8187d7225adc4f4Anton Korobeynikov unsigned j = 1; 3232ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); 3233ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov I != E; ++I, ++j) { 3234fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 3235d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov unsigned Flags = ISD::ParamFlags::NoFlagSet; 32367aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio unsigned OriginalAlignment = 3237d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner getTargetData()->getABITypeAlignment(I->getType()); 32387aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio 3239ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner // FIXME: Distinguish between a formal with no [sz]ext attribute from one 3240ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner // that is zero extended! 3241ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner if (FTy->paramHasAttr(j, FunctionType::ZExtAttribute)) 3242d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags &= ~(ISD::ParamFlags::SExt); 3243ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner if (FTy->paramHasAttr(j, FunctionType::SExtAttribute)) 3244d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::SExt; 32450db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (FTy->paramHasAttr(j, FunctionType::InRegAttribute)) 3246d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::InReg; 32470db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (FTy->paramHasAttr(j, FunctionType::StructRetAttribute)) 3248d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::StructReturn; 3249d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= (OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs); 3250ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner 3251fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 3252fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 3253fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 3254fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(VT); 3255b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3256fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3257fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: 3258fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(getTypeToTransformTo(VT)); 3259b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3260fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3261fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 3262fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 3263fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be broken up into small 3264fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the destination type is and how many small 3265fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it turns into. 32669f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType NVT = getTypeToExpandTo(VT); 32679f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = getNumElements(VT); 3268b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov for (unsigned i = 0; i != NumVals; ++i) { 3269fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(NVT); 3270cf8270a9941e697243bb9c91d5d8b2e1fc01a35cLauro Ramos Venancio // if it isn't first piece, alignment must be 1 32710db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (i > 0) 3272d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags = (Flags & (~ISD::ParamFlags::OrigAlignment)) | 3273d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov (1 << ISD::ParamFlags::OrigAlignmentOffs); 3274b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3275b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov } 3276fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 3277fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 3278fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 32799d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer unsigned NumElems = cast<VectorType>(I->getType())->getNumElements(); 32809d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const Type *EltTy = cast<VectorType>(I->getType())->getElementType(); 3281f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 3282fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 3283ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // type. If so, convert to the vector type. 3284fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 3285fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3286fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(TVT); 3287b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3288fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 3289fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 3290fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3291fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3292fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3293fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3294fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 32953b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng 32968c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner RetVals.push_back(MVT::Other); 3297fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 3298fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Create the node. 3299f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDNode *Result = DAG.getNode(ISD::FORMAL_ARGUMENTS, 3300f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(RetVals), RetVals.size(), 3301bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()).Val; 33028c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner 33038c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner DAG.setRoot(SDOperand(Result, Result->getNumValues()-1)); 3304fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 3305fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Set up the return result vector. 3306fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.clear(); 3307fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned i = 0; 330847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer unsigned Idx = 1; 330947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; 331047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ++I, ++Idx) { 3311fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 3312fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 3313fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 3314fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 3315fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 3316fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(SDOperand(Result, i++)); 3317fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3318fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: { 3319fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Op(Result, i++); 3320fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (MVT::isInteger(VT)) { 3321f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner if (FTy->paramHasAttr(Idx, FunctionType::SExtAttribute)) 3322f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner Op = DAG.getNode(ISD::AssertSext, Op.getValueType(), Op, 3323f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner DAG.getValueType(VT)); 3324f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner else if (FTy->paramHasAttr(Idx, FunctionType::ZExtAttribute)) 3325f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner Op = DAG.getNode(ISD::AssertZext, Op.getValueType(), Op, 3326f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner DAG.getValueType(VT)); 3327fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::TRUNCATE, VT, Op); 3328fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 3329fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 3330fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::FP_ROUND, VT, Op); 3331fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3332fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(Op); 3333fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3334fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3335fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 3336fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 3337b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // If this is a large integer or a floating point node that needs to be 3338b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // expanded, it needs to be reassembled from small integers. Figure out 3339b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // what the source elt type is and how many small integers it is. 3340b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng Ops.push_back(ExpandScalarFormalArgs(VT, Result, i, DAG, *this)); 3341fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 3342fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 3343fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 33449d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(I->getType()); 3345020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng unsigned NumElems = PTy->getNumElements(); 3346020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const Type *EltTy = PTy->getElementType(); 3347f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 3348fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 3349ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // type. If so, convert to the vector type. 3350fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 3351d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3352020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng SDOperand N = SDOperand(Result, i++); 3353020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng // Handle copies from generic vectors to registers. 3354d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 3355d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 3356d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 3357d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner Ops.push_back(N); 3358d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner } else { 3359fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 3360da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3361fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3362fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3363fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3364fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3365fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3366fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner return Ops; 3367fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner} 3368fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 3369f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3370b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// ExpandScalarCallArgs - Recursively expand call argument node by 3371b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// bit_converting it or extract a pair of elements from the larger node. 3372b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Chengstatic void ExpandScalarCallArgs(MVT::ValueType VT, SDOperand Arg, 33737aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio unsigned Flags, 3374b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SmallVector<SDOperand, 32> &Ops, 3375b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SelectionDAG &DAG, 33767aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio TargetLowering &TLI, 33777aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio bool isFirst = true) { 33787aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio 3379b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (TLI.getTypeAction(VT) != TargetLowering::Expand) { 3380cf8270a9941e697243bb9c91d5d8b2e1fc01a35cLauro Ramos Venancio // if it isn't first piece, alignment must be 1 33817aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio if (!isFirst) 3382d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags = (Flags & (~ISD::ParamFlags::OrigAlignment)) | 3383d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov (1 << ISD::ParamFlags::OrigAlignmentOffs); 3384b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng Ops.push_back(Arg); 3385b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3386b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return; 3387b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } 3388b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 3389b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng MVT::ValueType EVT = TLI.getTypeToTransformTo(VT); 3390b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng unsigned NumVals = MVT::getSizeInBits(VT) / MVT::getSizeInBits(EVT); 3391b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (NumVals == 1) { 3392b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng Arg = DAG.getNode(ISD::BIT_CONVERT, EVT, Arg); 33937aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio ExpandScalarCallArgs(EVT, Arg, Flags, Ops, DAG, TLI, isFirst); 3394b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else if (NumVals == 2) { 3395b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, EVT, Arg, 3396b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng DAG.getConstant(0, TLI.getPointerTy())); 3397b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, EVT, Arg, 3398b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng DAG.getConstant(1, TLI.getPointerTy())); 3399b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (!TLI.isLittleEndian()) 3400b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng std::swap(Lo, Hi); 34017aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio ExpandScalarCallArgs(EVT, Lo, Flags, Ops, DAG, TLI, isFirst); 34027aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio ExpandScalarCallArgs(EVT, Hi, Flags, Ops, DAG, TLI, false); 3403b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else { 3404b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // Value scalarized into many values. Unimp for now. 3405b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng assert(0 && "Cannot expand i64 -> i16 yet!"); 3406b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } 3407b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng} 3408b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 3409f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// TargetLowering::LowerCallTo - This is the default LowerCallTo 3410f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// implementation, which just inserts an ISD::CALL node, which is later custom 3411f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// lowered by the target to something concrete. FIXME: When all targets are 3412f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// migrated to using ISD::CALL, this hook should be integrated into SDISel. 3413f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattnerstd::pair<SDOperand, SDOperand> 341447857812e29324a9d1560796a05b53d3a9217fd9Reid SpencerTargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, 341547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer bool RetTyIsSigned, bool isVarArg, 3416f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned CallingConv, bool isTailCall, 3417f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Callee, 3418f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ArgListTy &Args, SelectionDAG &DAG) { 3419be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<SDOperand, 32> Ops; 3420f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Chain); // Op#0 - Chain 3421f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(CallingConv, getPointerTy())); // Op#1 - CC 3422f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isVarArg, getPointerTy())); // Op#2 - VarArg 3423f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isTailCall, getPointerTy())); // Op#3 - Tail 3424f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Callee); 3425f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3426f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Handle all of the outgoing arguments. 3427f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) { 342847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer MVT::ValueType VT = getValueType(Args[i].Ty); 342947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer SDOperand Op = Args[i].Node; 3430d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov unsigned Flags = ISD::ParamFlags::NoFlagSet; 34317aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio unsigned OriginalAlignment = 3432d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner getTargetData()->getABITypeAlignment(Args[i].Ty); 34330db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov 3434d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov if (Args[i].isSExt) 3435d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::SExt; 3436d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov if (Args[i].isZExt) 3437d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::ZExt; 34380db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (Args[i].isInReg) 3439d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::InReg; 34400db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (Args[i].isSRet) 3441d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::StructReturn; 3442d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs; 34430db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov 3444f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 3445f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 34467aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio case Legal: 3447f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 3448b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3449f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3450f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 3451f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (MVT::isInteger(VT)) { 3452d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov unsigned ExtOp; 3453d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov if (Args[i].isSExt) 3454d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov ExtOp = ISD::SIGN_EXTEND; 3455d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov else if (Args[i].isZExt) 3456d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov ExtOp = ISD::ZERO_EXTEND; 3457d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov else 3458d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov ExtOp = ISD::ANY_EXTEND; 3459f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ExtOp, getTypeToTransformTo(VT), Op); 3460f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3461f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 3462f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, getTypeToTransformTo(VT), Op); 3463f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3464f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 3465b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3466f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3467f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 3468f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 3469f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be broken down into small 3470f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 3471f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 3472b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov ExpandScalarCallArgs(VT, Op, Flags, Ops, DAG, *this); 3473f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3474da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 3475da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 34769d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(Args[i].Ty); 3477da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 3478da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 3479da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 3480da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 3481ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // type. If so, convert to the vector type. 3482da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 34831b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3484ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // Insert a VBIT_CONVERT of the MVT::Vector type to the vector type. 34851b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, TVT, Op); 34861b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Ops.push_back(Op); 3487b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 34881b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner } else { 3489da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call args yet!"); 3490da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3491da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 3492f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3493f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3494f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3495f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3496f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3497f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Figure out the result value types. 3498be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<MVT::ValueType, 4> RetTys; 3499f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3500f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTy != Type::VoidTy) { 3501f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 3502f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 3503f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 3504f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 3505f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(VT); 3506f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3507f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 3508f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(getTypeToTransformTo(VT)); 3509f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3510f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 3511f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 3512f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be reassembled from small 3513f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 3514f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 35159f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType NVT = getTypeToExpandTo(VT); 35169f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = getNumElements(VT); 3517f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0; i != NumVals; ++i) 3518f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(NVT); 3519f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3520da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 3521da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 35229d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(RetTy); 3523da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 3524da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 3525da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 3526da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 3527ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // type. If so, convert to the vector type. 3528da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 3529da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3530da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner RetTys.push_back(TVT); 3531da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 3532da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call results yet!"); 3533da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3534da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 3535f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3536f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3537f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3538f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3539f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(MVT::Other); // Always has a chain. 3540f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3541f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Finally, create the CALL node. 3542be384162c68641233deba8702666af51bdfd4b83Chris Lattner SDOperand Res = DAG.getNode(ISD::CALL, 3543be384162c68641233deba8702666af51bdfd4b83Chris Lattner DAG.getVTList(&RetTys[0], RetTys.size()), 3544be384162c68641233deba8702666af51bdfd4b83Chris Lattner &Ops[0], Ops.size()); 3545f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3546f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // This returns a pair of operands. The first element is the 3547f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // return value for the function (if RetTy is not VoidTy). The second 3548f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // element is the outgoing token chain. 3549f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand ResVal; 3550f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() != 1) { 3551f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 3552f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() == 2) { 3553f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = Res; 3554f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3555f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this value was promoted, truncate it down. 3556f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (ResVal.getValueType() != VT) { 3557da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (VT == MVT::Vector) { 35585df99b376f38a2a0aaa2fc63254cf0306eef3c1bChris Lattner // Insert a VBIT_CONVERT to convert from the packed result type to the 3559da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // MVT::Vector type. 35609d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer unsigned NumElems = cast<VectorType>(RetTy)->getNumElements(); 35619d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const Type *EltTy = cast<VectorType>(RetTy)->getElementType(); 3562da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 3563da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 3564ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer // type. If so, convert to the vector type. 3565fea997aac5773e936754de5436029c2a4fa1e930Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy),NumElems); 3566da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3567da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBIT_CONVERT of the FORMAL_ARGUMENTS to a 3568da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // "N x PTyElementVT" MVT::Vector type. 3569da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner ResVal = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, ResVal, 3570d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 3571d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 3572da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 3573da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3574da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 3575da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else if (MVT::isInteger(VT)) { 357647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer unsigned AssertOp = ISD::AssertSext; 357747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer if (!RetTyIsSigned) 357847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer AssertOp = ISD::AssertZext; 3579f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(AssertOp, ResVal.getValueType(), ResVal, 3580f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getValueType(VT)); 3581f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::TRUNCATE, VT, ResVal); 3582f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3583f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT)); 35841a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng if (getTypeAction(VT) == Expand) 35851a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng ResVal = DAG.getNode(ISD::BIT_CONVERT, VT, ResVal); 35861a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng else 35871a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng ResVal = DAG.getNode(ISD::FP_ROUND, VT, ResVal); 3588f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3589f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3590f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else if (RetTys.size() == 3) { 3591f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::BUILD_PAIR, VT, 3592f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Res.getValue(0), Res.getValue(1)); 3593f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3594f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3595f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(0 && "Case not handled yet!"); 3596f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3597f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3598f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3599f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner return std::make_pair(ResVal, Res.getValue(Res.Val->getNumValues()-1)); 3600f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner} 3601f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 360250381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 3603171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 3604171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 3605d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 3606171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 3607171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 36080aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 36090aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 36100aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 36110aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 36120aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 36130aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 36140aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 361574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 36161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 36171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 3618a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 36191db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 36201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 36211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 36221db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 36231db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 36241db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 36251db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 36261db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 36271db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 36281db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 36291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 36301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 36311db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 36321db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 36331db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 36341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 36351db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 36361db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 36371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 36381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 36391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 36401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 36411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 36421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 36431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 36441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 364574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 364674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 364774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 364874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 364974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 365074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 365174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 365274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng unsigned MSB = getSizeInBits(VT) / 8; 365374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 365474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 365574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 3656a5a57d66f5717873dbf3c48b174c0b0ce54b6612Evan Cheng Val = (Val << 8) | (unsigned char)Str[Offset]; 365774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 365874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 365974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 366074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 366174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 36621db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 36631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 36641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 36651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 36661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 36671db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 36681db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 3669c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 367080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 367180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 3672c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 3673c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 3674c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 36751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 36761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 36771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 36781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 36791db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 36801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 36811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 36821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 36831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 36841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 36851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 36861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 36871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 36881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 36891db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 36901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 36911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 36921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 36931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 36941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 36951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 369680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 369780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 369880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 369980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 37001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 370180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 370280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 370380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 3704dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 37051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 37061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 37071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 37081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 37091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 37101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 371180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 371280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 371380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 371480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 37151db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 37161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 37171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 371880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 371980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 37201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 37211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 37227041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 37231db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 37241db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 37251db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 37261db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 37271db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 37281db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 37291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 37301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 37311db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 37321db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 37331db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 37341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 3735bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 37361db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 3737ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 37381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 3739c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 3740c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 374180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 37421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 37431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 37441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 37451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 3746a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 3747786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng SDOperand Store = DAG.getStore(getRoot(), Value, 3748864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 37498b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), Offset); 3750c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 3751c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 3752c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3753c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3754c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 3755c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3756c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 3757c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 3758c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 3759c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 3760cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 376174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 376274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 3763cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 376474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 376574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 376674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 376774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 376874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 376974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 377074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 3771cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 377274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 377374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 377474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 3775f3e486e069011c70abb771958dc1218912b98eeaEvan Cheng if (GV && GV->isConstant()) { 37760937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 3777cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 3778cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 3779cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 3780cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 3781cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 378274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 378374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 3784c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 3785c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 3786c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 378774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 378874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 3789cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 379074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 379174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 379274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 3793786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 3794786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 37958b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 379674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 379774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 379874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 3799466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng I.getOperand(2), SrcOff); 380074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 380174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 3802786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 3803786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 38048b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 380574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 3806c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 380774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 380874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 38091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 38101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 3811c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 38121db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 38131db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 3814c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 3815c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 3816bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 3817bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size())); 3818c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 3819c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 38201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 38211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 3822bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, getRoot(), Op1, Op2, Op3, Op4)); 38231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 38241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 38257041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 38267041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 38277041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 38281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 38291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 38301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 38311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 38321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3833495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 383436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 383536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 3836c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AU.addRequired<AliasAnalysis>(); 38373cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng AU.addRequired<LoopInfo>(); 3838495a0b51915eb763576874f29192820b731edc22Chris Lattner} 38391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3840c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 38417e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// OptimizeNoopCopyExpression - We have determined that the specified cast 38427e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// instruction is a noop copy (e.g. it's casting from one pointer type to 38437e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// another, int->uint, or int->sbyte on PPC. 3844903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// 3845903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// Return true if any changes are made. 3846903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeNoopCopyExpression(CastInst *CI) { 38477e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *DefBB = CI->getParent(); 38487e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38497e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner /// InsertedCasts - Only insert a cast in each block once. 38507e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner std::map<BasicBlock*, CastInst*> InsertedCasts; 38517e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 3852903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = false; 38537e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end(); 38547e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UI != E; ) { 38557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Use &TheUse = UI.getUse(); 38567e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *User = cast<Instruction>(*UI); 38577e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38587e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Figure out which BB this cast is used in. For PHI's this is the 38597e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // appropriate predecessor block. 38607e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *UserBB = User->getParent(); 38617e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(User)) { 38627e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner unsigned OpVal = UI.getOperandNo()/2; 38637e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UserBB = PN->getIncomingBlock(OpVal); 38647e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 38657e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38667e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Preincrement use iterator so we don't invalidate it. 38677e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner ++UI; 38687e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38697e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this user is in the same block as the cast, don't change the cast. 38707e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (UserBB == DefBB) continue; 38717e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38727e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If we have already inserted a cast into this block, use it. 38737e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner CastInst *&InsertedCast = InsertedCasts[UserBB]; 38747e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38757e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (!InsertedCast) { 38767e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock::iterator InsertPt = UserBB->begin(); 38777e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 38787e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38797e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner InsertedCast = 38807b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer CastInst::create(CI->getOpcode(), CI->getOperand(0), CI->getType(), "", 38817b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer InsertPt); 3882903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = true; 38837e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 38847e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38857e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Replace a use of the cast with a use of the new casat. 38867e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner TheUse = InsertedCast; 38877e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 3888903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3889903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If we removed all uses, nuke the cast. 3890903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->use_empty()) 3891903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner CI->eraseFromParent(); 3892903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3893903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return MadeChange; 38947e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner} 3895c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3896903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 3897903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// casting to the type of GEPI. 3898f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattnerstatic Instruction *InsertGEPComputeCode(Instruction *&V, BasicBlock *BB, 3899f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *GEPI, Value *Ptr, 3900f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Value *PtrOffset) { 3901903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (V) return V; // Already computed. 3902903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 39033da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Figure out the insertion point 3904903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner BasicBlock::iterator InsertPt; 3905903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (BB == GEPI->getParent()) { 39063da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // If GEP is already inserted into BB, insert right after the GEP. 3907903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = GEPI; 3908903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ++InsertPt; 3909903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3910903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 3911903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = BB->begin(); 3912903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 3913903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3914903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3915903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 3916903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // BB so that there is only one value live across basic blocks (the cast 3917903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // operand). 3918903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 3919903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 39207b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer Ptr = CastInst::create(CI->getOpcode(), CI->getOperand(0), CI->getType(), 39217b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer "", InsertPt); 3922903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3923903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Add the offset, cast it to the right type. 3924903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 39253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Ptr is an integer type, GEPI is pointer type ==> IntToPtr 39263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return V = CastInst::create(Instruction::IntToPtr, Ptr, GEPI->getType(), 39273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "", InsertPt); 3928903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3929903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3930903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// ReplaceUsesOfGEPInst - Replace all uses of RepPtr with inserted code to 3931903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// compute its value. The RepPtr value can be computed with Ptr+PtrOffset. One 3932903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// trivial way of doing this would be to evaluate Ptr+PtrOffset in RepPtr's 3933903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// block, then ReplaceAllUsesWith'ing everything. However, we would prefer to 3934903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// sink PtrOffset into user blocks where doing so will likely allow us to fold 3935903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// the constant add into a load or store instruction. Additionally, if a user 3936903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// is a pointer-pointer cast, we look through it to find its users. 3937903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic void ReplaceUsesOfGEPInst(Instruction *RepPtr, Value *Ptr, 3938903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Constant *PtrOffset, BasicBlock *DefBB, 3939903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GetElementPtrInst *GEPI, 3940f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> &InsertedExprs) { 3941903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (!RepPtr->use_empty()) { 3942903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Instruction *User = cast<Instruction>(RepPtr->use_back()); 3943903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 39443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // If the user is a Pointer-Pointer cast, recurse. Only BitCast can be 39453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // used for a Pointer-Pointer cast. 39463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (isa<BitCastInst>(User)) { 3947903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(User, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3948903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3949903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Drop the use of RepPtr. The cast is dead. Don't delete it now, else we 3950903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // could invalidate an iterator. 3951903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->setOperand(0, UndefValue::get(RepPtr->getType())); 3952903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner continue; 3953903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3954903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3955903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a load of the pointer, or a store through the pointer, emit 3956903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // the increment into the load/store block. 3957f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *NewVal; 3958903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (isa<LoadInst>(User) || 3959903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner (isa<StoreInst>(User) && User->getOperand(0) != RepPtr)) { 3960903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 3961903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->getParent(), GEPI, 3962903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3963903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3964903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this use is not foldable into the addressing mode, use a version 3965903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // emitted in the GEP block. 3966903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 3967903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3968903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3969903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3970f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner if (GEPI->getType() != RepPtr->getType()) { 3971f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner BasicBlock::iterator IP = NewVal; 3972f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner ++IP; 39733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // NewVal must be a GEP which must be pointer type, so BitCast 39743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer NewVal = new BitCastInst(NewVal, RepPtr->getType(), "", IP); 3975f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner } 3976903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->replaceUsesOfWith(RepPtr, NewVal); 3977903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3978903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3979903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3980903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3981c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 3982c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 3983c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 3984c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 3985c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 3986c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 3987903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeGEPExpression(GetElementPtrInst *GEPI, 3988a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD) { 3989c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 3990c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 3991c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 3992c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 3993c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 3994c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 3995c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 3996c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 3997c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3998c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3999c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 4000903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!isUsedOutsideDefBB) return false; 4001c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4002c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 4003c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 4004c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 4005903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool hasVariableIndex = false; 4006c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 4007c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 4008903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) { 4009b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue()) { 4010c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 4011c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 4012c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 4013903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 4014903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner hasVariableIndex = true; 4015903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 4016c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 4017903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 4018903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a "GEP X, 0, 0, 0", turn this into a cast. 4019903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !hasVariableIndex) { 40203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer /// The GEP operand must be a pointer, so must its result -> BitCast 40213da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Value *NC = new BitCastInst(GEPI->getOperand(0), GEPI->getType(), 4022903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->getName(), GEPI); 4023903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->replaceAllUsesWith(NC); 4024903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->eraseFromParent(); 4025903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 4026903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 4027903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 40283802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 4029903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) 4030903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return false; 4031c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4032c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 4033c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 4034c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 4035a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const Type *UIntPtrTy = TD->getIntPtrType(); 40363da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Value *Ptr = new PtrToIntInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 4037c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 4038c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4039c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 4040c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 4041c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 4042c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 4043b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 4044c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 4045b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner ConstantOffset += TD->getStructLayout(StTy)->getElementOffset(Field); 4046c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 4047c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 4048c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 4049c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4050c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 4051c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 4052b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 405347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ConstantOffset += (int64_t)TD->getTypeSize(Ty)*CI->getSExtValue(); 4054c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 4055c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 4056c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4057c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 4058c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4059c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 40607b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer Idx = CastInst::createIntegerCast(Idx, UIntPtrTy, true/*SExt*/, "", GEPI); 4061c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4062a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 4063c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 4064c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 4065b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Constant *SizeCst = ConstantInt::get(UIntPtrTy, ElementSize); 4066c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4067c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 4068c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 4069c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 4070c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 4071c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 4072c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4073c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 4074c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 4075b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Constant *PtrOffset = ConstantInt::get(UIntPtrTy, ConstantOffset); 4076c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4077c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 4078c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 4079c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 4080c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 4081c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 4082c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 4083c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 4084c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 4085f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> InsertedExprs; 4086903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(GEPI, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 4087c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4088c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 4089c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 4090903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 4091903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 4092c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 4093c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 40943cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng/// isLoopInvariantInst - Returns true if all operands of the instruction are 40953cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng/// loop invariants in the specified loop. 40963cd4e5095b06b2be94a0cab3060272aae3460167Evan Chengstatic bool isLoopInvariantInst(Instruction *I, Loop *L) { 40973cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // The instruction is loop invariant if all of its operands are loop-invariant 40983cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) 40993cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (!L->isLoopInvariant(I->getOperand(i))) 41003cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng return false; 41013cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng return true; 41023cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng} 41033cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41043cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng/// SinkInvariantGEPIndex - If a GEP instruction has a variable index that has 41053cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng/// been hoisted out of the loop by LICM pass, sink it back into the use BB 41063cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng/// if it can be determined that the index computation can be folded into the 41073cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng/// addressing mode of the load / store uses. 41083cd4e5095b06b2be94a0cab3060272aae3460167Evan Chengstatic bool SinkInvariantGEPIndex(BinaryOperator *BinOp, LoopInfo *loopInfo, 41093cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng const TargetLowering &TLI) { 41103cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // Only look at Add / Sub for now. 41113cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (BinOp->getOpcode() != Instruction::Add && 41123cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng BinOp->getOpcode() != Instruction::Sub) 41133cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng return false; 41143cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41152edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng // DestBBs - These are the blocks where a copy of BinOp will be inserted. 4116db264ae07f451cbd5bb33d528ae00e4910ce386bEvan Cheng SmallSet<BasicBlock*, 8> DestBBs; 41173cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng BasicBlock *DefBB = BinOp->getParent(); 41182edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng bool MadeChange = false; 41193cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng for (Value::use_iterator UI = BinOp->use_begin(), E = BinOp->use_end(); 41202edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng UI != E; ++UI) { 41213cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng Instruction *User = cast<Instruction>(*UI); 41223cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // Only look for GEP use in another block. 41233cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (User->getParent() == DefBB) continue; 41243cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41253cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (isa<GetElementPtrInst>(User)) { 41263cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng BasicBlock *UserBB = User->getParent(); 41273cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng Loop *L = loopInfo->getLoopFor(UserBB); 41283cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41293cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // Only sink if expression is a loop invariant in the use BB. 41309f5ead9601e110b2e67123d73647cbd88308c379Evan Cheng if (L && isLoopInvariantInst(BinOp, L) && !User->use_empty()) { 41313cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng const Type *UseTy = NULL; 41323cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // FIXME: We are assuming all the uses of the GEP will have the 41333cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // same type. 41343cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng Instruction *GEPUser = cast<Instruction>(*User->use_begin()); 41353cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (LoadInst *Load = dyn_cast<LoadInst>(GEPUser)) 41363cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng UseTy = Load->getType(); 41373cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng else if (StoreInst *Store = dyn_cast<StoreInst>(GEPUser)) 41383cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng UseTy = Store->getOperand(0)->getType(); 41393cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41403cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng // Check if it is possible to fold the expression to address mode. 41413cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (UseTy && 414229a68fb5b733119dd8295a4f7c7d069b9f78f0a3Evan Cheng TLI.isLegalAddressExpression(BinOp->getOpcode(), 414329a68fb5b733119dd8295a4f7c7d069b9f78f0a3Evan Cheng BinOp->getOperand(0), 41443cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng BinOp->getOperand(1), UseTy)) { 41452edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng DestBBs.insert(UserBB); 41463cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng MadeChange = true; 41473cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng } 41483cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng } 41493cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng } 41503cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng } 41513cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41522edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng // Nothing to do. 41532edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng if (!MadeChange) 41542edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng return false; 41552edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng 41562edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng /// InsertedOps - Only insert a duplicate in each block once. 41572edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng std::map<BasicBlock*, BinaryOperator*> InsertedOps; 41582edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng for (Value::use_iterator UI = BinOp->use_begin(), E = BinOp->use_end(); 41592edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng UI != E; ) { 41602edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng Instruction *User = cast<Instruction>(*UI); 41612edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng BasicBlock *UserBB = User->getParent(); 41622edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng 41632edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng // Preincrement use iterator so we don't invalidate it. 41642edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng ++UI; 41652edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng 41662edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng // If any user in this BB wants it, replace all the uses in the BB. 41672edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng if (DestBBs.count(UserBB)) { 41682edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng // Sink it into user block. 41692edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng BinaryOperator *&InsertedOp = InsertedOps[UserBB]; 41702edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng if (!InsertedOp) { 41712edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng BasicBlock::iterator InsertPt = UserBB->begin(); 41722edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng while (isa<PHINode>(InsertPt)) ++InsertPt; 41732edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng 41742edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng InsertedOp = 41752edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng BinaryOperator::create(BinOp->getOpcode(), BinOp->getOperand(0), 41762edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng BinOp->getOperand(1), "", InsertPt); 41772edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng } 41782edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng 41792edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng User->replaceUsesOfWith(BinOp, InsertedOp); 41802edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng } 41812edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng } 41822edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng 41833cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng if (BinOp->use_empty()) 41843cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng BinOp->eraseFromParent(); 41853cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 41862edd5638255dbbcdad55ca724953e155ab13b5d1Evan Cheng return true; 41873cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng} 41883cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 4189bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4190bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// SplitEdgeNicely - Split the critical edge from TI to it's specified 4191bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// successor if it will improve codegen. We only do this if the successor has 4192bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// phi nodes (otherwise critical edges are ok). If there is already another 4193bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// predecessor of the succ that is empty (and thus has no phi nodes), use it 4194bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// instead of introducing a new block. 4195bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattnerstatic void SplitEdgeNicely(TerminatorInst *TI, unsigned SuccNum, Pass *P) { 4196bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BasicBlock *TIBB = TI->getParent(); 4197bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BasicBlock *Dest = TI->getSuccessor(SuccNum); 4198bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner assert(isa<PHINode>(Dest->begin()) && 4199bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner "This should only be called if Dest has a PHI!"); 4200bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4201bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner /// TIPHIValues - This array is lazily computed to determine the values of 4202bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner /// PHIs in Dest that TI would provide. 4203bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner std::vector<Value*> TIPHIValues; 4204bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4205bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Check to see if Dest has any blocks that can be used as a split edge for 4206bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // this terminator. 4207bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner for (pred_iterator PI = pred_begin(Dest), E = pred_end(Dest); PI != E; ++PI) { 4208bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BasicBlock *Pred = *PI; 4209bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // To be usable, the pred has to end with an uncond branch to the dest. 4210bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BranchInst *PredBr = dyn_cast<BranchInst>(Pred->getTerminator()); 4211bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (!PredBr || !PredBr->isUnconditional() || 4212bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Must be empty other than the branch. 4213bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner &Pred->front() != PredBr) 4214bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner continue; 4215bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4216bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Finally, since we know that Dest has phi nodes in it, we have to make 4217bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // sure that jumping to Pred will have the same affect as going to Dest in 4218bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // terms of PHI values. 4219bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner PHINode *PN; 4220bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner unsigned PHINo = 0; 4221bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner bool FoundMatch = true; 4222bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner for (BasicBlock::iterator I = Dest->begin(); 4223bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner (PN = dyn_cast<PHINode>(I)); ++I, ++PHINo) { 4224bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (PHINo == TIPHIValues.size()) 4225bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner TIPHIValues.push_back(PN->getIncomingValueForBlock(TIBB)); 4226bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4227bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // If the PHI entry doesn't work, we can't use this pred. 4228bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (TIPHIValues[PHINo] != PN->getIncomingValueForBlock(Pred)) { 4229bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner FoundMatch = false; 4230bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner break; 4231bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 4232bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 4233bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4234bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // If we found a workable predecessor, change TI to branch to Succ. 4235bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (FoundMatch) { 4236bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner Dest->removePredecessor(TIBB); 4237bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner TI->setSuccessor(SuccNum, Pred); 4238bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner return; 4239bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 4240bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 4241bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4242bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner SplitCriticalEdge(TI, SuccNum, P, true); 4243bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner} 4244bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 4245bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 42461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 42471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 42481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 4249832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "\n\n\n=== " << Fn.getName() << "\n"; 42501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 42513cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng LoopInfo *loopInfo = &getAnalysis<LoopInfo>(); 42523cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng 425347e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner // First, split all critical edges. 4254c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 42557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // In this pass we also look for GEP and cast instructions that are used 42567e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // across basic blocks and rewrite them to improve basic-block-at-a-time 42577e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // selection. 42587e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // 4259903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = true; 4260903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (MadeChange) { 4261903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = false; 426215699fc5ed0378205f9705d35d019d9ff0cf200dEvan Cheng for (Function::iterator FNI = Fn.begin(), E = Fn.end(); FNI != E; ++FNI) { 4263bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Split all critical edges where the dest block has a PHI. 426415699fc5ed0378205f9705d35d019d9ff0cf200dEvan Cheng TerminatorInst *BBTI = FNI->getTerminator(); 426547e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner if (BBTI->getNumSuccessors() > 1) { 426647e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner for (unsigned i = 0, e = BBTI->getNumSuccessors(); i != e; ++i) 4267bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (isa<PHINode>(BBTI->getSuccessor(i)->begin()) && 4268bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner isCriticalEdge(BBTI, i, true)) 4269bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner SplitEdgeNicely(BBTI, i, this); 427047e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner } 427147e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner 4272c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 427315699fc5ed0378205f9705d35d019d9ff0cf200dEvan Cheng for (BasicBlock::iterator BBI = FNI->begin(), E = FNI->end(); BBI != E; ) { 42747e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *I = BBI++; 42753f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner 42763f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (CallInst *CI = dyn_cast<CallInst>(I)) { 42773f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner // If we found an inline asm expession, and if the target knows how to 42783f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner // lower it to normal LLVM code, do so now. 42793f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (isa<InlineAsm>(CI->getCalledValue())) 42803f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (const TargetAsmInfo *TAI = 42813f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner TLI.getTargetMachine().getTargetAsmInfo()) { 42823f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (TAI->ExpandInlineAsm(CI)) 428315699fc5ed0378205f9705d35d019d9ff0cf200dEvan Cheng BBI = FNI->begin(); 42843f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner } 42853f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) { 4286903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeGEPExpression(GEPI, TLI.getTargetData()); 42877e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } else if (CastInst *CI = dyn_cast<CastInst>(I)) { 4288c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // If the source of the cast is a constant, then this should have 4289c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // already been constant folded. The only reason NOT to constant fold 4290c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // it is if something (e.g. LSR) was careful to place the constant 4291c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // evaluation in a block other than then one that uses it (e.g. to hoist 4292c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // the address of globals out of a loop). If this is the case, we don't 4293c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // want to forward-subst the cast. 4294c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner if (isa<Constant>(CI->getOperand(0))) 4295c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner continue; 4296c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner 42977e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is a noop copy, sink it into user blocks to reduce the number 42987e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // of virtual registers that must be created and coallesced. 42997e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType SrcVT = TLI.getValueType(CI->getOperand(0)->getType()); 43007e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType DstVT = TLI.getValueType(CI->getType()); 43017e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 43027e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // This is an fp<->int conversion? 43037e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (MVT::isInteger(SrcVT) != MVT::isInteger(DstVT)) 43047e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner continue; 43057e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 43067e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is an extension, it will be a zero or sign extension, which 43077e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // isn't a noop. 43087e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT < DstVT) continue; 43097e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 43107e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If these values will be promoted, find out what they will be promoted 43117e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // to. This helps us consider truncates on PPC as noop copies when they 43127e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // are. 43137e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(SrcVT) == TargetLowering::Promote) 43147e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner SrcVT = TLI.getTypeToTransformTo(SrcVT); 43157e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(DstVT) == TargetLowering::Promote) 43167e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner DstVT = TLI.getTypeToTransformTo(DstVT); 43177e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 43187e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If, after promotion, these are the same types, this is a noop copy. 43197e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT == DstVT) 4320903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeNoopCopyExpression(CI); 43213cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng } else if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(I)) { 43223cd4e5095b06b2be94a0cab3060272aae3460167Evan Cheng MadeChange |= SinkInvariantGEPIndex(BinOp, loopInfo, TLI); 43237e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 43247e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 432536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 4326903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 4327c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 43281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 43291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 43301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 43311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 4332edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 4333ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng // Add function live-ins to entry block live-in set. 4334ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng BasicBlock *EntryBB = &Fn.getEntryBlock(); 4335ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng BB = FuncInfo.MBBMap[EntryBB]; 4336ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng if (!MF.livein_empty()) 4337ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng for (MachineFunction::livein_iterator I = MF.livein_begin(), 4338ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng E = MF.livein_end(); I != E; ++I) 4339ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng BB->addLiveIn(I->first); 4340ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng 43411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 43421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 43431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4344571e434a34e26f295f13db2dd07551de7e25f8a9Chris LattnerSDOperand SelectionDAGLowering::CopyValueToVirtualRegister(Value *V, 4345571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg) { 4346571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Op = getValue(V); 434718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 4348d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 434918c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 4350d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 4351d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 4352d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 4353d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 4354d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 4355d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 4356571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return DAG.getCopyToReg(getRoot(), Reg, Op); 43571c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } else if (SrcVT == MVT::Vector) { 435870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Handle copies from generic vectors to registers. 435970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 43609d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer unsigned NE = TLI.getVectorTypeBreakdown(cast<VectorType>(V->getType()), 436170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT, PTyLegalElementVT); 43621c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 436370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Insert a VBIT_CONVERT of the input vector to a "N x PTyElementVT" 436470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // MVT::Vector type. 436570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Op, 436670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getConstant(NE, MVT::i32), 436770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getValueType(PTyElementVT)); 436870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 436970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Loop over all of the elements of the resultant vector, 437070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // VEXTRACT_VECTOR_ELT'ing them, converting them to PTyLegalElementVT, then 437170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // copying them into output registers. 4372bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 4373571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Root = getRoot(); 437470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 437570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Elt = DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, PTyElementVT, 4376a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(i, TLI.getPointerTy())); 437770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 437870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are legal. 437970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 438070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyLegalElementVT > PTyElementVT) { 438170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are promoted. 438270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyLegalElementVT)) 438370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::FP_EXTEND, PTyLegalElementVT, Elt); 438470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 438570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::ANY_EXTEND, PTyLegalElementVT, Elt); 438670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 438770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 438870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are expanded. 438970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // The src value is expanded into multiple registers. 439070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 4391a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(0, TLI.getPointerTy())); 439270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 4393a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(1, TLI.getPointerTy())); 439470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Lo)); 439570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Hi)); 439670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 43971c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } 4398bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, 4399bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 44009f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng } else if (TLI.getTypeAction(SrcVT) == TargetLowering::Promote) { 4401d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 4402fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 4403fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 4404fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 4405fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 4406571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return DAG.getCopyToReg(getRoot(), Reg, Op); 4407d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 44089f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng DestVT = TLI.getTypeToExpandTo(SrcVT); 44099f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = TLI.getNumElements(SrcVT); 44109f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (NumVals == 1) 44119f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng return DAG.getCopyToReg(getRoot(), Reg, 44129f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng DAG.getNode(ISD::BIT_CONVERT, DestVT, Op)); 44139f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng assert(NumVals == 2 && "1 to 4 (and more) expansion not implemented!"); 4414d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 4415d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 4416a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(0, TLI.getPointerTy())); 4417d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 4418a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(1, TLI.getPointerTy())); 4419571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Op = DAG.getCopyToReg(getRoot(), Reg, Lo); 4420d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 4421d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 44221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 44231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4424068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 442515699fc5ed0378205f9705d35d019d9ff0cf200dEvan ChengLowerArguments(BasicBlock *LLVMBB, SelectionDAGLowering &SDL, 4426068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 44271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 442815699fc5ed0378205f9705d35d019d9ff0cf200dEvan Cheng Function &F = *LLVMBB->getParent(); 44290afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 4430bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 4431bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 4432bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 4433bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 4434bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 4435bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 4436bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 4437bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 4438f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 4439bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 4440bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 4441251db1890c1fe03d02ee878ada8129537844d031Chris Lattner DenseMap<const Value*, unsigned>::iterator VMI=FuncInfo.ValueMap.find(AI); 4442251db1890c1fe03d02ee878ada8129537844d031Chris Lattner if (VMI != FuncInfo.ValueMap.end()) { 4443251db1890c1fe03d02ee878ada8129537844d031Chris Lattner SDOperand Copy = SDL.CopyValueToVirtualRegister(AI, VMI->second); 4444bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 4445bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 44460afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 4447bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 4448bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 4449966454129dc62260df1f438f0243f6877dcd185cChris Lattner // FIXME: this should insert code into the DAG! 4450bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 4451068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 4452068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 4453068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 4454068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 4455f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 4456068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 4457068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 4458068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 4459edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 4460bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 4461ecb7a77885b174cf4d001a9b48533b3979e7810dDan Gohman if (LLVMBB == &LLVMBB->getParent()->getEntryBlock()) 4462bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 44631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 44651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 44661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 44681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 44691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 44701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 4471183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey 4472183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Lower call part of invoke. 4473183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey InvokeInst *Invoke = dyn_cast<InvokeInst>(LLVMBB->getTerminator()); 4474183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey if (Invoke) SDL.visitInvoke(*Invoke, false); 4475f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 44761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 44771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 44781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 4479f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 44809f24ad79ce32200b06499ef638b502fc1c36ed04Chris Lattner DenseMap<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 44811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 4482ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 4483571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(I, VMI->second)); 44841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 44851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 44871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 44881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 44891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 44901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 44911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 4492edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 44938c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 44941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 44961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 4497d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 44988c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Vector bool would be better, but vector<bool> is really slow. 44998c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner std::vector<unsigned char> SuccsHandled; 45008c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (TI->getNumSuccessors()) 45018c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled.resize(BB->getParent()->getNumBlockIDs()); 45028c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 45031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 45041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 45051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 45061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 4507d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (!isa<PHINode>(SuccBB->begin())) continue; 45088c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 4509d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 45108c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // If this terminator has multiple identical successors (common for 45118c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // switches), only handle each succ once. 45128c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned SuccMBBNo = SuccMBB->getNumber(); 45138c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (SuccsHandled[SuccMBBNo]) continue; 45148c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled[SuccMBBNo] = true; 45158c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 45168c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 45171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 45181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 45191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 45201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 45211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 45221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 45238c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner (PN = dyn_cast<PHINode>(I)); ++I) { 45248c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Ignore dead phi's. 45258c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (PN->use_empty()) continue; 45268c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 45278c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned Reg; 45288c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 45293f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner 45308c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 45318c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned &RegOut = ConstantsOut[C]; 45328c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (RegOut == 0) { 45338c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner RegOut = FuncInfo.CreateRegForValue(C); 45348c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner UnorderedChains.push_back( 45358c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SDL.CopyValueToVirtualRegister(C, RegOut)); 45361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 45378c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = RegOut; 45388c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } else { 45398c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 45408c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Reg == 0) { 45418c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner assert(isa<AllocaInst>(PHIOp) && 45428c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 45438c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner "Didn't codegen value into a register!??"); 45448c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 45458c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner UnorderedChains.push_back( 45468c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SDL.CopyValueToVirtualRegister(PHIOp, Reg)); 45477e02151ce2686687446ba7293e66d6b096106e68Chris Lattner } 45481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 45498c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 45508c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Remember that this register needs to added to the machine PHI node as 45518c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // the input for this MBB. 45528c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 45538c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned NumElements; 45548c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (VT != MVT::Vector) 45558c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner NumElements = TLI.getNumElements(VT); 45568c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner else { 45578c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT1,VT2; 45588c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner NumElements = 45599d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer TLI.getVectorTypeBreakdown(cast<VectorType>(PN->getType()), 45608c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner VT1, VT2); 45618c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 45628c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 45638c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 45648c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 45651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 45661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 45671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4568ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 45695a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 45707436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 45717436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 45727436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 45737436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 45747436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 45757436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 45767436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 45777436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 45787436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 45797436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 45807436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 45817436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 4582bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 4583bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &UnorderedChains[0], UnorderedChains.size())); 4584ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 4585ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 45861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 4587183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey if (Invoke) { 4588183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey // Just the branch part of invoke. 4589183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey SDL.visitInvoke(*Invoke, true); 4590183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey } else { 4591183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey SDL.visit(*LLVMBB->getTerminator()); 4592183f47fb1aa30ba9a56e645c35a7d798cf7e467cJim Laskey } 4593a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 4594f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 459537efe6764568a3829fee26aba532283131d1a104Nate Begeman // lowering, as well as any jump table information. 4596f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 4597f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 45983a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JTCases.clear(); 45993a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JTCases = SDL.JTCases; 4600f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4601a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 4602a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 46031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 46041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4605f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 4606c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey // Get alias analysis for load/store combining. 4607c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AliasAnalysis &AA = getAnalysis<AliasAnalysis>(); 4608c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey 4609af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 4610c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey DAG.Combine(false, AA); 46112300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 4612832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Lowered selection DAG:\n"; 46131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 4614f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 46151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 46161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 4617ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 4618f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4619832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Legalized selection DAG:\n"; 46201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 4621f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4622af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 4623c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey DAG.Combine(true, AA); 46242300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 4625a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 4626552c4a849422ad91fa9988255ae35aebbf3acf7bEvan Cheng 4627a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 4628a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 46291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 4630f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4631832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Selected machine code:\n"; 46321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 4633f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 4634f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4635f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 4636f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 4637f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 4638f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 463944c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 4640f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 4641f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4642f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 4643f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 4644f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 46451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4646f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 4647f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 4648f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4649f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4650a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 46511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 46523a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (SwitchCases.empty() && JTCases.empty()) { 4653f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 4654f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 4655f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 4656f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 465709e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 4658f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 4659f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4660f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 46611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4662f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 46639453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 46649453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 46659453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 46663a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov for (unsigned i = 0, e = JTCases.size(); i != e; ++i) { 46673a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Lower header first, if it wasn't already lowered 46683a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (!JTCases[i].first.Emitted) { 46693a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAG HSDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 46703a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CurDAG = &HSDAG; 46713a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAGLowering HSDL(HSDAG, TLI, FuncInfo); 46723a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 46733a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov BB = JTCases[i].first.HeaderBB; 46743a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov HSDL.setCurrentBasicBlock(BB); 46753a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Emit the code 46763a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov HSDL.visitJumpTableHeader(JTCases[i].second, JTCases[i].first); 46773a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov HSDAG.setRoot(HSDL.getRoot()); 46783a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CodeGenAndEmitDAG(HSDAG); 46793a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov } 46803a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 46813a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAG JSDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 46823a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CurDAG = &JSDAG; 46833a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAGLowering JSDL(JSDAG, TLI, FuncInfo); 468437efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 46853a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov BB = JTCases[i].second.MBB; 46863a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JSDL.setCurrentBasicBlock(BB); 468737efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 46883a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JSDL.visitJumpTable(JTCases[i].second); 46893a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JSDAG.setRoot(JSDL.getRoot()); 46903a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CodeGenAndEmitDAG(JSDAG); 46913a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 469237efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 469337efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 469437efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 469537efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 469637efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 469737efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 46983a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (PHIBB == JTCases[i].second.Default) { 469909e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 47003a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov PHI->addMachineBasicBlockOperand(JTCases[i].first.HeaderBB); 4701f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 4702f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (BB->succ_end() != std::find(BB->succ_begin(),BB->succ_end(), PHIBB)) { 470309e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 4704f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(BB); 470537efe6764568a3829fee26aba532283131d1a104Nate Begeman } 470637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 470737efe6764568a3829fee26aba532283131d1a104Nate Begeman } 470837efe6764568a3829fee26aba532283131d1a104Nate Begeman 4709b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // If the switch block involved a branch to one of the actual successors, we 4710b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // need to update PHI nodes in that block. 4711b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 4712b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 4713b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 4714b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner "This is not a machine PHI node that we are updating!"); 4715b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (BB->isSuccessor(PHI->getParent())) { 4716b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 4717b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner PHI->addMachineBasicBlockOperand(BB); 4718b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 4719b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 4720b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner 4721f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 4722f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 4723d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 472444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 4725f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 4726f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 4727d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4728f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 4729f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 4730f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 4731d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4732f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 4733f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 4734f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 4735f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 4736d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4737d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Handle any PHI nodes in successors of this chunk, as if we were coming 4738d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // from the original BB before switch expansion. Note that PHI nodes can 4739d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // occur multiple times in PHINodesToUpdate. We have to be very careful to 4740d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // handle them the right number of times. 474157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner while ((BB = SwitchCases[i].TrueBB)) { // Handle LHS and RHS. 4742d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (MachineBasicBlock::iterator Phi = BB->begin(); 4743d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi != BB->end() && Phi->getOpcode() == TargetInstrInfo::PHI; ++Phi){ 4744d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // This value for this PHI node is recorded in PHINodesToUpdate, get it. 4745d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned pn = 0; ; ++pn) { 4746d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner assert(pn != PHINodesToUpdate.size() && "Didn't find PHI entry!"); 4747d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (PHINodesToUpdate[pn].first == Phi) { 4748d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addRegOperand(PHINodesToUpdate[pn].second, false); 4749d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addMachineBasicBlockOperand(SwitchCases[i].ThisBB); 4750d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner break; 4751d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 4752d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 4753f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4754d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4755d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Don't process RHS if same block as LHS. 475657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (BB == SwitchCases[i].FalseBB) 475757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 4758d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4759d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // If we haven't handled the RHS, do so now. Otherwise, we're done. 47602452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner SwitchCases[i].TrueBB = SwitchCases[i].FalseBB; 476157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 4762f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 476357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner assert(SwitchCases[i].TrueBB == 0 && SwitchCases[i].FalseBB == 0); 4764a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 47651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4766a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 476713ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 4768a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 4769a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 4770a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 4771a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 4772a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 477313ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 4774eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterScheduler::FunctionPassCtor Ctor = RegisterScheduler::getDefault(); 477513ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 477613ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 4777eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = ISHeuristic; 47789373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey RegisterScheduler::setDefault(Ctor); 47794ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 478013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 47819ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey ScheduleDAG *SL = Ctor(this, &DAG, BB); 4782a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 4783cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 4784a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 47850e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 478603fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 47879ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim LaskeyHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 47889ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey return new HazardRecognizer(); 47899ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey} 47909ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 4791755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 4792755480681c795d585c73556c028b6143c46bda86Chris Lattner// Helper functions used by the generated instruction selector. 4793755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 4794755480681c795d585c73556c028b6143c46bda86Chris Lattner// Calls to these methods are generated by tblgen. 4795755480681c795d585c73556c028b6143c46bda86Chris Lattner 4796755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckAndMask - The isel is trying to match something like (and X, 255). If 4797755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 4798755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an AND, and DesiredMaskS is the value 4799755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 4800755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckAndMask(SDOperand LHS, ConstantSDNode *RHS, 4801755480681c795d585c73556c028b6143c46bda86Chris Lattner int64_t DesiredMaskS) { 4802755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 4803755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 4804755480681c795d585c73556c028b6143c46bda86Chris Lattner 4805755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 4806755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 4807755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4808755480681c795d585c73556c028b6143c46bda86Chris Lattner 4809755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 4810755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 4811755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4812755480681c795d585c73556c028b6143c46bda86Chris Lattner 4813755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 4814755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 4815755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 4816755480681c795d585c73556c028b6143c46bda86Chris Lattner if (getTargetLowering().MaskedValueIsZero(LHS, NeededMask)) 4817755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4818755480681c795d585c73556c028b6143c46bda86Chris Lattner 4819755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 4820755480681c795d585c73556c028b6143c46bda86Chris Lattner 4821755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 4822755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4823755480681c795d585c73556c028b6143c46bda86Chris Lattner} 4824755480681c795d585c73556c028b6143c46bda86Chris Lattner 4825755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckOrMask - The isel is trying to match something like (or X, 255). If 4826755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 4827755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an OR, and DesiredMaskS is the value 4828755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 4829755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckOrMask(SDOperand LHS, ConstantSDNode *RHS, 4830755480681c795d585c73556c028b6143c46bda86Chris Lattner int64_t DesiredMaskS) { 4831755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 4832755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 4833755480681c795d585c73556c028b6143c46bda86Chris Lattner 4834755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 4835755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 4836755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4837755480681c795d585c73556c028b6143c46bda86Chris Lattner 4838755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 4839755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 4840755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4841755480681c795d585c73556c028b6143c46bda86Chris Lattner 4842755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 4843755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 4844755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 4845755480681c795d585c73556c028b6143c46bda86Chris Lattner 4846755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t KnownZero, KnownOne; 4847755480681c795d585c73556c028b6143c46bda86Chris Lattner getTargetLowering().ComputeMaskedBits(LHS, NeededMask, KnownZero, KnownOne); 4848755480681c795d585c73556c028b6143c46bda86Chris Lattner 4849755480681c795d585c73556c028b6143c46bda86Chris Lattner // If all the missing bits in the or are already known to be set, match! 4850755480681c795d585c73556c028b6143c46bda86Chris Lattner if ((NeededMask & KnownOne) == NeededMask) 4851755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4852755480681c795d585c73556c028b6143c46bda86Chris Lattner 4853755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 4854755480681c795d585c73556c028b6143c46bda86Chris Lattner 4855755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 4856755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4857755480681c795d585c73556c028b6143c46bda86Chris Lattner} 4858755480681c795d585c73556c028b6143c46bda86Chris Lattner 48599ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 48600e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 48610e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 48620e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 48630e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 48640e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 48650e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 48660e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 48670e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 48680e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 48690e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 48700e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 48710e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 48720e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 48730e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 48740e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 48750e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 48760e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 48770e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 48780e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 48790e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 48800e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 48810e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 48820e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 48830e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 48840e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 4885832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Could not match memory address. Inline asm failure!\n"; 48860e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 48870e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 48880e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 48890e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 489036d439666c9f9f781d57dc2fd6d3cc80602fe095Chris Lattner Ops.push_back(DAG.getTargetConstant(4/*MEM*/ | (SelOps.size() << 3), 489136d439666c9f9f781d57dc2fd6d3cc80602fe095Chris Lattner MVT::i32)); 48920e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 48930e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 48940e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 48950e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 48960e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 48970e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 48980e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 48990e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 49000e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 4901