SelectionDAGISel.cpp revision fea997aac5773e936754de5436029c2a4fa1e930
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" 161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 17a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng#include "llvm/CodeGen/ScheduleDAG.h" 18adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Constants.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 2236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner#include "llvm/GlobalVariable.h" 23ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner#include "llvm/InlineAsm.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 2643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey#include "llvm/IntrinsicInst.h" 2744c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey#include "llvm/CodeGen/MachineModuleInfo.h" 281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 3037efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 32eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey#include "llvm/CodeGen/SchedulerRegistry.h" 331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 35fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 363f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner#include "llvm/Target/TargetAsmInfo.h" 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 42124729155d860a0850eb4ef2a7cea4145e13a057Vladimir Prus#include "llvm/Target/TargetOptions.h" 43495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 447c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 46a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 477e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 50da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 517944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 52a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 53a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 54a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 55a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 56a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 577944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 585e46a19ec848cd4fc9649bd5170c43d9e657668cChris Lattnerstatic const bool ViewISelDAGs = 0, ViewSchedDAGs = 0; 597944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 607944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 61eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 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. 1741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<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 = 24758092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner std::max((unsigned)TLI.getTargetData()->getTypeAlignmentPref(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 = 2848c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(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 3063c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a packed 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) { 3093c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner const PackedType *PTy = cast<PackedType>(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 3571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<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 }; 387f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 388f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// The comparison function for sorting Case values. 389f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 390f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman bool operator () (const Case& C1, const Case& C2) { 39147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer assert(isa<ConstantInt>(C1.first) && isa<ConstantInt>(C2.first)); 3928c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer return cast<const ConstantInt>(C1.first)->getSExtValue() < 3938c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer cast<const ConstantInt>(C2.first)->getSExtValue(); 394f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 395f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 396f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 3981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 3991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 4001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 4011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 4021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 403a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD; 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 405f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 406f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 407f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 40837efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGISel::JumpTable JT; 409f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 4111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 415edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 4179453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT(0,0,0,0), FuncInfo(funcinfo) { 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 420a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 421a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 422a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 423d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 424d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 425edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 426d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 427d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 428d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 429d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 430d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 431d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 432d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 433d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 434bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, 435bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &PendingLoads[0], PendingLoads.size()); 436d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 437d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 438d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 439a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 440a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 441571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand CopyValueToVirtualRegister(Value *V, unsigned Reg); 442571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 4431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4461e7aa5c209109d07af30c8a2e9bfd82cf3824246Chris Lattner // Note: this doesn't use InstVisitor, because it has to work with 4471e7aa5c209109d07af30c8a2e9bfd82cf3824246Chris Lattner // ConstantExpr's in addition to instructions. 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 46028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 461466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 46228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile); 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 4651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 468199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4754e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 476864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue GetRegistersForValue(const std::string &ConstrCode, 477864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, 478864635ad7b3046d3042311423071152c613961deChris Lattner bool OutReg, bool InReg, 479864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 480864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &InputRegs); 481f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 482571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void FindMergedConditions(Value *Cond, MachineBasicBlock *TBB, 483571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, MachineBasicBlock *CurBB, 484571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc); 4858c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner bool isExportableFromCurrentBlock(Value *V, const BasicBlock *FromBB); 486571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void ExportFromCurrentBlock(Value *V); 487571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 4901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 491f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 4921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 4931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 494f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Helper for visitSwitch 495f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 49637efe6764568a3829fee26aba532283131d1a104Nate Begeman void visitJumpTable(SelectionDAGISel::JumpTable &JT); 497f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 4991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 5001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 5011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 50224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitScalarBinary(User &I, unsigned OpCode); 50324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitVectorBinary(User &I, unsigned OpCode); 50424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitEitherBinary(User &I, unsigned ScalarOp, unsigned VectorOp); 505e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 5065fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 50724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer if (isa<PackedType>(I.getType())) 50824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, ISD::VADD); 50924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer else if (I.getType()->isFloatingPoint()) 51024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::FADD); 5111628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 51224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::ADD); 51301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 514b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 5151628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitMul(User &I) { 51624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer if (isa<PackedType>(I.getType())) 51724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, ISD::VMUL); 51824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer else if (I.getType()->isFloatingPoint()) 51924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::FMUL); 5201628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 52124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::MUL); 5221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 52324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitURem(User &I) { visitScalarBinary(I, ISD::UREM); } 52424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitSRem(User &I) { visitScalarBinary(I, ISD::SREM); } 52524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitFRem(User &I) { visitScalarBinary(I, ISD::FREM); } 52624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitUDiv(User &I) { visitEitherBinary(I, ISD::UDIV, ISD::VUDIV); } 52724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitSDiv(User &I) { visitEitherBinary(I, ISD::SDIV, ISD::VSDIV); } 52824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitFDiv(User &I) { visitEitherBinary(I, ISD::FDIV, ISD::VSDIV); } 52924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitAnd (User &I) { visitEitherBinary(I, ISD::AND, ISD::VAND ); } 53024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitOr (User &I) { visitEitherBinary(I, ISD::OR, ISD::VOR ); } 53124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitXor (User &I) { visitEitherBinary(I, ISD::XOR, ISD::VXOR ); } 53224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitShl (User &I) { visitShift(I, ISD::SHL); } 5333822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer void visitLShr(User &I) { visitShift(I, ISD::SRL); } 5343822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer void visitAShr(User &I) { visitShift(I, ISD::SRA); } 53545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer void visitICmp(User &I); 53645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer void visitFCmp(User &I); 5373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Visit the conversion instructions 5383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitTrunc(User &I); 5393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitZExt(User &I); 5403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitSExt(User &I); 5413da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPTrunc(User &I); 5423da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPExt(User &I); 5433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPToUI(User &I); 5443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPToSI(User &I); 5453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitUIToFP(User &I); 5463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitSIToFP(User &I); 5473da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitPtrToInt(User &I); 5483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitIntToPtr(User &I); 5493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitBitCast(User &I); 5501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5512bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5522bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 5533e104b11168da4692b69cc6b236c1da22adff959Chris Lattner void visitShuffleVector(User &I); 554c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 565ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner void visitInlineAsm(CallInst &I); 566c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 5670eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 5681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 5701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 5711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 5731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5747041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 5751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 5771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 5781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 5811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 5821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 5851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 5861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 587199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 588199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 589199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 590199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 591199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 592199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 593199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 594199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 595199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 596199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 597199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 598199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 599199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 600199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 601199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 602199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 60323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner if (!isa<PackedType>(VTy)) 60423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 60523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 606b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR of undef nodes. 60723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner const PackedType *PTy = cast<PackedType>(VTy); 60823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 60923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 61023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 611bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 61223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 61323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 61423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 61523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 61623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 617bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, 618bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 619199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 620199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 621199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (const PackedType *PTy = dyn_cast<PackedType>(VTy)) { 622199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 623199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 624199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 625199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 626199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 627199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // the packed constant. 628bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 629199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) { 6302bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 6312bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 632199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 633199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 634199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 635199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 636199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 637199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 638199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 639199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 640199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 641199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 642b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR node with generic Vector type. 64323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 64423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 645bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR,MVT::Vector,&Ops[0],Ops.size()); 646199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 647199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 6486b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng return N = DAG.getConstant(cast<ConstantInt>(C)->getZExtValue(),VT); 649199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 650199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 651199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 652199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 653199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 654199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 655199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 656199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 657199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 658199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 659199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 660199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.ValueMap.find(V); 661199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 662199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 663199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned InReg = VMI->second; 664199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 665199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // If this type is not legal, make it so now. 66670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) { 6679f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (TLI.getTypeAction(VT) == TargetLowering::Expand) { 66870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Source must be expanded. This input value is actually coming from the 66970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // register pair VMI->second and VMI->second+1. 6709f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType DestVT = TLI.getTypeToExpandTo(VT); 6719f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = TLI.getNumElements(VT); 6729f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 6739f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (NumVals == 1) 6749f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getNode(ISD::BIT_CONVERT, VT, N); 6759f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng else { 6769f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng assert(NumVals == 2 && "1 to 4 (and more) expansion not implemented!"); 6779f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 6789f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 6799f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng } 6809f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng } else { 6819f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 6829f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 6839f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (TLI.getTypeAction(VT) == TargetLowering::Promote) // Promotion case 6849f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng N = MVT::isFloatingPoint(VT) 6859f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng ? DAG.getNode(ISD::FP_ROUND, VT, N) 6869f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng : DAG.getNode(ISD::TRUNCATE, VT, N); 687199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 68870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 68970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Otherwise, if this is a vector, make it available as a generic vector 69070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // here. 69170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 6922e2ef9535070bb352601482cceac1140c1158cddChris Lattner const PackedType *PTy = cast<PackedType>(VTy); 6932e2ef9535070bb352601482cceac1140c1158cddChris Lattner unsigned NE = TLI.getPackedTypeBreakdown(PTy, PTyElementVT, 69470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyLegalElementVT); 69570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 69670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Build a VBUILD_VECTOR with the input registers. 697bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 69870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 69970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the value types are legal, just VBUILD the CopyFromReg nodes. 70070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) 70170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 70270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT)); 70370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyElementVT < PTyLegalElementVT) { 70470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was promoted, use TRUNCATE of FP_ROUND as appropriate. 70570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 70670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 70770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 70870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyElementVT)) 70970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::FP_ROUND, PTyElementVT, Op); 71070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 71170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::TRUNCATE, PTyElementVT, Op); 71270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(Op); 71370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 71470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 71570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was expanded, use BUILD_PAIR. 71670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner assert((NE & 1) == 0 && "Must expand into a multiple of 2 elements!"); 71770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE/2; ++i) { 71870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op0 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 71970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 72070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op1 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 72170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 72270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Op0, Op1)); 72370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 72470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 72570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 72670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getConstant(NE, MVT::i32)); 72770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getValueType(PTyLegalElementVT)); 728bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, &Ops[0], Ops.size()); 7292e2ef9535070bb352601482cceac1140c1158cddChris Lattner 7302e2ef9535070bb352601482cceac1140c1158cddChris Lattner // Finally, use a VBIT_CONVERT to make this available as the appropriate 7312e2ef9535070bb352601482cceac1140c1158cddChris Lattner // vector type. 7322e2ef9535070bb352601482cceac1140c1158cddChris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 7332e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getConstant(PTy->getNumElements(), 7342e2ef9535070bb352601482cceac1140c1158cddChris Lattner MVT::i32), 7352e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getValueType(TLI.getValueType(PTy->getElementType()))); 736199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 737199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 738199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 739199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 740199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 741199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 7421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 7431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 744a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 7451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 7461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 747bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> NewValues; 748ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 749ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 750ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 751ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman 752ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // If this is an integer return value, we need to promote it ourselves to 753ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // the full width of a register, since LegalizeOp will use ANY_EXTEND rather 754ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // than sign/zero. 7558e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // FIXME: C calling convention requires the return type to be promoted to 7568e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // at least 32-bit. But this is not necessary for non-C calling conventions. 757ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (MVT::isInteger(RetOp.getValueType()) && 758ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp.getValueType() < MVT::i64) { 759ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman MVT::ValueType TmpVT; 760ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 761ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = TLI.getTypeToTransformTo(MVT::i32); 762ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 763ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = MVT::i32; 76447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer const FunctionType *FTy = I.getParent()->getParent()->getFunctionType(); 765bcca3405bd6698af82eeed20e24744d0625aa1b3Reid Spencer ISD::NodeType ExtendKind = ISD::ANY_EXTEND; 7668c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer if (FTy->paramHasAttr(0, FunctionType::SExtAttribute)) 7678c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer ExtendKind = ISD::SIGN_EXTEND; 76847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer if (FTy->paramHasAttr(0, FunctionType::ZExtAttribute)) 76947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ExtendKind = ISD::ZERO_EXTEND; 770376dd212f9142cd0f0b03e0b6296b2df7208bb9aReid Spencer RetOp = DAG.getNode(ExtendKind, TmpVT, RetOp); 771ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 772ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(RetOp); 77347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer NewValues.push_back(DAG.getConstant(false, MVT::i32)); 7741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 775bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, 776bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &NewValues[0], NewValues.size())); 7771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 779571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// ExportFromCurrentBlock - If this condition isn't known to be exported from 780571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// the current basic block, add it to ValueMap now so that we'll get a 781571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// CopyTo/FromReg. 782571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::ExportFromCurrentBlock(Value *V) { 783571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // No need to export constants. 784571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (!isa<Instruction>(V) && !isa<Argument>(V)) return; 785571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 786571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Already exported? 787571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (FuncInfo.isExportedInst(V)) return; 788571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 789571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg = FuncInfo.InitializeRegForValue(V); 790571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner PendingLoads.push_back(CopyValueToVirtualRegister(V, Reg)); 791571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 792571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 7938c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattnerbool SelectionDAGLowering::isExportableFromCurrentBlock(Value *V, 7948c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner const BasicBlock *FromBB) { 7958c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // The operands of the setcc have to be in this block. We don't know 7968c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // how to export them from some other block. 7978c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Instruction *VI = dyn_cast<Instruction>(V)) { 7988c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Can export from current BB. 7998c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (VI->getParent() == FromBB) 8008c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 8018c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8028c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Is already exported, noop. 8038c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return FuncInfo.isExportedInst(V); 8048c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 8058c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8068c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // If this is an argument, we can export it if the BB is the entry block or 8078c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // if it is already exported. 8088c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (isa<Argument>(V)) { 8098c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (FromBB == &FromBB->getParent()->getEntryBlock()) 8108c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 8118c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8128c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Otherwise, can only export this if it is already exported. 8138c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return FuncInfo.isExportedInst(V); 8148c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 8158c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8168c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Otherwise, constants can always be exported. 8178c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 8188c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner} 8198c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 8206a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattnerstatic bool InBlock(const Value *V, const BasicBlock *BB) { 8216a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner if (const Instruction *I = dyn_cast<Instruction>(V)) 8226a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner return I->getParent() == BB; 8236a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner return true; 8246a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner} 8256a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner 826571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// FindMergedConditions - If Cond is an expression like 827571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::FindMergedConditions(Value *Cond, 828571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TBB, 829571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, 830571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *CurBB, 831571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc) { 832571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this node is not part of the or/and tree, emit it as a branch. 833e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Instruction *BOp = dyn_cast<Instruction>(Cond); 834571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 835e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) || 836e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() || 8376a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner BOp->getParent() != CurBB->getBasicBlock() || 8386a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) || 8396a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) { 840571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner const BasicBlock *BB = CurBB->getBasicBlock(); 841571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 842e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // If the leaf of the tree is a comparison, merge the condition into 843e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // the caseblock. 844e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if ((isa<ICmpInst>(Cond) || isa<FCmpInst>(Cond)) && 845e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // The operands of the cmp have to be in this block. We don't know 8465a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner // how to export them from some other block. If this is the first block 8475a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner // of the sequence, no exporting is needed. 8485a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner (CurBB == CurMBB || 8495a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner (isExportableFromCurrentBlock(BOp->getOperand(0), BB) && 8505a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner isExportableFromCurrentBlock(BOp->getOperand(1), BB)))) { 851e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer BOp = cast<Instruction>(Cond); 852e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode Condition; 853e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *IC = dyn_cast<ICmpInst>(Cond)) { 854e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (IC->getPredicate()) { 855e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: assert(0 && "Unknown icmp predicate opcode!"); 856e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_EQ: Condition = ISD::SETEQ; break; 857e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_NE: Condition = ISD::SETNE; break; 858e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLE: Condition = ISD::SETLE; break; 859e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULE: Condition = ISD::SETULE; break; 860e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGE: Condition = ISD::SETGE; break; 861e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGE: Condition = ISD::SETUGE; break; 862e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLT: Condition = ISD::SETLT; break; 863e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULT: Condition = ISD::SETULT; break; 864e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGT: Condition = ISD::SETGT; break; 865e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGT: Condition = ISD::SETUGT; break; 866e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 867e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else if (FCmpInst *FC = dyn_cast<FCmpInst>(Cond)) { 868e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode FPC, FOC; 869e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (FC->getPredicate()) { 870e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: assert(0 && "Unknown fcmp predicate opcode!"); 871e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: FOC = FPC = ISD::SETFALSE; break; 872e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OEQ: FOC = ISD::SETEQ; FPC = ISD::SETOEQ; break; 873e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGT: FOC = ISD::SETGT; FPC = ISD::SETOGT; break; 874e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGE: FOC = ISD::SETGE; FPC = ISD::SETOGE; break; 875e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLT: FOC = ISD::SETLT; FPC = ISD::SETOLT; break; 876e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLE: FOC = ISD::SETLE; FPC = ISD::SETOLE; break; 877e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ONE: FOC = ISD::SETNE; FPC = ISD::SETONE; break; 878e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ORD: FOC = ISD::SETEQ; FPC = ISD::SETO; break; 879e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNO: FOC = ISD::SETNE; FPC = ISD::SETUO; break; 880e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UEQ: FOC = ISD::SETEQ; FPC = ISD::SETUEQ; break; 881e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGT: FOC = ISD::SETGT; FPC = ISD::SETUGT; break; 882e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGE: FOC = ISD::SETGE; FPC = ISD::SETUGE; break; 883e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULT: FOC = ISD::SETLT; FPC = ISD::SETULT; break; 884e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULE: FOC = ISD::SETLE; FPC = ISD::SETULE; break; 885e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNE: FOC = ISD::SETNE; FPC = ISD::SETUNE; break; 886e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: FOC = FPC = ISD::SETTRUE; break; 887e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 888e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FiniteOnlyFPMath()) 889e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FOC; 890e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else 891e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FPC; 892e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else { 893e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer assert(0 && "Unknown compare instruction"); 894571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 895571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 896571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SelectionDAGISel::CaseBlock CB(Condition, BOp->getOperand(0), 897571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOperand(1), TBB, FBB, CurBB); 898571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 899571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 900571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 901571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 902571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Create a CaseBlock record representing this branch. 9036b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng SelectionDAGISel::CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(), 904571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner TBB, FBB, CurBB); 905571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 906571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 907571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 908571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 909d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 910d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Create TmpBB after CurBB. 911571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineFunction::iterator BBI = CurBB; 912571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TmpBB = new MachineBasicBlock(CurBB->getBasicBlock()); 913571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner CurBB->getParent()->getBasicBlockList().insert(++BBI, TmpBB); 914571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 915d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner if (Opc == Instruction::Or) { 916d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X | Y as: 917d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TBB 918d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp TmpBB 919d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 920d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 921d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 922d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 923571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 924d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 925d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, Opc); 926d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 927d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 928d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 929d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } else { 930d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner assert(Opc == Instruction::And && "Unknown merge op!"); 931d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X & Y as: 932d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TmpBB 933d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 934d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 935d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 936d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 937d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 938d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // This requires creation of TmpBB after CurBB. 939d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 940d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 941d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, Opc); 942d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 943d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 944d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 945d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } 946571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 947571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 948df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// If the set of cases should be emitted as a series of branches, return true. 949df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// If we should emit this as a bunch of and/or'd together conditions, return 950df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// false. 951df19f27d039fd791c73e39f4134319debc75db4fChris Lattnerstatic bool 952df19f27d039fd791c73e39f4134319debc75db4fChris LattnerShouldEmitAsBranches(const std::vector<SelectionDAGISel::CaseBlock> &Cases) { 953df19f27d039fd791c73e39f4134319debc75db4fChris Lattner if (Cases.size() != 2) return true; 954df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 9550ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // If this is two comparisons of the same values or'd or and'd together, they 9560ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // will get folded into a single comparison, so don't emit two blocks. 9570ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner if ((Cases[0].CmpLHS == Cases[1].CmpLHS && 9580ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner Cases[0].CmpRHS == Cases[1].CmpRHS) || 9590ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner (Cases[0].CmpRHS == Cases[1].CmpLHS && 9600ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner Cases[0].CmpLHS == Cases[1].CmpRHS)) { 9610ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner return false; 9620ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner } 9630ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 964df19f27d039fd791c73e39f4134319debc75db4fChris Lattner return true; 965df19f27d039fd791c73e39f4134319debc75db4fChris Lattner} 966df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 9671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 9681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 9691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 9701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 9721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 9731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 9741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 9751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 9761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 9781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 9791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 980a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 981dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 98257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 98357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // Update machine-CFG edges. 98457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(Succ0MBB); 98557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 98657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner return; 98757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner } 98857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 98957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // If this condition is one of the special cases we handle, do special stuff 99057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // now. 99157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Value *CondVal = I.getCondition(); 99257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 993571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 994571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this is a series of conditions that are or'd or and'd together, emit 995571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // this as a sequence of branches instead of setcc's with and/or operations. 996571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // For example, instead of something like: 997571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 998571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // C = seteq 999571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 1000571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // F = setle 1001571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // or C, F 1002571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jnz foo 1003571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Emit: 1004571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 1005571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // je foo 1006571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 1007571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jle foo 1008571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // 1009571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) { 1010571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BOp->hasOneUse() && 1011d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner (BOp->getOpcode() == Instruction::And || 1012571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOpcode() == Instruction::Or)) { 1013571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FindMergedConditions(BOp, Succ0MBB, Succ1MBB, CurMBB, BOp->getOpcode()); 10140ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // If the compares in later blocks need to use values not currently 10150ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // exported from this block, export them now. This block should always 10160ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // be the first entry. 10170ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner assert(SwitchCases[0].ThisBB == CurMBB && "Unexpected lowering!"); 10180ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1019df19f27d039fd791c73e39f4134319debc75db4fChris Lattner // Allow some cases to be rejected. 1020df19f27d039fd791c73e39f4134319debc75db4fChris Lattner if (ShouldEmitAsBranches(SwitchCases)) { 1021df19f27d039fd791c73e39f4134319debc75db4fChris Lattner for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) { 1022df19f27d039fd791c73e39f4134319debc75db4fChris Lattner ExportFromCurrentBlock(SwitchCases[i].CmpLHS); 1023df19f27d039fd791c73e39f4134319debc75db4fChris Lattner ExportFromCurrentBlock(SwitchCases[i].CmpRHS); 1024df19f27d039fd791c73e39f4134319debc75db4fChris Lattner } 1025df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 1026df19f27d039fd791c73e39f4134319debc75db4fChris Lattner // Emit the branch for this block. 1027df19f27d039fd791c73e39f4134319debc75db4fChris Lattner visitSwitchCase(SwitchCases[0]); 1028df19f27d039fd791c73e39f4134319debc75db4fChris Lattner SwitchCases.erase(SwitchCases.begin()); 1029df19f27d039fd791c73e39f4134319debc75db4fChris Lattner return; 10305a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner } 10315a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner 10320ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // Okay, we decided not to do this, remove any inserted MBB's and clear 10330ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // SwitchCases. 10340ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) 10350ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner CurMBB->getParent()->getBasicBlockList().erase(SwitchCases[i].ThisBB); 10360ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1037df19f27d039fd791c73e39f4134319debc75db4fChris Lattner SwitchCases.clear(); 1038571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 1039571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 10402452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner 10412452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Create a CaseBlock record representing this branch. 10426b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng SelectionDAGISel::CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(), 10432452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner Succ0MBB, Succ1MBB, CurMBB); 10442452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Use visitSwitchCase to actually insert the fast branch sequence for this 10452452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // cond branch. 10462452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner visitSwitchCase(CB); 10471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1049f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 1050f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 1051f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 105257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand Cond; 105357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand CondLHS = getValue(CB.CmpLHS); 105457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 1055571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Build the setcc now, fold "(X == true)" to X and "(X == false)" to !X to 1056571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // handle common cases produced by branch lowering. 10576b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng if (CB.CmpRHS == ConstantInt::getTrue() && CB.CC == ISD::SETEQ) 105857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Cond = CondLHS; 10596b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng else if (CB.CmpRHS == ConstantInt::getFalse() && CB.CC == ISD::SETEQ) { 1060571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand True = DAG.getConstant(1, CondLHS.getValueType()); 1061571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Cond = DAG.getNode(ISD::XOR, CondLHS.getValueType(), CondLHS, True); 1062571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } else 1063571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Cond = DAG.getSetCC(MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC); 1064f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1065f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 1066f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 1067f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1068f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1069f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 1070f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 1071f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1072f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 1073f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 107457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.TrueBB == NextBlock) { 107557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner std::swap(CB.TrueBB, CB.FalseBB); 1076f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 1077f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 1078f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1079f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 108057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.TrueBB)); 108157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.FalseBB == NextBlock) 1082f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 1083f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 1084f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 108557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.FalseBB))); 1086f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 108757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.TrueBB); 108857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.FalseBB); 1089f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1090f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 109137efe6764568a3829fee26aba532283131d1a104Nate Begemanvoid SelectionDAGLowering::visitJumpTable(SelectionDAGISel::JumpTable &JT) { 109237efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code for the jump table 109337efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType PTy = TLI.getPointerTy(); 10943d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng SDOperand Index = DAG.getCopyFromReg(getRoot(), JT.Reg, PTy); 10953d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng SDOperand Table = DAG.getJumpTable(JT.JTI, PTy); 10963d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng DAG.setRoot(DAG.getNode(ISD::BR_JT, MVT::Other, Index.getValue(1), 10973d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Table, Index)); 10983d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng return; 109937efe6764568a3829fee26aba532283131d1a104Nate Begeman} 110037efe6764568a3829fee26aba532283131d1a104Nate Begeman 1101f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitch(SwitchInst &I) { 1102f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 1103f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1104f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1105c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1106f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 1107f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 1108f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1109d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *Default = FuncInfo.MBBMap[I.getDefaultDest()]; 1110d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1111f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 1112f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 1113f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (I.getNumOperands() == 2) { 1114f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 1115c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1116f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 1117d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (Default != NextBlock) 1118f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1119d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner DAG.getBasicBlock(Default))); 1120c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1121d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurMBB->addSuccessor(Default); 1122f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 1123f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1124f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1125f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 1126f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 1127f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 1128f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<Case> Cases; 1129c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1130f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 1; i < I.getNumSuccessors(); ++i) { 1131f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *SMBB = FuncInfo.MBBMap[I.getSuccessor(i)]; 1132f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cases.push_back(Case(I.getSuccessorValue(i), SMBB)); 1133f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1134c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1135f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::sort(Cases.begin(), Cases.end(), CaseCmp()); 1136f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1137f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 1138f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 1139f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 1140f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Value *SV = I.getOperand(0); 114137efe6764568a3829fee26aba532283131d1a104Nate Begeman 114237efe6764568a3829fee26aba532283131d1a104Nate Begeman // Get the MachineFunction which holds the current MBB. This is used during 114337efe6764568a3829fee26aba532283131d1a104Nate Begeman // emission of jump tables, and when inserting any additional MBBs necessary 114437efe6764568a3829fee26aba532283131d1a104Nate Begeman // to represent the switch. 1145f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction *CurMF = CurMBB->getParent(); 1146f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const BasicBlock *LLVMBB = CurMBB->getBasicBlock(); 1147d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1148d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // If the switch has few cases (two or less) emit a series of specific 1149d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // tests. 1150b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (Cases.size() < 3) { 1151d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // TODO: If any two of the cases has the same destination, and if one value 1152d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // is the same as the other, but has one bit unset that the other has set, 1153d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // use bit manipulation to do two compares at once. For example: 1154d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // "if (X == 6 || X == 4)" -> "if ((X|2) == 6)" 1155d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1156b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner // Rearrange the case blocks so that the last one falls through if possible. 1157b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner if (NextBlock && Default != NextBlock && Cases.back().second != NextBlock) { 1158b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner // The last case block won't fall through into 'NextBlock' if we emit the 1159b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner // branches in this order. See if rearranging a case value would help. 1160b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner for (unsigned i = 0, e = Cases.size()-1; i != e; ++i) { 1161b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner if (Cases[i].second == NextBlock) { 1162b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner std::swap(Cases[i], Cases.back()); 1163b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner break; 1164b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner } 1165b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner } 1166b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner } 1167b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner 1168d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // Create a CaseBlock record representing a conditional branch to 1169d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // the Case's target mbb if the value being switched on SV is equal 1170d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // to C. 1171d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *CurBlock = CurMBB; 1172d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner for (unsigned i = 0, e = Cases.size(); i != e; ++i) { 1173d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *FallThrough; 1174d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (i != e-1) { 1175d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner FallThrough = new MachineBasicBlock(CurMBB->getBasicBlock()); 1176d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurMF->getBasicBlockList().insert(BBI, FallThrough); 1177d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } else { 1178d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // If the last case doesn't match, go to the default block. 1179d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner FallThrough = Default; 1180d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } 1181d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1182d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, Cases[i].first, 1183d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner Cases[i].second, FallThrough, CurBlock); 1184d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1185d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // If emitting the first comparison, just call visitSwitchCase to emit the 1186d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // code into the current block. Otherwise, push the CaseBlock onto the 1187d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // vector to be later processed by SDISel, and insert the node's MBB 1188d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // before the next MBB. 1189d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (CurBlock == CurMBB) 1190d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner visitSwitchCase(CB); 1191d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner else 1192d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner SwitchCases.push_back(CB); 1193d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1194d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurBlock = FallThrough; 1195d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } 1196d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner return; 1197d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } 119837efe6764568a3829fee26aba532283131d1a104Nate Begeman 119917c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // If the switch has more than 5 blocks, and at least 31.25% dense, and the 120017c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // target supports indirect branches, then emit a jump table rather than 120117c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // lowering the switch to a binary tree of conditional branches. 12023d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng if ((TLI.isOperationLegal(ISD::BR_JT, MVT::Other) || 12033d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng TLI.isOperationLegal(ISD::BRIND, MVT::Other)) && 1204f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman Cases.size() > 5) { 12056b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng uint64_t First =cast<ConstantInt>(Cases.front().first)->getZExtValue(); 12066b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng uint64_t Last = cast<ConstantInt>(Cases.back().first)->getZExtValue(); 1207f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman double Density = (double)Cases.size() / (double)((Last - First) + 1ULL); 1208f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 120917c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman if (Density >= 0.3125) { 121037efe6764568a3829fee26aba532283131d1a104Nate Begeman // Create a new basic block to hold the code for loading the address 121137efe6764568a3829fee26aba532283131d1a104Nate Begeman // of the jump table, and jumping to it. Update successor information; 121237efe6764568a3829fee26aba532283131d1a104Nate Begeman // we will either branch to the default case for the switch, or the jump 121337efe6764568a3829fee26aba532283131d1a104Nate Begeman // table. 121437efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *JumpTableBB = new MachineBasicBlock(LLVMBB); 121537efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMF->getBasicBlockList().insert(BBI, JumpTableBB); 121637efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(Default); 121737efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(JumpTableBB); 121837efe6764568a3829fee26aba532283131d1a104Nate Begeman 121937efe6764568a3829fee26aba532283131d1a104Nate Begeman // Subtract the lowest switch case value from the value being switched on 122037efe6764568a3829fee26aba532283131d1a104Nate Begeman // and conditional branch to default mbb if the result is greater than the 122137efe6764568a3829fee26aba532283131d1a104Nate Begeman // difference between smallest and largest cases. 122237efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SwitchOp = getValue(SV); 122337efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType VT = SwitchOp.getValueType(); 122437efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 122537efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(First, VT)); 122637efe6764568a3829fee26aba532283131d1a104Nate Begeman 122737efe6764568a3829fee26aba532283131d1a104Nate Begeman // The SDNode we just created, which holds the value being switched on 122837efe6764568a3829fee26aba532283131d1a104Nate Begeman // minus the the smallest case value, needs to be copied to a virtual 122937efe6764568a3829fee26aba532283131d1a104Nate Begeman // register so it can be used as an index into the jump table in a 123037efe6764568a3829fee26aba532283131d1a104Nate Begeman // subsequent basic block. This value may be smaller or larger than the 123137efe6764568a3829fee26aba532283131d1a104Nate Begeman // target's pointer type, and therefore require extension or truncating. 123237efe6764568a3829fee26aba532283131d1a104Nate Begeman if (VT > TLI.getPointerTy()) 123337efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::TRUNCATE, TLI.getPointerTy(), SUB); 123437efe6764568a3829fee26aba532283131d1a104Nate Begeman else 123537efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), SUB); 1236c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 123737efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JumpTableReg = FuncInfo.MakeReg(TLI.getPointerTy()); 123837efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CopyTo = DAG.getCopyToReg(getRoot(), JumpTableReg, SwitchOp); 123937efe6764568a3829fee26aba532283131d1a104Nate Begeman 124037efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the range check for the jump table, and branch to the default 124137efe6764568a3829fee26aba532283131d1a104Nate Begeman // block for the switch statement if the value being switched on exceeds 124237efe6764568a3829fee26aba532283131d1a104Nate Begeman // the largest case in the switch. 124337efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CMP = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 124437efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(Last-First,VT), ISD::SETUGT); 124537efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, CMP, 124637efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getBasicBlock(Default))); 124737efe6764568a3829fee26aba532283131d1a104Nate Begeman 1248f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Build a vector of destination BBs, corresponding to each target 1249f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // of the jump table. If the value of the jump table slot corresponds to 1250f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // a case statement, push the case's BB onto the vector, otherwise, push 1251f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // the default BB. 125237efe6764568a3829fee26aba532283131d1a104Nate Begeman std::vector<MachineBasicBlock*> DestBBs; 1253f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman uint64_t TEI = First; 1254c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling for (CaseItr ii = Cases.begin(), ee = Cases.end(); ii != ee; ++TEI) 12556b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng if (cast<ConstantInt>(ii->first)->getZExtValue() == TEI) { 1256f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman DestBBs.push_back(ii->second); 1257f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman ++ii; 1258f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } else { 1259f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman DestBBs.push_back(Default); 1260f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 1261f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 12628c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Update successor info. Add one edge to each unique successor. 12638c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Vector bool would be better, but vector<bool> is really slow. 12648c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner std::vector<unsigned char> SuccsHandled; 12658c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled.resize(CurMBB->getParent()->getNumBlockIDs()); 12668c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 1267c66764c00756d800aede2fd32d55658a236b1912Chris Lattner for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(), 12688c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner E = DestBBs.end(); I != E; ++I) { 12698c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (!SuccsHandled[(*I)->getNumber()]) { 12708c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled[(*I)->getNumber()] = true; 12718c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner JumpTableBB->addSuccessor(*I); 12728c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 12738c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 1274f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 1275f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Create a jump table index for this jump table, or return an existing 1276f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // one. 127737efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JTI = CurMF->getJumpTableInfo()->getJumpTableIndex(DestBBs); 127837efe6764568a3829fee26aba532283131d1a104Nate Begeman 127937efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the jump table information so that we can codegen it as a second 128037efe6764568a3829fee26aba532283131d1a104Nate Begeman // MachineBasicBlock 128137efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.Reg = JumpTableReg; 128237efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.JTI = JTI; 128337efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.MBB = JumpTableBB; 12849453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT.Default = Default; 128537efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 128637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 128737efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1288f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1289f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Push the initial CaseRec onto the worklist 1290f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<CaseRec> CaseVec; 1291f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 1292f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1293f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman while (!CaseVec.empty()) { 1294f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Grab a record representing a case range to process off the worklist 1295f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec CR = CaseVec.back(); 1296f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.pop_back(); 1297f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1298f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Size is the number of Cases represented by this range. If Size is 1, 1299f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // then we are processing a leaf of the binary search tree. Otherwise, 1300f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // we need to pick a pivot, and push left and right ranges onto the 1301f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // worklist. 1302f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman unsigned Size = CR.Range.second - CR.Range.first; 1303f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1304f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (Size == 1) { 1305f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1306f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the Case's target mbb if the value being switched on SV is equal 1307f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // to C. Otherwise, branch to default. 1308f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = CR.Range.first->first; 1309f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Target = CR.Range.first->second; 1310f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, C, Target, Default, 1311f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CR.CaseBB); 1312c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1313f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the MBB representing the leaf node is the current MBB, then just 1314f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // call visitSwitchCase to emit the code into the current block. 1315f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, push the CaseBlock onto the vector to be later processed 1316f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // by SDISel, and insert the node's MBB before the next MBB. 1317f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1318f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1319c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling else 1320f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1321f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1322f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // split case range at pivot 1323f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseItr Pivot = CR.Range.first + (Size / 2); 1324f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange LHSR(CR.Range.first, Pivot); 1325f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange RHSR(Pivot, CR.Range.second); 1326f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = Pivot->first; 132757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner MachineBasicBlock *FalseBB = 0, *TrueBB = 0; 1328c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1329f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // We know that we branch to the LHS if the Value being switched on is 1330f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // less than the Pivot value, C. We use this to optimize our binary 1331f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // tree a bit, by recognizing that if SV is greater than or equal to the 1332f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // LHS's Case Value, and that Case Value is exactly one less than the 1333f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Pivot's Value, then we can branch directly to the LHS's Target, 1334f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // rather than creating a leaf node for it. 1335f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((LHSR.second - LHSR.first) == 1 && 1336f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSR.first->first == CR.GE && 13376b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng cast<ConstantInt>(C)->getZExtValue() == 13386b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng (cast<ConstantInt>(CR.GE)->getZExtValue() + 1ULL)) { 133957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner TrueBB = LHSR.first->second; 1340f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 134157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner TrueBB = new MachineBasicBlock(LLVMBB); 134257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMF->getBasicBlockList().insert(BBI, TrueBB); 134357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CaseVec.push_back(CaseRec(TrueBB, C, CR.GE, LHSR)); 1344f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1345c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1346f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Similar to the optimization above, if the Value being switched on is 1347f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // known to be less than the Constant CR.LT, and the current Case Value 1348f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // is CR.LT - 1, then we can branch directly to the target block for 1349f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the current Case Value, rather than emitting a RHS leaf node for it. 1350f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((RHSR.second - RHSR.first) == 1 && CR.LT && 13516b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng cast<ConstantInt>(RHSR.first->first)->getZExtValue() == 13526b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng (cast<ConstantInt>(CR.LT)->getZExtValue() - 1ULL)) { 135357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner FalseBB = RHSR.first->second; 1354f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 135557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner FalseBB = new MachineBasicBlock(LLVMBB); 135657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMF->getBasicBlockList().insert(BBI, FalseBB); 135757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CaseVec.push_back(CaseRec(FalseBB,CR.LT,C,RHSR)); 1358f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1359c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1360f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1361f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the LHS node if the value being switched on SV is less than C. 1362f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, branch to LHS. 13638c57dfb1aea24132bd5b58c4ed4893ea967ba131Reid Spencer ISD::CondCode CC = ISD::SETLT; 136457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SelectionDAGISel::CaseBlock CB(CC, SV, C, TrueBB, FalseBB, CR.CaseBB); 1365c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1366f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1367f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1368c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling else 1369f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1370f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1371f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1374b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 1375b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 137624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer const Type *Ty = I.getType(); 137724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer if (isa<PackedType>(Ty)) { 137824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, ISD::VSUB); 137924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer } else if (Ty->isFloatingPoint()) { 138001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 138101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 138201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 138301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 138401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 138501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 138624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::FSUB); 13871628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer } else 138824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ISD::SUB); 1389b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 1390b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 139124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencervoid SelectionDAGLowering::visitScalarBinary(User &I, unsigned OpCode) { 13921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 13931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 139424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer 139524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer setValue(&I, DAG.getNode(OpCode, Op1.getValueType(), Op1, Op2)); 13961628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer} 13971628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 139824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencervoid 139924d6da5fedcf39891f7d8c5b031c01324b3db545Reid SpencerSelectionDAGLowering::visitVectorBinary(User &I, unsigned OpCode) { 140024d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer assert(isa<PackedType>(I.getType())); 140124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer const PackedType *Ty = cast<PackedType>(I.getType()); 140224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer SDOperand Typ = DAG.getValueType(TLI.getValueType(Ty->getElementType())); 140324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer 140424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer setValue(&I, DAG.getNode(OpCode, MVT::Vector, 140524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer getValue(I.getOperand(0)), 140624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer getValue(I.getOperand(1)), 140724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer DAG.getConstant(Ty->getNumElements(), MVT::i32), 140824d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer Typ)); 140924d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer} 14101628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 141124d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencervoid SelectionDAGLowering::visitEitherBinary(User &I, unsigned ScalarOp, 141224d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer unsigned VectorOp) { 141324d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer if (isa<PackedType>(I.getType())) 141424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitVectorBinary(I, VectorOp); 141524d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer else 141624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer visitScalarBinary(I, ScalarOp); 1417e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 14182c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1419e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 1420e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 1421e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 1422e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 1423e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 1424e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 14251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 14261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 14271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 142845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencervoid SelectionDAGLowering::visitICmp(User &I) { 1429e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE; 1430e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *IC = dyn_cast<ICmpInst>(&I)) 1431e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = IC->getPredicate(); 1432e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else if (ConstantExpr *IC = dyn_cast<ConstantExpr>(&I)) 1433e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = ICmpInst::Predicate(IC->getPredicate()); 1434e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 1435e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 143645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer ISD::CondCode Opcode; 1437e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 143845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_EQ : Opcode = ISD::SETEQ; break; 143945fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_NE : Opcode = ISD::SETNE; break; 144045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_UGT : Opcode = ISD::SETUGT; break; 144145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_UGE : Opcode = ISD::SETUGE; break; 144245fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_ULT : Opcode = ISD::SETULT; break; 144345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_ULE : Opcode = ISD::SETULE; break; 144445fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SGT : Opcode = ISD::SETGT; break; 144545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SGE : Opcode = ISD::SETGE; break; 144645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SLT : Opcode = ISD::SETLT; break; 144745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SLE : Opcode = ISD::SETLE; break; 144845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer default: 144945fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer assert(!"Invalid ICmp predicate value"); 145045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer Opcode = ISD::SETEQ; 145145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer break; 145245fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer } 145345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 145445fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer} 145545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer 145645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencervoid SelectionDAGLowering::visitFCmp(User &I) { 1457e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE; 1458e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FCmpInst *FC = dyn_cast<FCmpInst>(&I)) 1459e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = FC->getPredicate(); 1460e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else if (ConstantExpr *FC = dyn_cast<ConstantExpr>(&I)) 1461e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = FCmpInst::Predicate(FC->getPredicate()); 1462e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 1463e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 1464e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode Condition, FOC, FPC; 1465e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 1466e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: FOC = FPC = ISD::SETFALSE; break; 1467e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OEQ: FOC = ISD::SETEQ; FPC = ISD::SETOEQ; break; 1468e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGT: FOC = ISD::SETGT; FPC = ISD::SETOGT; break; 1469e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGE: FOC = ISD::SETGE; FPC = ISD::SETOGE; break; 1470e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLT: FOC = ISD::SETLT; FPC = ISD::SETOLT; break; 1471e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLE: FOC = ISD::SETLE; FPC = ISD::SETOLE; break; 1472e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ONE: FOC = ISD::SETNE; FPC = ISD::SETONE; break; 1473e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ORD: FOC = ISD::SETEQ; FPC = ISD::SETO; break; 1474e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNO: FOC = ISD::SETNE; FPC = ISD::SETUO; break; 1475e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UEQ: FOC = ISD::SETEQ; FPC = ISD::SETUEQ; break; 1476e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGT: FOC = ISD::SETGT; FPC = ISD::SETUGT; break; 1477e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGE: FOC = ISD::SETGE; FPC = ISD::SETUGE; break; 1478e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULT: FOC = ISD::SETLT; FPC = ISD::SETULT; break; 1479e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULE: FOC = ISD::SETLE; FPC = ISD::SETULE; break; 1480e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNE: FOC = ISD::SETNE; FPC = ISD::SETUNE; break; 1481e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: FOC = FPC = ISD::SETTRUE; break; 148245fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer default: 148345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer assert(!"Invalid FCmp predicate value"); 1484e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer FOC = FPC = ISD::SETFALSE; 148545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer break; 148645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer } 1487e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FiniteOnlyFPMath()) 1488e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FOC; 1489e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else 1490e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FPC; 1491e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Condition)); 14921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 14931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 14941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 14951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 14961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 14971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 1498b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner if (!isa<PackedType>(I.getType())) { 1499b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 1500b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner TrueVal, FalseVal)); 1501b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } else { 1502b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::VSELECT, MVT::Vector, Cond, TrueVal, FalseVal, 1503b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-2), 1504b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-1))); 1505b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } 15061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 15071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15083da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15093da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitTrunc(User &I) { 15103da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // TruncInst cannot be a no-op cast because sizeof(src) > sizeof(dest). 15113da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15123da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15133da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 15143da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15153da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15163da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitZExt(User &I) { 15173da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // ZExt cannot be a no-op cast because sizeof(src) < sizeof(dest). 15183da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // ZExt also can't be a cast to bool for same reason. So, nothing much to do 15193da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15213da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 15223da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15233da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15243da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitSExt(User &I) { 15253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // SExt cannot be a no-op cast because sizeof(src) < sizeof(dest). 15263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // SExt also can't be a cast to bool for same reason. So, nothing much to do 15273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 15303da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15313da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15323da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPTrunc(User &I) { 15333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPTrunc is never a no-op cast, no need to check 15343da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15353da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15363da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N)); 15373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPExt(User &I){ 15403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPTrunc is never a no-op cast, no need to check 15413da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15423da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 15443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPToUI(User &I) { 15473da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPToUI is never a no-op cast, no need to check 15483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15503da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 15513da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15523da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15533da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPToSI(User &I) { 15543da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPToSI is never a no-op cast, no need to check 15553da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15563da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15573da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 15583da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15593da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15603da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitUIToFP(User &I) { 15613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // UIToFP is never a no-op cast, no need to check 15623da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15633da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15643da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 15653da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15663da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15673da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitSIToFP(User &I){ 15683da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // UIToFP is never a no-op cast, no need to check 15693da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15703da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 15723da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 15743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitPtrToInt(User &I) { 15753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // What to do depends on the size of the integer and the size of the pointer. 15763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // We can either truncate, zero extend, or no-op, accordingly. 15771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 1578e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 157928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15803da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand Result; 15813da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (MVT::getSizeInBits(DestVT) < MVT::getSizeInBits(SrcVT)) 15823da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Result = DAG.getNode(ISD::TRUNCATE, DestVT, N); 15833da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 15843da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Note: ZERO_EXTEND can handle cases where the sizes are equal too 15853da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Result = DAG.getNode(ISD::ZERO_EXTEND, DestVT, N); 15863da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, Result); 15873da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15893da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitIntToPtr(User &I) { 15903da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // What to do depends on the size of the integer and the size of the pointer. 15913da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // We can either truncate, zero extend, or no-op, accordingly. 15923da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 15933da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType SrcVT = N.getValueType(); 15943da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 15953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (MVT::getSizeInBits(DestVT) < MVT::getSizeInBits(SrcVT)) 15963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 15973da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 15983da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Note: ZERO_EXTEND can handle cases where the sizes are equal too 15993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 16003da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16013da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 16023da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitBitCast(User &I) { 16033da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 16043da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 1605e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner if (DestVT == MVT::Vector) { 16063da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // This is a cast to a vector from something else. 16073da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Get information about the output vector. 1608e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 1609e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 1610e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N, 1611e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getConstant(DestTy->getNumElements(),MVT::i32), 1612e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getValueType(EltVT))); 16133da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return; 16143da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer } 16153da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType SrcVT = N.getValueType(); 16163da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (SrcVT == MVT::Vector) { 16173da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // This is a cast from a vctor to something else. 16183da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Get information about the input vector. 1619e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N)); 16203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return; 16211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 16223da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 16233da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // BitCast assures us that source and destination are the same size so this 16243da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // is either a BIT_CONVERT or a no-op. 16253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (DestVT != N.getValueType()) 16263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::BIT_CONVERT, DestVT, N)); // convert types 16273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 16283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, N); // noop cast. 16291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16312bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 1632c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1633c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 1634c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1635c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 1636c7029805ef35ce9805931067b841e6af11db382eChris Lattner 16372332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Num = *(InVec.Val->op_end()-2); 16382332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 16392332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner setValue(&I, DAG.getNode(ISD::VINSERT_VECTOR_ELT, MVT::Vector, 16402332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner InVec, InVal, InIdx, Num, Typ)); 1641c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 1642c7029805ef35ce9805931067b841e6af11db382eChris Lattner 16432bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 1644384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1645384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1646384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 1647384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 1648384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner setValue(&I, DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, 1649384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 1650384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 1651c7029805ef35ce9805931067b841e6af11db382eChris Lattner 16523e104b11168da4692b69cc6b236c1da22adff959Chris Lattnervoid SelectionDAGLowering::visitShuffleVector(User &I) { 16533e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V1 = getValue(I.getOperand(0)); 16543e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V2 = getValue(I.getOperand(1)); 16553e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Mask = getValue(I.getOperand(2)); 16563e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 16573e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Num = *(V1.Val->op_end()-2); 16583e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Typ = *(V2.Val->op_end()-1); 16593e104b11168da4692b69cc6b236c1da22adff959Chris Lattner setValue(&I, DAG.getNode(ISD::VVECTOR_SHUFFLE, MVT::Vector, 16603e104b11168da4692b69cc6b236c1da22adff959Chris Lattner V1, V2, Mask, Num, Typ)); 16613e104b11168da4692b69cc6b236c1da22adff959Chris Lattner} 16623e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 16633e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 16641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 16651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 16661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 16671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 16691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 16701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 1671c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 1672b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 16731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 16741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 1675a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t Offset = TD->getStructLayout(StTy)->MemberOffsets[Field]; 16761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 1677dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 16781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 16791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 16801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 16811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 16827c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 16837c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 16847c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 1685b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 168647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer uint64_t Offs = 16870d630d220414b02fed6873555bb46795a682174bEvan Cheng TD->getTypeSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 16887c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 16897c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 16907c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 16917c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 16927c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 1693a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 16947c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 16957c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 16967c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 16977c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 16987c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 169947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 17007c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 17017c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 17027c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 17037c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 17047c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 17057c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 17067c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 17077c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 17086b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 17091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 17107c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 17111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 17127c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 17137c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 17147c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 17157c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 17161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 17171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 17181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 17191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 17201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 17221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 17231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 17241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 17251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 17261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 1728a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 172958092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner unsigned Align = 173058092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner std::max((unsigned)TLI.getTargetData()->getTypeAlignmentPref(Ty), 173158092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner I.getAlignment()); 17321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 173468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 173568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 173668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 173768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 173868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 17391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 174068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 17411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 17421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 17441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 17451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 17461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 17471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 17481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 17491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 17501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 17511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 17521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 17531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 17541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 17551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 17561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 17571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 17581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1759bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[] = { getRoot(), AllocSize, getIntPtrConstant(Align) }; 1760f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTs = DAG.getNodeValueTypes(AllocSize.getValueType(), 1761f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner MVT::Other); 1762f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, 2, Ops, 3); 17631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 17641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 17661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 17671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 17681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 17691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 17701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 17711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 1772edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1773d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 1774d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 1775d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 1776d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 1777d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 1778d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 1779d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 178028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 1781466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng setValue(&I, getLoadFrom(I.getType(), Ptr, I.getOperand(0), 178228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner Root, I.isVolatile())); 178328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 178428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 178528b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 1786466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 178728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile) { 17885fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 17898cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 17904ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 1791466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng L = DAG.getVecLoad(PTy->getNumElements(), PVT, Root, Ptr, 1792466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng DAG.getSrcValue(SV)); 17935fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 17940b4f80ee898c1e85242482e4cb363e6bfe0a133bEvan Cheng L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SV, 0, isVolatile); 17955fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1796d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 179728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 1798d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 1799d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 1800d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 180128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 180228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 18031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 18041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 18051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 18061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 18071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 18081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 18091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 18100b4f80ee898c1e85242482e4cb363e6bfe0a133bEvan Cheng DAG.setRoot(DAG.getStore(getRoot(), Src, Ptr, I.getOperand(1), 0, 18118b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.isVolatile())); 18121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 18131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 18140eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// IntrinsicCannotAccessMemory - Return true if the specified intrinsic cannot 18150eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// access memory and has no other side effects at all. 18160eade319cdb72e24c11d068728a98083737c6435Chris Lattnerstatic bool IntrinsicCannotAccessMemory(unsigned IntrinsicID) { 18170eade319cdb72e24c11d068728a98083737c6435Chris Lattner#define GET_NO_MEMORY_INTRINSICS 18180eade319cdb72e24c11d068728a98083737c6435Chris Lattner#include "llvm/Intrinsics.gen" 18190eade319cdb72e24c11d068728a98083737c6435Chris Lattner#undef GET_NO_MEMORY_INTRINSICS 18200eade319cdb72e24c11d068728a98083737c6435Chris Lattner return false; 18210eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 18220eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1823e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// IntrinsicOnlyReadsMemory - Return true if the specified intrinsic doesn't 1824e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// have any side-effects or if it only reads memory. 1825e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattnerstatic bool IntrinsicOnlyReadsMemory(unsigned IntrinsicID) { 1826e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#define GET_SIDE_EFFECT_INFO 1827e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#include "llvm/Intrinsics.gen" 1828e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#undef GET_SIDE_EFFECT_INFO 1829e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner return false; 1830e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner} 1831e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner 18320eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 18330eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 18340eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 18350eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 18367255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner bool HasChain = !IntrinsicCannotAccessMemory(Intrinsic); 1837e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner bool OnlyLoad = HasChain && IntrinsicOnlyReadsMemory(Intrinsic); 18380eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18390eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 1840bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 1841e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { // If this intrinsic has side-effects, chainify it. 1842e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) { 1843e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner // We don't need to serialize loads against other loads. 1844e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(DAG.getRoot()); 1845e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } else { 1846e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(getRoot()); 1847e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 1848e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 18490eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18500eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 18510eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 18520eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18530eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 18540eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 18550eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 18560eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18570eade319cdb72e24c11d068728a98083737c6435Chris Lattner // If this is a vector type, force it to the right packed type. 18580eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (Op.getValueType() == MVT::Vector) { 18590eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *OpTy = cast<PackedType>(I.getOperand(i)->getType()); 18600eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType()); 18610eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18620eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VVT = MVT::getVectorType(EltVT, OpTy->getNumElements()); 18630eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VVT != MVT::Other && "Intrinsic uses a non-legal type?"); 18640eade319cdb72e24c11d068728a98083737c6435Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, VVT, Op); 18650eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 18660eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18670eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 18680eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 18690eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 18700eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 18710eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18720eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 18730eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 18740eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 18750eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (VT == MVT::Vector) { 18760eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 18770eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 18780eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18790eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 18800eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 18810eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 18820eade319cdb72e24c11d068728a98083737c6435Chris Lattner 18830eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 18840eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 18850eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 18860eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 18870eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 18880eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1889f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTList = DAG.getNodeValueTypes(VTs); 1890f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner 18910eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 189248b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 189348b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 1894f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTList, VTs.size(), 1895f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 189648b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 1897f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTList, VTs.size(), 1898f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 189948b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 1900f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTList, VTs.size(), 1901f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 190248b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 1903e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { 1904e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner SDOperand Chain = Result.getValue(Result.Val->getNumValues()-1); 1905e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) 1906e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner PendingLoads.push_back(Chain); 1907e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner else 1908e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner DAG.setRoot(Chain); 1909e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 19100eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 19110eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (const PackedType *PTy = dyn_cast<PackedType>(I.getType())) { 19120eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EVT = TLI.getValueType(PTy->getElementType()); 19130eade319cdb72e24c11d068728a98083737c6435Chris Lattner Result = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Result, 19140eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getConstant(PTy->getNumElements(), MVT::i32), 19150eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getValueType(EVT)); 19160eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 19170eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 19180eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 19190eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 19200eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1921c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 1922c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 1923c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 1924c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 1925c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 1926c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 19270eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 19280eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 19290eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 19300eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 1931c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 1932c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 1933c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 1934bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case Intrinsic::returnaddress: 1935bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman setValue(&I, DAG.getNode(ISD::RETURNADDR, TLI.getPointerTy(), 1936bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman getValue(I.getOperand(1)))); 1937bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman return 0; 1938bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case Intrinsic::frameaddress: 1939bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman setValue(&I, DAG.getNode(ISD::FRAMEADDR, TLI.getPointerTy(), 1940bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman getValue(I.getOperand(1)))); 1941bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman return 0; 1942c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 1943d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov return "_setjmp"+!TLI.usesUnderscoreSetJmp(); 1944c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 1945c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 1946d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov return "_longjmp"+!TLI.usesUnderscoreLongJmp(); 1947c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 194803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 194903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 195003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 195103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 195203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 195303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 195403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 195503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 195603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 195703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 195803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 195903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 1960c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 196186cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 196244c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 196343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 196444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && SPI.getContext() && MMI->Verify(SPI.getContext())) { 1965bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[5]; 196636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 1967bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[0] = getRoot(); 1968bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[1] = getValue(SPI.getLineValue()); 1969bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[2] = getValue(SPI.getColumnValue()); 1970ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 197144c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey DebugInfoDesc *DD = MMI->getDescFor(SPI.getContext()); 1972ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 197343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 197443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1975bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[3] = DAG.getString(CompileUnit->getFileName()); 1976bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[4] = DAG.getString(CompileUnit->getDirectory()); 1977ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 1978bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops, 5)); 197986cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 198043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1981b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 198236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 198343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 198444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 198543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 198644c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && RSI.getContext() && MMI->Verify(RSI.getContext())) { 198744c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionStart(RSI.getContext()); 19881ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 1989bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.getConstant(LabelID, MVT::i32))); 199043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 199143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1992b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 199343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 199443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 199544c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 199643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 199744c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && REI.getContext() && MMI->Verify(REI.getContext())) { 199844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionEnd(REI.getContext()); 19991ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, 2000bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 200143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 200243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2003b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 200443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 200543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 200644c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 200743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 200844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && FSI.getSubprogram() && 200944c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MMI->Verify(FSI.getSubprogram())) { 201044c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionStart(FSI.getSubprogram()); 20111ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, 2012bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 201343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 201443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2015b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 201643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 201743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 201844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 201943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 202044c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && DI.getVariable() && MMI->Verify(DI.getVariable())) { 20210892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey SDOperand AddressOp = getValue(DI.getAddress()); 2022bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(AddressOp)) 202344c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MMI->RecordVariable(DI.getVariable(), FI->getIndex()); 202443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 202543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 202643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 202743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 2028c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 20290b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 20300b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 2031c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 2032c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2033c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2034c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 20356ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f32: 20366ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f64: 20376ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner setValue(&I, DAG.getNode(ISD::FPOWI, 20386ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)).getValueType(), 20396ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)), 20406ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(2)))); 20416ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner return 0; 2042c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 2043c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2044c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 2045c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2046c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 20478b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 2048bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 2049f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, 2050f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::i64, MVT::Other), 2, 2051f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Op, 1); 20528b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 20538b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 205451b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 20558b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 2056d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 2057d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 2058d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 2059d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 2060d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 2061d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 2062d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 20630b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 20640b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 20650b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 20660b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 2067c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 2068c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2069c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2070c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 20710b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 20720b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 20730b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 20740b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 2075c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 2076c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2077c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2078c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 20790b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 20800b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 20810b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 20820b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 2083c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 2084c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2085c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2086c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2087140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 2088bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 2089f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, 2090f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(TLI.getPointerTy(), MVT::Other), 2, &Op, 1); 2091140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 2092140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 2093140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 2094140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 209539a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 209639a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 209739a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 2098140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 209939a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 2100ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 2101ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 2102ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 2103c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 2104c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 2105c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 2106c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 21071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 210864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 2109c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 21105cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (F->isDeclaration()) 2111c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 2112c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 2113c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 2114c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 2115c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 2116c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 2117a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (Name[0] == 'c' && (Name == "copysign" || Name == "copysignf")) { 2118a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 2119a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 2120a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(1)->getType() && 2121a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(2)->getType()) { 2122a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand LHS = getValue(I.getOperand(1)); 2123a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand RHS = getValue(I.getOperand(2)); 2124a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 2125a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner LHS, RHS)); 2126a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner return; 2127a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 2128a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } else if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 2129c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 2130c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 2131c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 2132c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2133c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 2134c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 2135c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 2136c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 2137f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 2138f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 213906a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 2140c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2141f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 2142f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 2143f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2144c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 2145f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 2146f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 214706a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 2148c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2149f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 2150f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 2151f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2152f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 2153c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 2154ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 2155ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner visitInlineAsm(I); 2156ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 2157c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 2158edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 215947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 216047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 216147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer 216264e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 216364e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 216464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 216564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 216664e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 216747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 216847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 2169c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 21701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 21711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 21721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 217347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = ArgNode; Entry.Ty = Arg->getType(); 217447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.isSigned = FTy->paramHasAttr(i, FunctionType::SExtAttribute); 2175b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Entry.isInReg = FTy->paramHasAttr(i, FunctionType::InRegAttribute); 2176b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Entry.isSRet = FTy->paramHasAttr(i, FunctionType::StructRetAttribute); 217747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 21781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2179edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2180cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 218147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), I.getType(), 218247857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer FTy->paramHasAttr(0,FunctionType::SExtAttribute), 218347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer FTy->isVarArg(), I.getCallingConv(), I.isTailCall(), 218447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Callee, Args, DAG); 21851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 2186cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 2187cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 21881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 21891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2190864635ad7b3046d3042311423071152c613961deChris LattnerSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 21919f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag)const{ 2192864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Val = DAG.getCopyFromReg(Chain, Regs[0], RegVT, Flag); 2193864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 2194864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 2195864635ad7b3046d3042311423071152c613961deChris Lattner 2196864635ad7b3046d3042311423071152c613961deChris Lattner // If the result was expanded, copy from the top part. 2197864635ad7b3046d3042311423071152c613961deChris Lattner if (Regs.size() > 1) { 2198864635ad7b3046d3042311423071152c613961deChris Lattner assert(Regs.size() == 2 && 2199864635ad7b3046d3042311423071152c613961deChris Lattner "Cannot expand to more than 2 elts yet!"); 2200864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Hi = DAG.getCopyFromReg(Chain, Regs[1], RegVT, Flag); 2201693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Chain = Hi.getValue(1); 2202693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Flag = Hi.getValue(2); 22039f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (DAG.getTargetLoweringInfo().isLittleEndian()) 22049f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Val, Hi); 22059f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner else 22069f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Hi, Val); 2207864635ad7b3046d3042311423071152c613961deChris Lattner } 2208864635ad7b3046d3042311423071152c613961deChris Lattner 2209cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Otherwise, if the return value was promoted or extended, truncate it to the 2210864635ad7b3046d3042311423071152c613961deChris Lattner // appropriate type. 2211864635ad7b3046d3042311423071152c613961deChris Lattner if (RegVT == ValueVT) 2212864635ad7b3046d3042311423071152c613961deChris Lattner return Val; 2213864635ad7b3046d3042311423071152c613961deChris Lattner 2214cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (MVT::isInteger(RegVT)) { 2215cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (ValueVT < RegVT) 2216cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 2217cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner else 2218cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::ANY_EXTEND, ValueVT, Val); 2219cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } else { 2220864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::FP_ROUND, ValueVT, Val); 2221cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } 2222864635ad7b3046d3042311423071152c613961deChris Lattner} 2223864635ad7b3046d3042311423071152c613961deChris Lattner 2224c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 2225c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// specified value into the registers specified by this object. This uses 2226c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// Chain/Flag as the input and updates them for the output Chain/Flag. 2227c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 2228a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 2229a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const { 2230c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (Regs.size() == 1) { 2231c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // If there is a single register and the types differ, this must be 2232c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // a promotion. 2233c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (RegVT != ValueVT) { 22340c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (MVT::isInteger(RegVT)) { 22350c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (RegVT < ValueVT) 22360c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::TRUNCATE, RegVT, Val); 22370c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner else 22380c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::ANY_EXTEND, RegVT, Val); 22390c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner } else 2240c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::FP_EXTEND, RegVT, Val); 2241c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2242c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Chain = DAG.getCopyToReg(Chain, Regs[0], Val, Flag); 2243c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 2244c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } else { 22459f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<unsigned> R(Regs); 22469f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (!DAG.getTargetLoweringInfo().isLittleEndian()) 22479f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::reverse(R.begin(), R.end()); 22489f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner 22499f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner for (unsigned i = 0, e = R.size(); i != e; ++i) { 2250c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner SDOperand Part = DAG.getNode(ISD::EXTRACT_ELEMENT, RegVT, Val, 2251a844126c43976387a66dafbe5137a762169f1f34Evan Cheng DAG.getConstant(i, PtrVT)); 22529f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner Chain = DAG.getCopyToReg(Chain, R[i], Part, Flag); 2253c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 2254c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2255c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2256c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 2257864635ad7b3046d3042311423071152c613961deChris Lattner 2258c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 2259c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 2260c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 2261c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 22629f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 2263c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getConstant(Code | (Regs.size() << 3), MVT::i32)); 2264c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 2265c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 2266c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 2267864635ad7b3046d3042311423071152c613961deChris Lattner 2268864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 2269864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 2270864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 2271864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 22729b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 22739b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetLowering &TLI, const MRegisterInfo *MRI) { 2274f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType FoundVT = MVT::Other; 2275f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner const TargetRegisterClass *FoundRC = 0; 22769b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (MRegisterInfo::regclass_iterator RCI = MRI->regclass_begin(), 22779b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = MRI->regclass_end(); RCI != E; ++RCI) { 2278f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType ThisVT = MVT::Other; 2279f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner 22809b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 22819b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 22829b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 22839b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 22849b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 22859b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 2286f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // If we have already found this register in a different register class, 2287f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // choose the one with the largest VT specified. For example, on 2288f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // PowerPC, we favor f64 register classes over f32. 2289f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (FoundVT == MVT::Other || 2290f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::getSizeInBits(FoundVT) < MVT::getSizeInBits(*I)) { 2291f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner ThisVT = *I; 2292f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 2293f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 22949b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 22959b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 22969b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 2297f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (ThisVT == MVT::Other) continue; 22989b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 2299864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 2300864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 2301864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 2302864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 23039b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 23049b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 2305f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (*I == Reg) { 2306f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // We found a matching register class. Keep looking at others in case 2307f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // we find one with larger registers that this physreg is also in. 2308f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundRC = RC; 2309f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundVT = ThisVT; 2310f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 2311f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 2312864635ad7b3046d3042311423071152c613961deChris Lattner } 2313f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner return FoundRC; 2314864635ad7b3046d3042311423071152c613961deChris Lattner} 2315864635ad7b3046d3042311423071152c613961deChris Lattner 2316864635ad7b3046d3042311423071152c613961deChris LattnerRegsForValue SelectionDAGLowering:: 2317864635ad7b3046d3042311423071152c613961deChris LattnerGetRegistersForValue(const std::string &ConstrCode, 2318864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, bool isOutReg, bool isInReg, 2319864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 23204e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 2321864635ad7b3046d3042311423071152c613961deChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 2322864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegForInlineAsmConstraint(ConstrCode, VT); 2323864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 2324864635ad7b3046d3042311423071152c613961deChris Lattner 2325864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumRegs = VT != MVT::Other ? TLI.getNumElements(VT) : 1; 2326864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 2327864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT = VT; 2328864635ad7b3046d3042311423071152c613961deChris Lattner 23292a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // If this is a constraint for a specific physical register, like {r17}, 23302a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // assign it now. 2331864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 2332864635ad7b3046d3042311423071152c613961deChris Lattner if (VT == MVT::Other) 2333864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 2334cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner 2335cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Get the actual register value type. This is important, because the user 2336cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // may have asked for (e.g.) the AX register in i32 type. We need to 2337cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // remember that AX is actually i16 to get the right extension. 2338cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner RegVT = *PhysReg.second->vt_begin(); 2339864635ad7b3046d3042311423071152c613961deChris Lattner 2340864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 2341864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 2342864635ad7b3046d3042311423071152c613961deChris Lattner 2343864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 2344864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 2345864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 2346864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 2347864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 2348864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 2349864635ad7b3046d3042311423071152c613961deChris Lattner 2350864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 2351864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 2352864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 2353864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 2354864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 2355864635ad7b3046d3042311423071152c613961deChris Lattner } 2356864635ad7b3046d3042311423071152c613961deChris Lattner } 2357864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 2358864635ad7b3046d3042311423071152c613961deChris Lattner } 2359864635ad7b3046d3042311423071152c613961deChris Lattner 23602a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Otherwise, if this was a reference to an LLVM register class, create vregs 23612a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // for this reference. 23622a821601f1db665fbb825727aacf1a54d17b91efChris Lattner std::vector<unsigned> RegClassRegs; 23632a821601f1db665fbb825727aacf1a54d17b91efChris Lattner if (PhysReg.second) { 23642a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // If this is an early clobber or tied register, our regalloc doesn't know 23652a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // how to maintain the constraint. If it isn't, go ahead and create vreg 23662a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // and let the regalloc do the right thing. 23672a821601f1db665fbb825727aacf1a54d17b91efChris Lattner if (!isOutReg || !isInReg) { 23682a821601f1db665fbb825727aacf1a54d17b91efChris Lattner if (VT == MVT::Other) 23692a821601f1db665fbb825727aacf1a54d17b91efChris Lattner ValueVT = *PhysReg.second->vt_begin(); 23702a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegVT = *PhysReg.second->vt_begin(); 23712a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 23722a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Create the appropriate number of virtual registers. 23732a821601f1db665fbb825727aacf1a54d17b91efChris Lattner SSARegMap *RegMap = DAG.getMachineFunction().getSSARegMap(); 23742a821601f1db665fbb825727aacf1a54d17b91efChris Lattner for (; NumRegs; --NumRegs) 23752a821601f1db665fbb825727aacf1a54d17b91efChris Lattner Regs.push_back(RegMap->createVirtualRegister(PhysReg.second)); 23762a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 23772a821601f1db665fbb825727aacf1a54d17b91efChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 23782a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } 23792a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 23802a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Otherwise, we can't allocate it. Let the code below figure out how to 23812a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // maintain these constraints. 23822a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegClassRegs.assign(PhysReg.second->begin(), PhysReg.second->end()); 23832a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 23842a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } else { 23852a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // This is a reference to a register class that doesn't directly correspond 23862a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // to an LLVM register class. Allocate NumRegs consecutive, available, 23872a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // registers from the class. 23882a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegClassRegs = TLI.getRegClassForInlineAsmConstraint(ConstrCode, VT); 23892a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } 2390864635ad7b3046d3042311423071152c613961deChris Lattner 23914e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner const MRegisterInfo *MRI = DAG.getTarget().getRegisterInfo(); 23924e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner MachineFunction &MF = *CurMBB->getParent(); 2393864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 2394864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 2395864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 23964e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 2397864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 2398864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 2399864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 2400864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 2401864635ad7b3046d3042311423071152c613961deChris Lattner continue; 2402864635ad7b3046d3042311423071152c613961deChris Lattner } 2403864635ad7b3046d3042311423071152c613961deChris Lattner 24044e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 24054e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 24069b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, MRI); 2407864635ad7b3046d3042311423071152c613961deChris Lattner if (!RC) { 2408864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 2409864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 2410864635ad7b3046d3042311423071152c613961deChris Lattner continue; 24114e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 24124e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 2413864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 2414864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 2415864635ad7b3046d3042311423071152c613961deChris Lattner 2416864635ad7b3046d3042311423071152c613961deChris Lattner // If we allocated enough consecutive 2417864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 2418864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 2419864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 2420864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 2421864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) { 2422864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 2423864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 2424864635ad7b3046d3042311423071152c613961deChris Lattner if (isOutReg) OutputRegs.insert(Reg); // Mark reg used. 2425864635ad7b3046d3042311423071152c613961deChris Lattner if (isInReg) InputRegs.insert(Reg); // Mark reg used. 2426864635ad7b3046d3042311423071152c613961deChris Lattner } 2427864635ad7b3046d3042311423071152c613961deChris Lattner 2428864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, *RC->vt_begin(), VT); 2429864635ad7b3046d3042311423071152c613961deChris Lattner } 24304e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 2431864635ad7b3046d3042311423071152c613961deChris Lattner 2432864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 2433864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(); 24344e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 24354e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 2436367f109ba954239a348c624a3331422bfdb31d03Chris Lattner/// getConstraintGenerality - Return an integer indicating how general CT is. 2437367f109ba954239a348c624a3331422bfdb31d03Chris Lattnerstatic unsigned getConstraintGenerality(TargetLowering::ConstraintType CT) { 2438367f109ba954239a348c624a3331422bfdb31d03Chris Lattner switch (CT) { 2439367f109ba954239a348c624a3331422bfdb31d03Chris Lattner default: assert(0 && "Unknown constraint type!"); 2440367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Other: 2441367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Unknown: 2442367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 0; 2443367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Register: 2444367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 1; 2445367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_RegisterClass: 2446367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 2; 2447367f109ba954239a348c624a3331422bfdb31d03Chris Lattner case TargetLowering::C_Memory: 2448367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return 3; 2449367f109ba954239a348c624a3331422bfdb31d03Chris Lattner } 2450367f109ba954239a348c624a3331422bfdb31d03Chris Lattner} 2451367f109ba954239a348c624a3331422bfdb31d03Chris Lattner 2452367f109ba954239a348c624a3331422bfdb31d03Chris Lattnerstatic std::string GetMostGeneralConstraint(std::vector<std::string> &C, 2453367f109ba954239a348c624a3331422bfdb31d03Chris Lattner const TargetLowering &TLI) { 2454367f109ba954239a348c624a3331422bfdb31d03Chris Lattner assert(!C.empty() && "Must have at least one constraint"); 2455367f109ba954239a348c624a3331422bfdb31d03Chris Lattner if (C.size() == 1) return C[0]; 2456367f109ba954239a348c624a3331422bfdb31d03Chris Lattner 2457367f109ba954239a348c624a3331422bfdb31d03Chris Lattner std::string *Current = &C[0]; 2458367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // If we have multiple constraints, try to pick the most general one ahead 2459367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // of time. This isn't a wonderful solution, but handles common cases. 2460367f109ba954239a348c624a3331422bfdb31d03Chris Lattner TargetLowering::ConstraintType Flavor = TLI.getConstraintType(Current[0][0]); 2461367f109ba954239a348c624a3331422bfdb31d03Chris Lattner for (unsigned j = 1, e = C.size(); j != e; ++j) { 2462367f109ba954239a348c624a3331422bfdb31d03Chris Lattner TargetLowering::ConstraintType ThisFlavor = TLI.getConstraintType(C[j][0]); 2463367f109ba954239a348c624a3331422bfdb31d03Chris Lattner if (getConstraintGenerality(ThisFlavor) > 2464367f109ba954239a348c624a3331422bfdb31d03Chris Lattner getConstraintGenerality(Flavor)) { 2465367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // This constraint letter is more general than the previous one, 2466367f109ba954239a348c624a3331422bfdb31d03Chris Lattner // use it. 2467367f109ba954239a348c624a3331422bfdb31d03Chris Lattner Flavor = ThisFlavor; 2468367f109ba954239a348c624a3331422bfdb31d03Chris Lattner Current = &C[j]; 2469367f109ba954239a348c624a3331422bfdb31d03Chris Lattner } 2470367f109ba954239a348c624a3331422bfdb31d03Chris Lattner } 2471367f109ba954239a348c624a3331422bfdb31d03Chris Lattner return *Current; 2472367f109ba954239a348c624a3331422bfdb31d03Chris Lattner} 2473367f109ba954239a348c624a3331422bfdb31d03Chris Lattner 2474864635ad7b3046d3042311423071152c613961deChris Lattner 2475ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 2476ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 2477ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattnervoid SelectionDAGLowering::visitInlineAsm(CallInst &I) { 2478ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner InlineAsm *IA = cast<InlineAsm>(I.getOperand(0)); 2479ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2480ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand AsmStr = DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), 2481ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner MVT::Other); 2482ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 24832cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); 24841efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner std::vector<MVT::ValueType> ConstraintVTs; 2485ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2486ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// AsmNodeOperands - A list of pairs. The first element is a register, the 2487ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// second is a bitfield where bit #0 is set if it is a use and bit #1 is set 2488ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// if it is a def of that register. 2489ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> AsmNodeOperands; 2490ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 2491ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(AsmStr); 2492ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2493ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 2494ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 2495ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 24964e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We fully assign registers here at isel time. This is not optimal, but 24974e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // should work. For register classes that correspond to LLVM classes, we 24984e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // could let the LLVM RA do its thing, but we currently don't. Do a prepass 24994e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // over the constraints, collecting fixed registers that we know we can't use. 25004e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 25011efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner unsigned OpNum = 1; 25024e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 2503367f109ba954239a348c624a3331422bfdb31d03Chris Lattner std::string ConstraintCode = 2504367f109ba954239a348c624a3331422bfdb31d03Chris Lattner GetMostGeneralConstraint(Constraints[i].Codes, TLI); 25052223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 25061efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner MVT::ValueType OpVT; 25071efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 25081efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Compute the value type for each operand and add it to ConstraintVTs. 25091efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner switch (Constraints[i].Type) { 25101efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 25111efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (!Constraints[i].isIndirectOutput) { 25121efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 25131efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getType()); 25141efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 251522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner const Type *OpTy = I.getOperand(OpNum)->getType(); 25161efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(cast<PointerType>(OpTy)->getElementType()); 25171efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 25181efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 25191efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 25201efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 25211efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getOperand(OpNum)->getType()); 25221efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 25231efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 25241efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 25251efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = MVT::Other; 25261efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 25271efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 25281efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 25291efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner ConstraintVTs.push_back(OpVT); 25301efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2531864635ad7b3046d3042311423071152c613961deChris Lattner if (TLI.getRegForInlineAsmConstraint(ConstraintCode, OpVT).first == 0) 2532864635ad7b3046d3042311423071152c613961deChris Lattner continue; // Not assigned a fixed reg. 25331efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2534864635ad7b3046d3042311423071152c613961deChris Lattner // Build a list of regs that this operand uses. This always has a single 2535864635ad7b3046d3042311423071152c613961deChris Lattner // element for promoted/expanded operands. 2536864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = GetRegistersForValue(ConstraintCode, OpVT, 2537864635ad7b3046d3042311423071152c613961deChris Lattner false, false, 2538864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 25394e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 25404e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner switch (Constraints[i].Type) { 25414e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isOutput: 25424e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We can't assign any other output to this register. 2543864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 25444e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // If this is an early-clobber output, it cannot be assigned to the same 25454e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // value as the input reg. 25462223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2547864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 25484e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 25491efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 25501efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // We can't assign any other input to this register. 2551864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 25521efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 25534e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isClobber: 25544e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Clobbered regs cannot be used as inputs or outputs. 2555864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 2556864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 25574e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 25584e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 25594e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 25602cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 25610f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 25620f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 2563864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 2564864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 25651efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum = 1; 25660f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 25676656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 2568367f109ba954239a348c624a3331422bfdb31d03Chris Lattner std::string ConstraintCode = 2569367f109ba954239a348c624a3331422bfdb31d03Chris Lattner GetMostGeneralConstraint(Constraints[i].Codes, TLI); 25701efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 25712cc2f66c25d9576743026688fdae5ed402726532Chris Lattner switch (Constraints[i].Type) { 25722cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 257322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 257422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 257522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 257622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 257722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (CTy == TargetLowering::C_Memory) { 257822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Memory output. 257922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 258022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 258122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Check that the operand (the address to store to) isn't a float. 258222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 258322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 258422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 258522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!Constraints[i].isIndirectOutput) 258622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 258722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 258822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner OpNum++; // Consumes a call operand. 258922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 259022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Extend/truncate to the right pointer type if needed. 259122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 259222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (InOperandVal.getValueType() < PtrType) 259322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 259422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner else if (InOperandVal.getValueType() > PtrType) 259522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 259622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 259722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 259822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 259922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 260022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(InOperandVal); 260122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 260222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 260322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 260422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Otherwise, this is a register output. 260522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 260622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 2607864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an early-clobber output, or if there is an input 2608864635ad7b3046d3042311423071152c613961deChris Lattner // constraint that matches this, we need to reserve the input register 2609864635ad7b3046d3042311423071152c613961deChris Lattner // so no other inputs allocate to it. 2610864635ad7b3046d3042311423071152c613961deChris Lattner bool UsesInputRegister = false; 2611864635ad7b3046d3042311423071152c613961deChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2612864635ad7b3046d3042311423071152c613961deChris Lattner UsesInputRegister = true; 26132223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 2614864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 2615864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 2616864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = 2617864635ad7b3046d3042311423071152c613961deChris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 2618864635ad7b3046d3042311423071152c613961deChris Lattner true, UsesInputRegister, 2619864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 2620d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner if (Regs.Regs.empty()) { 2621832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Couldn't allocate output reg for contraint '" 2622832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << ConstraintCode << "'!\n"; 2623d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner exit(1); 2624d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner } 26252cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 26262cc2f66c25d9576743026688fdae5ed402726532Chris Lattner if (!Constraints[i].isIndirectOutput) { 2627864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 26282cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 26292cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 2630864635ad7b3046d3042311423071152c613961deChris Lattner RetValRegs = Regs; 26312cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 263222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner IndirectStoresToEmit.push_back(std::make_pair(Regs, 263322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner I.getOperand(OpNum))); 26342cc2f66c25d9576743026688fdae5ed402726532Chris Lattner OpNum++; // Consumes a call operand. 26352cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 26366656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 26376656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 26386656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 2639c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Regs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, AsmNodeOperands); 26406656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 26416656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 26426656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 264322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 26444e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner OpNum++; // Consumes a call operand. 26453d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 26462223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (isdigit(ConstraintCode[0])) { // Matching constraint? 26472223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 26482223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 26492223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner unsigned OperandNo = atoi(ConstraintCode.c_str()); 26503d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 2651c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 2652c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 2653c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 2654c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 2655c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 2656c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2657c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2658a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner assert(((NumOps & 7) == 2 /*REGDEF*/ || 2659a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner (NumOps & 7) == 4 /*MEM*/) && 2660c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2661c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 2662c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2663c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2664c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2665c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2666527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner if ((NumOps & 7) == 2 /*REGDEF*/) { 2667527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 2668527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner RegsForValue MatchedRegs; 2669527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 2670527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 2671527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 2672527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner unsigned Reg = 2673527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 2674527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.Regs.push_back(Reg); 2675527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner } 2676c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2677527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner // Use the produced MatchedRegs object to 2678527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, 2679527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner TLI.getPointerTy()); 2680527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 2681527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner break; 2682527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner } else { 2683527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner assert((NumOps & 7) == 4/*MEM*/ && "Unknown matching constraint!"); 2684527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner assert(0 && "matching constraints for memory operands unimp"); 2685c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 268687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 268787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 268887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 268987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 269087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 26913d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 269287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (CTy == TargetLowering::C_Other) { 269353069fbbae2558a3138df24776448791fea3aceeChris Lattner InOperandVal = TLI.isOperandValidForConstraint(InOperandVal, 269453069fbbae2558a3138df24776448791fea3aceeChris Lattner ConstraintCode[0], DAG); 269553069fbbae2558a3138df24776448791fea3aceeChris Lattner if (!InOperandVal.Val) { 2696832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Invalid operand for inline asm constraint '" 2697832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << ConstraintCode << "'!\n"; 269853069fbbae2558a3138df24776448791fea3aceeChris Lattner exit(1); 269953069fbbae2558a3138df24776448791fea3aceeChris Lattner } 2700c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 270187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 270287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 3 /*IMM*/ | (1 << 3); 270387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 270487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 270587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 270687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } else if (CTy == TargetLowering::C_Memory) { 270787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Memory input. 270887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 270987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Check that the operand isn't a float. 271087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 271187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2712c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 271387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Extend/truncate to the right pointer type if needed. 271487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 271587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (InOperandVal.getValueType() < PtrType) 271687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 271787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner else if (InOperandVal.getValueType() > PtrType) 271887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 271987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 272087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 272187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 272287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 272387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 2724c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 27252223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 272687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 272787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 272887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 272987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 273087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner RegsForValue InRegs = 273187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 273287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner false, true, OutputRegs, InputRegs); 273387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // FIXME: should be match fail. 273487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(!InRegs.Regs.empty() && "Couldn't allocate input reg!"); 273587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 2736a844126c43976387a66dafbe5137a762169f1f34Evan Cheng InRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, TLI.getPointerTy()); 273787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 273887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, AsmNodeOperands); 27396656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 27406656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2741c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 2742c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue ClobberedRegs = 2743c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner GetRegistersForValue(ConstraintCode, MVT::Other, false, false, 2744c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner OutputRegs, InputRegs); 2745c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 2746c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 2747c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (!ClobberedRegs.Regs.empty()) 2748c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner ClobberedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, AsmNodeOperands); 27496656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 27506656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2751c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 27526656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2753ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2754ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 2755ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 2756ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 2757ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2758f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, 2759f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::Other, MVT::Flag), 2, 2760bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &AsmNodeOperands[0], AsmNodeOperands.size()); 2761ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 2762ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 27636656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 27646656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 2765864635ad7b3046d3042311423071152c613961deChris Lattner if (!RetValRegs.Regs.empty()) 2766864635ad7b3046d3042311423071152c613961deChris Lattner setValue(&I, RetValRegs.getCopyFromRegs(DAG, Chain, Flag)); 27676656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 27686656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 27696656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 27706656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 27716656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 27726656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 2773864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 27746656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 2775864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, Flag); 2776864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 27776656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2778ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 27796656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 2780bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 27816656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 2782786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng OutChains.push_back(DAG.getStore(Chain, StoresToEmit[i].first, 27836656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 27848b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoresToEmit[i].second, 0)); 27856656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 2786bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, 2787bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 2788ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 2789ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 2790ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2791ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 27921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 27931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 27941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 279668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 279768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 279868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 279968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 280068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 28011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 28021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 2803a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(I.getType()->getElementType()); 28041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 28051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 28061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 280747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 280847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 280947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = Src; 281047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Ty = TLI.getTargetData()->getIntPtrType(); 281147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.isSigned = false; 2812b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Entry.isInReg = false; 2813b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Entry.isSRet = false; 281447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 2815cf5734dddd66af9388a171b44996505ede47feedChris Lattner 2816cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 281747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), I.getType(), false, false, CallingConv::C, true, 2818cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 2819cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 2820cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 2821cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 28221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 28231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 28241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 282547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 282647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 282747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = getValue(I.getOperand(0)); 282847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Ty = TLI.getTargetData()->getIntPtrType(); 282947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.isSigned = false; 2830b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Entry.isInReg = false; 2831b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Entry.isSRet = false; 283247857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 28331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 2834cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 283547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), Type::VoidTy, false, false, CallingConv::C, true, 2836cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 2837cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 28381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 28391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2840025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 2841025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 2842025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 2843025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 2844025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 2845025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 2846025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 2847832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "If a target marks an instruction with " 2848832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << "'usesCustomDAGSchedInserter', it must implement " 2849832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << "TargetLowering::InsertAtEndOfBasicBlock!\n"; 2850025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 2851025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 2852025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 2853025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 285439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 2855acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 2856acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2857acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 285839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 285939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 28601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 2861acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 2862acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 2863acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 2864acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 2865acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 28661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 28671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 28681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 2869acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 2870acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2871acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 28721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 28731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 28741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 2875acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 2876acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2877acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 2878acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 2879acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 28801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 28811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2882b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// ExpandScalarFormalArgs - Recursively expand the formal_argument node, either 2883b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// bit_convert it or join a pair of them with a BUILD_PAIR when appropriate. 2884b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Chengstatic SDOperand ExpandScalarFormalArgs(MVT::ValueType VT, SDNode *Arg, 2885b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng unsigned &i, SelectionDAG &DAG, 2886b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng TargetLowering &TLI) { 2887b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (TLI.getTypeAction(VT) != TargetLowering::Expand) 2888b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return SDOperand(Arg, i++); 2889b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 2890b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng MVT::ValueType EVT = TLI.getTypeToTransformTo(VT); 2891b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng unsigned NumVals = MVT::getSizeInBits(VT) / MVT::getSizeInBits(EVT); 2892b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (NumVals == 1) { 2893b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return DAG.getNode(ISD::BIT_CONVERT, VT, 2894b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng ExpandScalarFormalArgs(EVT, Arg, i, DAG, TLI)); 2895b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else if (NumVals == 2) { 2896b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Lo = ExpandScalarFormalArgs(EVT, Arg, i, DAG, TLI); 2897b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Hi = ExpandScalarFormalArgs(EVT, Arg, i, DAG, TLI); 2898b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (!TLI.isLittleEndian()) 2899b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng std::swap(Lo, Hi); 2900b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return DAG.getNode(ISD::BUILD_PAIR, VT, Lo, Hi); 2901b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else { 2902b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // Value scalarized into many values. Unimp for now. 2903b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng assert(0 && "Cannot expand i64 -> i16 yet!"); 2904b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } 2905b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return SDOperand(); 2906b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng} 2907b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 2908fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// TargetLowering::LowerArguments - This is the default LowerArguments 2909fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// implementation, which just inserts a FORMAL_ARGUMENTS node. FIXME: When all 2910f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// targets are migrated to using FORMAL_ARGUMENTS, this hook should be 2911f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// integrated into SDISel. 2912fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattnerstd::vector<SDOperand> 2913fdfded55888e35b76bb70231a5bb2f60877c2f6aChris LattnerTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { 2914b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov const FunctionType *FTy = F.getFunctionType(); 2915fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. 2916fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<SDOperand> Ops; 29178c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner Ops.push_back(DAG.getRoot()); 2918fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.getCallingConv(), getPointerTy())); 2919fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.isVarArg(), getPointerTy())); 2920fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2921fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add one result value for each formal argument. 2922fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<MVT::ValueType> RetVals; 29236aa279dc8b5a05499b2cd158f8187d7225adc4f4Anton Korobeynikov unsigned j = 1; 2924ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); 2925ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov I != E; ++I, ++j) { 2926fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2927ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov bool isInReg = FTy->paramHasAttr(j, FunctionType::InRegAttribute); 2928b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov bool isSRet = FTy->paramHasAttr(j, FunctionType::StructRetAttribute); 2929b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov unsigned Flags = (isInReg << 1) | (isSRet << 2); 2930fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2931fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2932fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2933fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2934fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(VT); 2935b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 2936fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2937fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: 2938fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(getTypeToTransformTo(VT)); 2939b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 2940fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2941fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2942fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2943fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be broken up into small 2944fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the destination type is and how many small 2945fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it turns into. 29469f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType NVT = getTypeToExpandTo(VT); 29479f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = getNumElements(VT); 2948b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov for (unsigned i = 0; i != NumVals; ++i) { 2949fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(NVT); 2950b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 2951b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov } 2952fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2953fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2954fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2955fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumElems = cast<PackedType>(I->getType())->getNumElements(); 2956fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner const Type *EltTy = cast<PackedType>(I->getType())->getElementType(); 2957f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 2958fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2959fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2960fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2961fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2962fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(TVT); 2963b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 2964fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2965fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2966fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2967fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2968fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2969fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2970fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 29713b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng 29728c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner RetVals.push_back(MVT::Other); 2973fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2974fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Create the node. 2975f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDNode *Result = DAG.getNode(ISD::FORMAL_ARGUMENTS, 2976f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(RetVals), RetVals.size(), 2977bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()).Val; 29788c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner 29798c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner DAG.setRoot(SDOperand(Result, Result->getNumValues()-1)); 2980fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2981fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Set up the return result vector. 2982fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.clear(); 2983fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned i = 0; 298447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer unsigned Idx = 1; 298547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; 298647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ++I, ++Idx) { 2987fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2988fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2989fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2990fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2991fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2992fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(SDOperand(Result, i++)); 2993fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2994fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: { 2995fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Op(Result, i++); 2996fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (MVT::isInteger(VT)) { 2997f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner if (FTy->paramHasAttr(Idx, FunctionType::SExtAttribute)) 2998f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner Op = DAG.getNode(ISD::AssertSext, Op.getValueType(), Op, 2999f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner DAG.getValueType(VT)); 3000f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner else if (FTy->paramHasAttr(Idx, FunctionType::ZExtAttribute)) 3001f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner Op = DAG.getNode(ISD::AssertZext, Op.getValueType(), Op, 3002f8e7a219121b7d6f8bcf1e22828648a243384fbbChris Lattner DAG.getValueType(VT)); 3003fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::TRUNCATE, VT, Op); 3004fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 3005fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 3006fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::FP_ROUND, VT, Op); 3007fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3008fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(Op); 3009fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3010fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3011fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 3012fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 3013b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // If this is a large integer or a floating point node that needs to be 3014b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // expanded, it needs to be reassembled from small integers. Figure out 3015b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // what the source elt type is and how many small integers it is. 3016b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng Ops.push_back(ExpandScalarFormalArgs(VT, Result, i, DAG, *this)); 3017fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 3018fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 3019fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 3020020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const PackedType *PTy = cast<PackedType>(I->getType()); 3021020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng unsigned NumElems = PTy->getNumElements(); 3022020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const Type *EltTy = PTy->getElementType(); 3023f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 3024fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 3025fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 3026fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 3027d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3028020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng SDOperand N = SDOperand(Result, i++); 3029020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng // Handle copies from generic vectors to registers. 3030d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 3031d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 3032d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 3033d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner Ops.push_back(N); 3034d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner } else { 3035fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 3036da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3037fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3038fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3039fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 3040fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3041fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 3042fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner return Ops; 3043fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner} 3044fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 3045f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3046b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// ExpandScalarCallArgs - Recursively expand call argument node by 3047b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng/// bit_converting it or extract a pair of elements from the larger node. 3048b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Chengstatic void ExpandScalarCallArgs(MVT::ValueType VT, SDOperand Arg, 3049b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov unsigned Flags, 3050b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SmallVector<SDOperand, 32> &Ops, 3051b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SelectionDAG &DAG, 3052b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng TargetLowering &TLI) { 3053b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (TLI.getTypeAction(VT) != TargetLowering::Expand) { 3054b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng Ops.push_back(Arg); 3055b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3056b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng return; 3057b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } 3058b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 3059b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng MVT::ValueType EVT = TLI.getTypeToTransformTo(VT); 3060b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng unsigned NumVals = MVT::getSizeInBits(VT) / MVT::getSizeInBits(EVT); 3061b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (NumVals == 1) { 3062b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng Arg = DAG.getNode(ISD::BIT_CONVERT, EVT, Arg); 3063b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov ExpandScalarCallArgs(EVT, Arg, Flags, Ops, DAG, TLI); 3064b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else if (NumVals == 2) { 3065b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, EVT, Arg, 3066b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng DAG.getConstant(0, TLI.getPointerTy())); 3067b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, EVT, Arg, 3068b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng DAG.getConstant(1, TLI.getPointerTy())); 3069b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng if (!TLI.isLittleEndian()) 3070b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng std::swap(Lo, Hi); 3071b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov ExpandScalarCallArgs(EVT, Lo, Flags, Ops, DAG, TLI); 3072b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov ExpandScalarCallArgs(EVT, Hi, Flags, Ops, DAG, TLI); 3073b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } else { 3074b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng // Value scalarized into many values. Unimp for now. 3075b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng assert(0 && "Cannot expand i64 -> i16 yet!"); 3076b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng } 3077b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng} 3078b15974a65ce3c5d5cdde8d5e524055d3f1d59a77Evan Cheng 3079f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// TargetLowering::LowerCallTo - This is the default LowerCallTo 3080f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// implementation, which just inserts an ISD::CALL node, which is later custom 3081f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// lowered by the target to something concrete. FIXME: When all targets are 3082f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// migrated to using ISD::CALL, this hook should be integrated into SDISel. 3083f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattnerstd::pair<SDOperand, SDOperand> 308447857812e29324a9d1560796a05b53d3a9217fd9Reid SpencerTargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, 308547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer bool RetTyIsSigned, bool isVarArg, 3086f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned CallingConv, bool isTailCall, 3087f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Callee, 3088f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ArgListTy &Args, SelectionDAG &DAG) { 3089be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<SDOperand, 32> Ops; 3090f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Chain); // Op#0 - Chain 3091f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(CallingConv, getPointerTy())); // Op#1 - CC 3092f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isVarArg, getPointerTy())); // Op#2 - VarArg 3093f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isTailCall, getPointerTy())); // Op#3 - Tail 3094f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Callee); 3095f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3096f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Handle all of the outgoing arguments. 3097f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) { 309847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer MVT::ValueType VT = getValueType(Args[i].Ty); 309947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer SDOperand Op = Args[i].Node; 310047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer bool isSigned = Args[i].isSigned; 3101b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov bool isInReg = Args[i].isInReg; 3102b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov bool isSRet = Args[i].isSRet; 3103b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov unsigned Flags = (isSRet << 2) | (isInReg << 1) | isSigned; 3104f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 3105f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 3106f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 3107f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 3108b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3109f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3110f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 3111f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (MVT::isInteger(VT)) { 3112f6d62c2e2a53e3ebf2e25f0891e5f1a0b772b368Evan Cheng unsigned ExtOp = isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; 3113f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ExtOp, getTypeToTransformTo(VT), Op); 3114f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3115f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 3116f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, getTypeToTransformTo(VT), Op); 3117f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3118f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 3119b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 3120f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3121f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 3122f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 3123f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be broken down into small 3124f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 3125f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 3126b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov ExpandScalarCallArgs(VT, Op, Flags, Ops, DAG, *this); 3127f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3128da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 3129da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 313047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer const PackedType *PTy = cast<PackedType>(Args[i].Ty); 3131da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 3132da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 3133da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 3134da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 3135da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 3136da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 31371b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 31381b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner // Insert a VBIT_CONVERT of the MVT::Vector type to the packed type. 31391b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, TVT, Op); 31401b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Ops.push_back(Op); 3141b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 31421b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner } else { 3143da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call args yet!"); 3144da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3145da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 3146f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3147f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3148f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3149f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3150f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3151f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Figure out the result value types. 3152be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<MVT::ValueType, 4> RetTys; 3153f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3154f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTy != Type::VoidTy) { 3155f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 3156f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 3157f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 3158f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 3159f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(VT); 3160f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3161f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 3162f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(getTypeToTransformTo(VT)); 3163f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 3164f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 3165f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 3166f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be reassembled from small 3167f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 3168f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 31699f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng MVT::ValueType NVT = getTypeToExpandTo(VT); 31709f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = getNumElements(VT); 3171f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0; i != NumVals; ++i) 3172f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(NVT); 3173f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3174da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 3175da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 3176da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const PackedType *PTy = cast<PackedType>(RetTy); 3177da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 3178da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 3179da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 3180da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 3181da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 3182da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 3183da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3184da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner RetTys.push_back(TVT); 3185da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 3186da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call results yet!"); 3187da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3188da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 3189f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3190f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3191f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3192f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3193f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(MVT::Other); // Always has a chain. 3194f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3195f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Finally, create the CALL node. 3196be384162c68641233deba8702666af51bdfd4b83Chris Lattner SDOperand Res = DAG.getNode(ISD::CALL, 3197be384162c68641233deba8702666af51bdfd4b83Chris Lattner DAG.getVTList(&RetTys[0], RetTys.size()), 3198be384162c68641233deba8702666af51bdfd4b83Chris Lattner &Ops[0], Ops.size()); 3199f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3200f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // This returns a pair of operands. The first element is the 3201f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // return value for the function (if RetTy is not VoidTy). The second 3202f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // element is the outgoing token chain. 3203f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand ResVal; 3204f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() != 1) { 3205f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 3206f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() == 2) { 3207f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = Res; 3208f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3209f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this value was promoted, truncate it down. 3210f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (ResVal.getValueType() != VT) { 3211da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (VT == MVT::Vector) { 3212da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBITCONVERT to convert from the packed result type to the 3213da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // MVT::Vector type. 3214da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = cast<PackedType>(RetTy)->getNumElements(); 3215da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = cast<PackedType>(RetTy)->getElementType(); 3216da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 3217da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 3218da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 3219fea997aac5773e936754de5436029c2a4fa1e930Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy),NumElems); 3220da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 3221da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBIT_CONVERT of the FORMAL_ARGUMENTS to a 3222da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // "N x PTyElementVT" MVT::Vector type. 3223da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner ResVal = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, ResVal, 3224d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 3225d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 3226da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 3227da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 3228da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 3229da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else if (MVT::isInteger(VT)) { 323047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer unsigned AssertOp = ISD::AssertSext; 323147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer if (!RetTyIsSigned) 323247857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer AssertOp = ISD::AssertZext; 3233f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(AssertOp, ResVal.getValueType(), ResVal, 3234f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getValueType(VT)); 3235f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::TRUNCATE, VT, ResVal); 3236f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3237f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT)); 32381a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng if (getTypeAction(VT) == Expand) 32391a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng ResVal = DAG.getNode(ISD::BIT_CONVERT, VT, ResVal); 32401a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng else 32411a8f1fe676f1d83e0da7336e744ebcdcc14a88c4Evan Cheng ResVal = DAG.getNode(ISD::FP_ROUND, VT, ResVal); 3242f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3243f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3244f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else if (RetTys.size() == 3) { 3245f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::BUILD_PAIR, VT, 3246f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Res.getValue(0), Res.getValue(1)); 3247f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3248f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 3249f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(0 && "Case not handled yet!"); 3250f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3251f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 3252f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 3253f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner return std::make_pair(ResVal, Res.getValue(Res.Val->getNumValues()-1)); 3254f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner} 3255f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 325650381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 3257171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 3258171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 3259d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 3260171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 3261171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 32620aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 32630aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 32640aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 32650aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 32660aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 32670aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 32680aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 326974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 32701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 32711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 3272a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 32731db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 32741db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 32751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 32761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 32771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 32781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 32791db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 32801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 32811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 32821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 32831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 32841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 32851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 32861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 32871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 32881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 32891db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 32901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 32911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 32921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 32931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 32941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 32951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 32961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 32971db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 32981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 329974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 330074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 330174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 330274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 330374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 330474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 330574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 330674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng unsigned MSB = getSizeInBits(VT) / 8; 330774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 330874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 330974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 3310a5a57d66f5717873dbf3c48b174c0b0ce54b6612Evan Cheng Val = (Val << 8) | (unsigned char)Str[Offset]; 331174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 331274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 331374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 331474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 331574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 33161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 33171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 33181db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 33191db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 33201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 33211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 33221db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 3323c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 332480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 332580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 3326c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 3327c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 3328c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 33291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 33301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 33311db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 33321db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 33331db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 33341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 33351db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 33361db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 33371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 33381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 33391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 33401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 33411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 33421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 33431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 33441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 33451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 33461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 33471db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 33481db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 33491db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 335080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 335180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 335280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 335380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 33541db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 335580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 335680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 335780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 3358dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 33591db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 33601db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 33611db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 33621db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 33631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 33641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 336580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 336680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 336780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 336880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 33691db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 33701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 33711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 337280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 337380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 33741db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 33751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 33767041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 33771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 33781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 33791db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 33801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 33811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 33821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 33831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 33841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 33851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 33861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 33871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 33881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 3389bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 33901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 3391ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 33921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 3393c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 3394c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 339580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 33961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 33971db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 33981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 33991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 3400a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 3401786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng SDOperand Store = DAG.getStore(getRoot(), Value, 3402864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 34038b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), Offset); 3404c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 3405c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 3406c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3407c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3408c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 3409c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3410c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 3411c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 3412c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 3413c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 3414cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 341574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 341674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 3417cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 341874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 341974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 342074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 342174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 342274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 342374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 342474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 3425cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 342674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 342774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 342874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 3429f3e486e069011c70abb771958dc1218912b98eeaEvan Cheng if (GV && GV->isConstant()) { 34300937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 3431cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 3432cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 3433cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 3434cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 3435cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 343674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 343774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 3438c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 3439c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 3440c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 344174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 344274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 3443cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 344474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 344574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 344674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 3447786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 3448786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 34498b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 345074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 345174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 345274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 3453466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng I.getOperand(2), SrcOff); 345474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 345574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 3456786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 3457786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 34588b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 345974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 3460c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 346174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 346274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 34631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 34641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 3465c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 34661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 34671db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 3468c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 3469c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 3470bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 3471bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size())); 3472c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 3473c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 34741db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 34751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 3476bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, getRoot(), Op1, Op2, Op3, Op4)); 34771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 34781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34797041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 34807041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 34817041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 34821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 34831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 34841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 34851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 34861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3487495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 348836b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 348936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 3490c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AU.addRequired<AliasAnalysis>(); 3491495a0b51915eb763576874f29192820b731edc22Chris Lattner} 34921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3493c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 34947e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// OptimizeNoopCopyExpression - We have determined that the specified cast 34957e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// instruction is a noop copy (e.g. it's casting from one pointer type to 34967e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// another, int->uint, or int->sbyte on PPC. 3497903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// 3498903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// Return true if any changes are made. 3499903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeNoopCopyExpression(CastInst *CI) { 35007e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *DefBB = CI->getParent(); 35017e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35027e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner /// InsertedCasts - Only insert a cast in each block once. 35037e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner std::map<BasicBlock*, CastInst*> InsertedCasts; 35047e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 3505903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = false; 35067e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end(); 35077e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UI != E; ) { 35087e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Use &TheUse = UI.getUse(); 35097e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *User = cast<Instruction>(*UI); 35107e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35117e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Figure out which BB this cast is used in. For PHI's this is the 35127e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // appropriate predecessor block. 35137e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *UserBB = User->getParent(); 35147e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(User)) { 35157e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner unsigned OpVal = UI.getOperandNo()/2; 35167e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UserBB = PN->getIncomingBlock(OpVal); 35177e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 35187e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35197e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Preincrement use iterator so we don't invalidate it. 35207e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner ++UI; 35217e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35227e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this user is in the same block as the cast, don't change the cast. 35237e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (UserBB == DefBB) continue; 35247e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35257e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If we have already inserted a cast into this block, use it. 35267e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner CastInst *&InsertedCast = InsertedCasts[UserBB]; 35277e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35287e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (!InsertedCast) { 35297e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock::iterator InsertPt = UserBB->begin(); 35307e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 35317e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35327e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner InsertedCast = 35337b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer CastInst::create(CI->getOpcode(), CI->getOperand(0), CI->getType(), "", 35347b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer InsertPt); 3535903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = true; 35367e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 35377e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35387e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Replace a use of the cast with a use of the new casat. 35397e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner TheUse = InsertedCast; 35407e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 3541903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3542903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If we removed all uses, nuke the cast. 3543903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->use_empty()) 3544903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner CI->eraseFromParent(); 3545903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3546903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return MadeChange; 35477e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner} 3548c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3549903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 3550903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// casting to the type of GEPI. 3551f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattnerstatic Instruction *InsertGEPComputeCode(Instruction *&V, BasicBlock *BB, 3552f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *GEPI, Value *Ptr, 3553f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Value *PtrOffset) { 3554903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (V) return V; // Already computed. 3555903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 35563da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Figure out the insertion point 3557903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner BasicBlock::iterator InsertPt; 3558903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (BB == GEPI->getParent()) { 35593da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // If GEP is already inserted into BB, insert right after the GEP. 3560903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = GEPI; 3561903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ++InsertPt; 3562903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3563903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 3564903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = BB->begin(); 3565903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 3566903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3567903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3568903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 3569903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // BB so that there is only one value live across basic blocks (the cast 3570903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // operand). 3571903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 3572903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 35737b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer Ptr = CastInst::create(CI->getOpcode(), CI->getOperand(0), CI->getType(), 35747b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer "", InsertPt); 3575903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3576903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Add the offset, cast it to the right type. 3577903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 35783da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Ptr is an integer type, GEPI is pointer type ==> IntToPtr 35793da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return V = CastInst::create(Instruction::IntToPtr, Ptr, GEPI->getType(), 35803da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "", InsertPt); 3581903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3582903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3583903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// ReplaceUsesOfGEPInst - Replace all uses of RepPtr with inserted code to 3584903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// compute its value. The RepPtr value can be computed with Ptr+PtrOffset. One 3585903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// trivial way of doing this would be to evaluate Ptr+PtrOffset in RepPtr's 3586903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// block, then ReplaceAllUsesWith'ing everything. However, we would prefer to 3587903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// sink PtrOffset into user blocks where doing so will likely allow us to fold 3588903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// the constant add into a load or store instruction. Additionally, if a user 3589903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// is a pointer-pointer cast, we look through it to find its users. 3590903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic void ReplaceUsesOfGEPInst(Instruction *RepPtr, Value *Ptr, 3591903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Constant *PtrOffset, BasicBlock *DefBB, 3592903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GetElementPtrInst *GEPI, 3593f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> &InsertedExprs) { 3594903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (!RepPtr->use_empty()) { 3595903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Instruction *User = cast<Instruction>(RepPtr->use_back()); 3596903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 35973da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // If the user is a Pointer-Pointer cast, recurse. Only BitCast can be 35983da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // used for a Pointer-Pointer cast. 35993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (isa<BitCastInst>(User)) { 3600903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(User, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3601903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3602903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Drop the use of RepPtr. The cast is dead. Don't delete it now, else we 3603903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // could invalidate an iterator. 3604903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->setOperand(0, UndefValue::get(RepPtr->getType())); 3605903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner continue; 3606903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3607903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3608903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a load of the pointer, or a store through the pointer, emit 3609903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // the increment into the load/store block. 3610f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *NewVal; 3611903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (isa<LoadInst>(User) || 3612903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner (isa<StoreInst>(User) && User->getOperand(0) != RepPtr)) { 3613903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 3614903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->getParent(), GEPI, 3615903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3616903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3617903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this use is not foldable into the addressing mode, use a version 3618903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // emitted in the GEP block. 3619903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 3620903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3621903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3622903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3623f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner if (GEPI->getType() != RepPtr->getType()) { 3624f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner BasicBlock::iterator IP = NewVal; 3625f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner ++IP; 36263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // NewVal must be a GEP which must be pointer type, so BitCast 36273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer NewVal = new BitCastInst(NewVal, RepPtr->getType(), "", IP); 3628f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner } 3629903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->replaceUsesOfWith(RepPtr, NewVal); 3630903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3631903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3632903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3633903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3634c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 3635c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 3636c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 3637c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 3638c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 3639c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 3640903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeGEPExpression(GetElementPtrInst *GEPI, 3641a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD) { 3642c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 3643c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 3644c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 3645c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 3646c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 3647c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 3648c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 3649c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 3650c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3651c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3652c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3653903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!isUsedOutsideDefBB) return false; 3654c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3655c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 3656c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 3657c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 3658903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool hasVariableIndex = false; 3659c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 3660c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 3661903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) { 3662b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue()) { 3663c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 3664c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3665c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3666903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3667903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner hasVariableIndex = true; 3668903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3669c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3670903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3671903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a "GEP X, 0, 0, 0", turn this into a cast. 3672903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !hasVariableIndex) { 36733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer /// The GEP operand must be a pointer, so must its result -> BitCast 36743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Value *NC = new BitCastInst(GEPI->getOperand(0), GEPI->getType(), 3675903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->getName(), GEPI); 3676903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->replaceAllUsesWith(NC); 3677903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->eraseFromParent(); 3678903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 3679903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3680903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 36813802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 3682903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) 3683903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return false; 3684c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3685c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 3686c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 3687c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 3688a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const Type *UIntPtrTy = TD->getIntPtrType(); 36893da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Value *Ptr = new PtrToIntInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 3690c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 3691c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3692c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 3693c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 3694c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 3695c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 3696b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 3697c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 3698a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson ConstantOffset += TD->getStructLayout(StTy)->MemberOffsets[Field]; 3699c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 3700c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 3701c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 3702c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3703c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 3704c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 3705b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 370647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ConstantOffset += (int64_t)TD->getTypeSize(Ty)*CI->getSExtValue(); 3707c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 3708c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3709c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3710c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 3711c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3712c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 37137b06bd532d3324a2f76bbc856ae20ff89d8e0e92Reid Spencer Idx = CastInst::createIntegerCast(Idx, UIntPtrTy, true/*SExt*/, "", GEPI); 3714c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3715a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 3716c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 3717c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 3718b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Constant *SizeCst = ConstantInt::get(UIntPtrTy, ElementSize); 3719c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3720c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 3721c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 3722c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 3723c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3724c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3725c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3726c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 3727c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 3728b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Constant *PtrOffset = ConstantInt::get(UIntPtrTy, ConstantOffset); 3729c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3730c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 3731c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 3732c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 3733c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 3734c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 3735c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 3736c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 3737c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 3738f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> InsertedExprs; 3739903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(GEPI, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3740c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3741c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 3742c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 3743903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3744903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 3745c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 3746c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3747bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3748bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// SplitEdgeNicely - Split the critical edge from TI to it's specified 3749bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// successor if it will improve codegen. We only do this if the successor has 3750bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// phi nodes (otherwise critical edges are ok). If there is already another 3751bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// predecessor of the succ that is empty (and thus has no phi nodes), use it 3752bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner/// instead of introducing a new block. 3753bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattnerstatic void SplitEdgeNicely(TerminatorInst *TI, unsigned SuccNum, Pass *P) { 3754bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BasicBlock *TIBB = TI->getParent(); 3755bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BasicBlock *Dest = TI->getSuccessor(SuccNum); 3756bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner assert(isa<PHINode>(Dest->begin()) && 3757bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner "This should only be called if Dest has a PHI!"); 3758bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3759bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner /// TIPHIValues - This array is lazily computed to determine the values of 3760bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner /// PHIs in Dest that TI would provide. 3761bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner std::vector<Value*> TIPHIValues; 3762bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3763bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Check to see if Dest has any blocks that can be used as a split edge for 3764bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // this terminator. 3765bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner for (pred_iterator PI = pred_begin(Dest), E = pred_end(Dest); PI != E; ++PI) { 3766bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BasicBlock *Pred = *PI; 3767bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // To be usable, the pred has to end with an uncond branch to the dest. 3768bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner BranchInst *PredBr = dyn_cast<BranchInst>(Pred->getTerminator()); 3769bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (!PredBr || !PredBr->isUnconditional() || 3770bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Must be empty other than the branch. 3771bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner &Pred->front() != PredBr) 3772bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner continue; 3773bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3774bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Finally, since we know that Dest has phi nodes in it, we have to make 3775bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // sure that jumping to Pred will have the same affect as going to Dest in 3776bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // terms of PHI values. 3777bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner PHINode *PN; 3778bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner unsigned PHINo = 0; 3779bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner bool FoundMatch = true; 3780bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner for (BasicBlock::iterator I = Dest->begin(); 3781bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner (PN = dyn_cast<PHINode>(I)); ++I, ++PHINo) { 3782bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (PHINo == TIPHIValues.size()) 3783bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner TIPHIValues.push_back(PN->getIncomingValueForBlock(TIBB)); 3784bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3785bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // If the PHI entry doesn't work, we can't use this pred. 3786bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (TIPHIValues[PHINo] != PN->getIncomingValueForBlock(Pred)) { 3787bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner FoundMatch = false; 3788bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner break; 3789bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 3790bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 3791bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3792bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // If we found a workable predecessor, change TI to branch to Succ. 3793bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (FoundMatch) { 3794bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner Dest->removePredecessor(TIBB); 3795bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner TI->setSuccessor(SuccNum, Pred); 3796bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner return; 3797bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 3798bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner } 3799bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3800bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner SplitCriticalEdge(TI, SuccNum, P, true); 3801bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner} 3802bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 3803bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 38041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 38051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 38061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 3807832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "\n\n\n=== " << Fn.getName() << "\n"; 38081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 380947e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner // First, split all critical edges. 3810c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 38117e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // In this pass we also look for GEP and cast instructions that are used 38127e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // across basic blocks and rewrite them to improve basic-block-at-a-time 38137e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // selection. 38147e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // 3815903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = true; 3816903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (MadeChange) { 3817903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = false; 381836b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 3819bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner // Split all critical edges where the dest block has a PHI. 382047e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner TerminatorInst *BBTI = BB->getTerminator(); 382147e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner if (BBTI->getNumSuccessors() > 1) { 382247e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner for (unsigned i = 0, e = BBTI->getNumSuccessors(); i != e; ++i) 3823bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner if (isa<PHINode>(BBTI->getSuccessor(i)->begin()) && 3824bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner isCriticalEdge(BBTI, i, true)) 3825bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner SplitEdgeNicely(BBTI, i, this); 382647e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner } 382747e32e6b831dad8289fd498c71c5f641172b1c09Chris Lattner 3828c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 382957f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) { 38307e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *I = BBI++; 38313f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner 38323f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (CallInst *CI = dyn_cast<CallInst>(I)) { 38333f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner // If we found an inline asm expession, and if the target knows how to 38343f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner // lower it to normal LLVM code, do so now. 38353f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (isa<InlineAsm>(CI->getCalledValue())) 38363f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (const TargetAsmInfo *TAI = 38373f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner TLI.getTargetMachine().getTargetAsmInfo()) { 38383f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner if (TAI->ExpandInlineAsm(CI)) 38393f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner BBI = BB->begin(); 38403f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner } 38413f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) { 3842903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeGEPExpression(GEPI, TLI.getTargetData()); 38437e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } else if (CastInst *CI = dyn_cast<CastInst>(I)) { 3844c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // If the source of the cast is a constant, then this should have 3845c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // already been constant folded. The only reason NOT to constant fold 3846c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // it is if something (e.g. LSR) was careful to place the constant 3847c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // evaluation in a block other than then one that uses it (e.g. to hoist 3848c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // the address of globals out of a loop). If this is the case, we don't 3849c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // want to forward-subst the cast. 3850c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner if (isa<Constant>(CI->getOperand(0))) 3851c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner continue; 3852c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner 38537e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is a noop copy, sink it into user blocks to reduce the number 38547e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // of virtual registers that must be created and coallesced. 38557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType SrcVT = TLI.getValueType(CI->getOperand(0)->getType()); 38567e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType DstVT = TLI.getValueType(CI->getType()); 38577e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38587e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // This is an fp<->int conversion? 38597e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (MVT::isInteger(SrcVT) != MVT::isInteger(DstVT)) 38607e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner continue; 38617e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38627e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is an extension, it will be a zero or sign extension, which 38637e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // isn't a noop. 38647e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT < DstVT) continue; 38657e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38667e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If these values will be promoted, find out what they will be promoted 38677e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // to. This helps us consider truncates on PPC as noop copies when they 38687e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // are. 38697e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(SrcVT) == TargetLowering::Promote) 38707e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner SrcVT = TLI.getTypeToTransformTo(SrcVT); 38717e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(DstVT) == TargetLowering::Promote) 38727e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner DstVT = TLI.getTypeToTransformTo(DstVT); 38737e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 38747e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If, after promotion, these are the same types, this is a noop copy. 38757e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT == DstVT) 3876903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeNoopCopyExpression(CI); 38777e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 38787e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 387936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 3880903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3881c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 38821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 38831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 38841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 38851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 3886edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 38871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 38881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 38891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3890571e434a34e26f295f13db2dd07551de7e25f8a9Chris LattnerSDOperand SelectionDAGLowering::CopyValueToVirtualRegister(Value *V, 3891571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg) { 3892571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Op = getValue(V); 389318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 3894d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 389518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 3896d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 3897d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 3898d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 3899d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 3900d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 3901d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 3902571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return DAG.getCopyToReg(getRoot(), Reg, Op); 39031c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } else if (SrcVT == MVT::Vector) { 390470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Handle copies from generic vectors to registers. 390570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 390670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NE = TLI.getPackedTypeBreakdown(cast<PackedType>(V->getType()), 390770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT, PTyLegalElementVT); 39081c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 390970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Insert a VBIT_CONVERT of the input vector to a "N x PTyElementVT" 391070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // MVT::Vector type. 391170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Op, 391270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getConstant(NE, MVT::i32), 391370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getValueType(PTyElementVT)); 391470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 391570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Loop over all of the elements of the resultant vector, 391670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // VEXTRACT_VECTOR_ELT'ing them, converting them to PTyLegalElementVT, then 391770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // copying them into output registers. 3918bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 3919571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Root = getRoot(); 392070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 392170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Elt = DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, PTyElementVT, 3922a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(i, TLI.getPointerTy())); 392370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 392470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are legal. 392570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 392670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyLegalElementVT > PTyElementVT) { 392770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are promoted. 392870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyLegalElementVT)) 392970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::FP_EXTEND, PTyLegalElementVT, Elt); 393070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 393170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::ANY_EXTEND, PTyLegalElementVT, Elt); 393270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 393370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 393470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are expanded. 393570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // The src value is expanded into multiple registers. 393670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 3937a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(0, TLI.getPointerTy())); 393870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 3939a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(1, TLI.getPointerTy())); 394070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Lo)); 394170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Hi)); 394270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 39431c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } 3944bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, 3945bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 39469f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng } else if (TLI.getTypeAction(SrcVT) == TargetLowering::Promote) { 3947d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 3948fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 3949fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 3950fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 3951fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 3952571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return DAG.getCopyToReg(getRoot(), Reg, Op); 3953d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 39549f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng DestVT = TLI.getTypeToExpandTo(SrcVT); 39559f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng unsigned NumVals = TLI.getNumElements(SrcVT); 39569f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng if (NumVals == 1) 39579f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng return DAG.getCopyToReg(getRoot(), Reg, 39589f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng DAG.getNode(ISD::BIT_CONVERT, DestVT, Op)); 39599f87788040786b1bc6530763e4cf7e105bfb2924Evan Cheng assert(NumVals == 2 && "1 to 4 (and more) expansion not implemented!"); 3960d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 3961d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 3962a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(0, TLI.getPointerTy())); 3963d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 3964a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(1, TLI.getPointerTy())); 3965571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Op = DAG.getCopyToReg(getRoot(), Reg, Lo); 3966d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 3967d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 39681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 39691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3970068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 3971068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 3972068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 39731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 3974068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 39750afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 3976bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 3977bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 3978bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3979bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 3980bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 3981bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 3982bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 3983bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 3984f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 3985bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 3986bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 3987bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 3988bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 3989571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(AI, FuncInfo.ValueMap[AI]); 3990bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 3991bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 39920afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 3993bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3994bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 3995966454129dc62260df1f438f0243f6877dcd185cChris Lattner // FIXME: this should insert code into the DAG! 3996bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 3997068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 3998068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3999068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 4000068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 4001f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 4002068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 4003068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 4004068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 4005edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 4006bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 4007bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 4008bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 40091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 40111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 40121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 40141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 40151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 40161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 4017f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 40181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 40191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 40201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 4021f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 4022ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 40231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 4024ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 4025571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(I, VMI->second)); 40261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 40271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 40291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 40301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 40311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 40321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 40331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 4034edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 40358c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 40361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 40381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 4039d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 40408c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Vector bool would be better, but vector<bool> is really slow. 40418c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner std::vector<unsigned char> SuccsHandled; 40428c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (TI->getNumSuccessors()) 40438c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled.resize(BB->getParent()->getNumBlockIDs()); 40448c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 40451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 40461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 40471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 40481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 4049d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (!isa<PHINode>(SuccBB->begin())) continue; 40508c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 4051d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 40528c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // If this terminator has multiple identical successors (common for 40538c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // switches), only handle each succ once. 40548c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned SuccMBBNo = SuccMBB->getNumber(); 40558c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (SuccsHandled[SuccMBBNo]) continue; 40568c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled[SuccMBBNo] = true; 40578c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 40588c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 40591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 40601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 40621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 40631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 40641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 40658c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner (PN = dyn_cast<PHINode>(I)); ++I) { 40668c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Ignore dead phi's. 40678c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (PN->use_empty()) continue; 40688c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 40698c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned Reg; 40708c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 40713f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner 40728c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 40738c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned &RegOut = ConstantsOut[C]; 40748c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (RegOut == 0) { 40758c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner RegOut = FuncInfo.CreateRegForValue(C); 40768c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner UnorderedChains.push_back( 40778c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SDL.CopyValueToVirtualRegister(C, RegOut)); 40781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 40798c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = RegOut; 40808c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } else { 40818c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 40828c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Reg == 0) { 40838c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner assert(isa<AllocaInst>(PHIOp) && 40848c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 40858c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner "Didn't codegen value into a register!??"); 40868c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 40878c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner UnorderedChains.push_back( 40888c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SDL.CopyValueToVirtualRegister(PHIOp, Reg)); 40897e02151ce2686687446ba7293e66d6b096106e68Chris Lattner } 40901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 40918c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 40928c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Remember that this register needs to added to the machine PHI node as 40938c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // the input for this MBB. 40948c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 40958c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned NumElements; 40968c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (VT != MVT::Vector) 40978c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner NumElements = TLI.getNumElements(VT); 40988c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner else { 40998c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT1,VT2; 41008c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner NumElements = 41018c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 41028c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner VT1, VT2); 41038c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 41048c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 41058c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 41068c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 41071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 41081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 41091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4110ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 41115a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 41127436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 41137436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 41147436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 41157436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 41167436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 41177436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 41187436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 41197436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 41207436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 41217436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 41227436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 41237436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 4124bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 4125bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &UnorderedChains[0], UnorderedChains.size())); 4126ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 4127ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 41281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 41291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 4130a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 4131f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 413237efe6764568a3829fee26aba532283131d1a104Nate Begeman // lowering, as well as any jump table information. 4133f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 4134f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 413537efe6764568a3829fee26aba532283131d1a104Nate Begeman JT = SDL.JT; 4136f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4137a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 4138a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 41391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 41401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4141f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 4142c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey // Get alias analysis for load/store combining. 4143c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AliasAnalysis &AA = getAnalysis<AliasAnalysis>(); 4144c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey 4145af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 4146c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey DAG.Combine(false, AA); 41472300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 4148832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Lowered selection DAG:\n"; 41491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 4150f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 41511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 41521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 4153ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 4154f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4155832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Legalized selection DAG:\n"; 41561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 4157f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4158af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 4159c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey DAG.Combine(true, AA); 41602300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 4161a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 4162552c4a849422ad91fa9988255ae35aebbf3acf7bEvan Cheng 4163a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 4164a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 41651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 4166f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4167832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Selected machine code:\n"; 41681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 4169f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 4170f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4171f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 4172f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 4173f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 4174f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 417544c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 4176f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 4177f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4178f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 4179f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 4180f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 41811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4182f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 4183f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 4184f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4185f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4186a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 41871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 418837efe6764568a3829fee26aba532283131d1a104Nate Begeman if (SwitchCases.empty() && JT.Reg == 0) { 4189f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 4190f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 4191f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 4192f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 419309e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 4194f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 4195f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4196f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 41971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4198f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 41999453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 42009453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 42019453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 420237efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.Reg) { 420337efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(SwitchCases.empty() && "Cannot have jump table and lowered switch"); 420444c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 420537efe6764568a3829fee26aba532283131d1a104Nate Begeman CurDAG = &SDAG; 420637efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 42079453eea49bca1c3904047db495855c93e001d1cdNate Begeman MachineBasicBlock *RangeBB = BB; 420837efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 420937efe6764568a3829fee26aba532283131d1a104Nate Begeman BB = JT.MBB; 421037efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.setCurrentBasicBlock(BB); 421137efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 421237efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.visitJumpTable(JT); 421337efe6764568a3829fee26aba532283131d1a104Nate Begeman SDAG.setRoot(SDL.getRoot()); 421437efe6764568a3829fee26aba532283131d1a104Nate Begeman CodeGenAndEmitDAG(SDAG); 421537efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 421637efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 421737efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 421837efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 421937efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 422037efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 4221f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (PHIBB == JT.Default) { 422209e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 4223f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(RangeBB); 4224f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 4225f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (BB->succ_end() != std::find(BB->succ_begin(),BB->succ_end(), PHIBB)) { 422609e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 4227f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(BB); 422837efe6764568a3829fee26aba532283131d1a104Nate Begeman } 422937efe6764568a3829fee26aba532283131d1a104Nate Begeman } 423037efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 423137efe6764568a3829fee26aba532283131d1a104Nate Begeman } 423237efe6764568a3829fee26aba532283131d1a104Nate Begeman 4233b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // If the switch block involved a branch to one of the actual successors, we 4234b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // need to update PHI nodes in that block. 4235b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 4236b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 4237b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 4238b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner "This is not a machine PHI node that we are updating!"); 4239b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (BB->isSuccessor(PHI->getParent())) { 4240b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 4241b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner PHI->addMachineBasicBlockOperand(BB); 4242b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 4243b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 4244b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner 4245f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 4246f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 4247d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 424844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 4249f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 4250f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 4251d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4252f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 4253f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 4254f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 4255d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4256f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 4257f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 4258f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 4259f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 4260d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4261d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Handle any PHI nodes in successors of this chunk, as if we were coming 4262d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // from the original BB before switch expansion. Note that PHI nodes can 4263d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // occur multiple times in PHINodesToUpdate. We have to be very careful to 4264d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // handle them the right number of times. 426557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner while ((BB = SwitchCases[i].TrueBB)) { // Handle LHS and RHS. 4266d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (MachineBasicBlock::iterator Phi = BB->begin(); 4267d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi != BB->end() && Phi->getOpcode() == TargetInstrInfo::PHI; ++Phi){ 4268d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // This value for this PHI node is recorded in PHINodesToUpdate, get it. 4269d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned pn = 0; ; ++pn) { 4270d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner assert(pn != PHINodesToUpdate.size() && "Didn't find PHI entry!"); 4271d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (PHINodesToUpdate[pn].first == Phi) { 4272d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addRegOperand(PHINodesToUpdate[pn].second, false); 4273d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addMachineBasicBlockOperand(SwitchCases[i].ThisBB); 4274d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner break; 4275d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 4276d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 4277f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4278d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4279d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Don't process RHS if same block as LHS. 428057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (BB == SwitchCases[i].FalseBB) 428157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 4282d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 4283d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // If we haven't handled the RHS, do so now. Otherwise, we're done. 42842452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner SwitchCases[i].TrueBB = SwitchCases[i].FalseBB; 428557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 4286f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 428757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner assert(SwitchCases[i].TrueBB == 0 && SwitchCases[i].FalseBB == 0); 4288a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 42891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 4290a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 429113ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 4292a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 4293a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 4294a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 4295a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 4296a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 429713ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 4298eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterScheduler::FunctionPassCtor Ctor = RegisterScheduler::getDefault(); 429913ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 430013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 4301eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = ISHeuristic; 43029373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey RegisterScheduler::setDefault(Ctor); 43034ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 430413ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 43059ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey ScheduleDAG *SL = Ctor(this, &DAG, BB); 4306a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 4307cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 4308a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 43090e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 431003fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 43119ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim LaskeyHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 43129ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey return new HazardRecognizer(); 43139ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey} 43149ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 4315755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 4316755480681c795d585c73556c028b6143c46bda86Chris Lattner// Helper functions used by the generated instruction selector. 4317755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 4318755480681c795d585c73556c028b6143c46bda86Chris Lattner// Calls to these methods are generated by tblgen. 4319755480681c795d585c73556c028b6143c46bda86Chris Lattner 4320755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckAndMask - The isel is trying to match something like (and X, 255). If 4321755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 4322755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an AND, and DesiredMaskS is the value 4323755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 4324755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckAndMask(SDOperand LHS, ConstantSDNode *RHS, 4325755480681c795d585c73556c028b6143c46bda86Chris Lattner int64_t DesiredMaskS) { 4326755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 4327755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 4328755480681c795d585c73556c028b6143c46bda86Chris Lattner 4329755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 4330755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 4331755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4332755480681c795d585c73556c028b6143c46bda86Chris Lattner 4333755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 4334755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 4335755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4336755480681c795d585c73556c028b6143c46bda86Chris Lattner 4337755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 4338755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 4339755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 4340755480681c795d585c73556c028b6143c46bda86Chris Lattner if (getTargetLowering().MaskedValueIsZero(LHS, NeededMask)) 4341755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4342755480681c795d585c73556c028b6143c46bda86Chris Lattner 4343755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 4344755480681c795d585c73556c028b6143c46bda86Chris Lattner 4345755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 4346755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4347755480681c795d585c73556c028b6143c46bda86Chris Lattner} 4348755480681c795d585c73556c028b6143c46bda86Chris Lattner 4349755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckOrMask - The isel is trying to match something like (or X, 255). If 4350755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 4351755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an OR, and DesiredMaskS is the value 4352755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 4353755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckOrMask(SDOperand LHS, ConstantSDNode *RHS, 4354755480681c795d585c73556c028b6143c46bda86Chris Lattner int64_t DesiredMaskS) { 4355755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 4356755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 4357755480681c795d585c73556c028b6143c46bda86Chris Lattner 4358755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 4359755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 4360755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4361755480681c795d585c73556c028b6143c46bda86Chris Lattner 4362755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 4363755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 4364755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4365755480681c795d585c73556c028b6143c46bda86Chris Lattner 4366755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 4367755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 4368755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 4369755480681c795d585c73556c028b6143c46bda86Chris Lattner 4370755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t KnownZero, KnownOne; 4371755480681c795d585c73556c028b6143c46bda86Chris Lattner getTargetLowering().ComputeMaskedBits(LHS, NeededMask, KnownZero, KnownOne); 4372755480681c795d585c73556c028b6143c46bda86Chris Lattner 4373755480681c795d585c73556c028b6143c46bda86Chris Lattner // If all the missing bits in the or are already known to be set, match! 4374755480681c795d585c73556c028b6143c46bda86Chris Lattner if ((NeededMask & KnownOne) == NeededMask) 4375755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4376755480681c795d585c73556c028b6143c46bda86Chris Lattner 4377755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 4378755480681c795d585c73556c028b6143c46bda86Chris Lattner 4379755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 4380755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4381755480681c795d585c73556c028b6143c46bda86Chris Lattner} 4382755480681c795d585c73556c028b6143c46bda86Chris Lattner 43839ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 43840e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 43850e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 43860e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 43870e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 43880e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 43890e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 43900e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 43910e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 43920e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 43930e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 43940e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 43950e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 43960e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 43970e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 43980e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 43990e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 44000e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 44010e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 44020e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 44030e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 44040e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 44050e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 44060e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 44070e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 44080e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 4409832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Could not match memory address. Inline asm failure!\n"; 44100e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 44110e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 44120e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 44130e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 441436d439666c9f9f781d57dc2fd6d3cc80602fe095Chris Lattner Ops.push_back(DAG.getTargetConstant(4/*MEM*/ | (SelOps.size() << 3), 441536d439666c9f9f781d57dc2fd6d3cc80602fe095Chris Lattner MVT::i32)); 44160e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 44170e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 44180e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 44190e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 44200e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 44210e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 44220e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 44230e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 44240e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 4425