SelectionDAGISel.cpp revision d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0
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" 27b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner#include "llvm/CodeGen/IntrinsicLowering.h" 28b2efb853f00d45b1c8d57f92acd0028fbdeffda6Jim Laskey#include "llvm/CodeGen/MachineDebugInfo.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 3137efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 33eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey#include "llvm/CodeGen/SchedulerRegistry.h" 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 36fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 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" 471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 484e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner#include <set> 491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 507e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 53da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 547944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 55a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 56a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 57a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 58a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 59a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 607944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 615e46a19ec848cd4fc9649bd5170c43d9e657668cChris Lattnerstatic const bool ViewISelDAGs = 0, ViewSchedDAGs = 0; 627944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 637944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 64eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 65eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 66eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 67eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// RegisterScheduler class - Track the registration of instruction schedulers. 68eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 69eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 70eb577ba3b815a1fa4627b060dd2345d17abf672dJim LaskeyMachinePassRegistry RegisterScheduler::Registry; 71eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey 72eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 73eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 74eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// ISHeuristic command line option for instruction schedulers. 75eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey/// 76eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey//===---------------------------------------------------------------------===// 774ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Chengnamespace { 78eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey cl::opt<RegisterScheduler::FunctionPassCtor, false, 79eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterPassParser<RegisterScheduler> > 8013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey ISHeuristic("sched", 813700f90c19f51deae00f85b80d31e1f7fbda1f99Chris Lattner cl::init(&createDefaultScheduler), 8213ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey cl::desc("Instruction schedulers available:")); 8313ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 849ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey static RegisterScheduler 859373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey defaultListDAGScheduler("default", " Best scheduler for the target", 869373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey createDefaultScheduler); 874ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng} // namespace 884ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 89864635ad7b3046d3042311423071152c613961deChris Lattnernamespace { 90864635ad7b3046d3042311423071152c613961deChris Lattner /// RegsForValue - This struct represents the physical registers that a 91864635ad7b3046d3042311423071152c613961deChris Lattner /// particular value is assigned and the type information about the value. 92864635ad7b3046d3042311423071152c613961deChris Lattner /// This is needed because values can be promoted into larger registers and 93864635ad7b3046d3042311423071152c613961deChris Lattner /// expanded into multiple smaller registers than the value. 949525528a7dc5462b6374d38c81ba5c07b11741feChris Lattner struct VISIBILITY_HIDDEN RegsForValue { 95864635ad7b3046d3042311423071152c613961deChris Lattner /// Regs - This list hold the register (for legal and promoted values) 96864635ad7b3046d3042311423071152c613961deChris Lattner /// or register set (for expanded values) that the value should be assigned 97864635ad7b3046d3042311423071152c613961deChris Lattner /// to. 98864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 99864635ad7b3046d3042311423071152c613961deChris Lattner 100864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT - The value type of each register. 101864635ad7b3046d3042311423071152c613961deChris Lattner /// 102864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 103864635ad7b3046d3042311423071152c613961deChris Lattner 104864635ad7b3046d3042311423071152c613961deChris Lattner /// ValueVT - The value type of the LLVM value, which may be promoted from 105864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT or made from merging the two expanded parts. 106864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT; 107864635ad7b3046d3042311423071152c613961deChris Lattner 108864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue() : RegVT(MVT::Other), ValueVT(MVT::Other) {} 109864635ad7b3046d3042311423071152c613961deChris Lattner 110864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(unsigned Reg, MVT::ValueType regvt, MVT::ValueType valuevt) 111864635ad7b3046d3042311423071152c613961deChris Lattner : RegVT(regvt), ValueVT(valuevt) { 112864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 113864635ad7b3046d3042311423071152c613961deChris Lattner } 114864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(const std::vector<unsigned> ®s, 115864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType regvt, MVT::ValueType valuevt) 116864635ad7b3046d3042311423071152c613961deChris Lattner : Regs(regs), RegVT(regvt), ValueVT(valuevt) { 117864635ad7b3046d3042311423071152c613961deChris Lattner } 118864635ad7b3046d3042311423071152c613961deChris Lattner 119864635ad7b3046d3042311423071152c613961deChris Lattner /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from 120864635ad7b3046d3042311423071152c613961deChris Lattner /// this value and returns the result as a ValueVT value. This uses 121864635ad7b3046d3042311423071152c613961deChris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 122864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand getCopyFromRegs(SelectionDAG &DAG, 1239f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const; 124c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 125c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 126c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// specified value into the registers specified by this object. This uses 127c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 128c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 129a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 130a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const; 131c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 132c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// AddInlineAsmOperands - Add this value to the specified inlineasm node 133c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// operand list. This adds the code marker and includes the number of 134c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// values added into it. 135c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 1369f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const; 137864635ad7b3046d3042311423071152c613961deChris Lattner }; 138864635ad7b3046d3042311423071152c613961deChris Lattner} 1394ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 1401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 1411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 1429373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// createDefaultScheduler - This creates an instruction scheduler appropriate 1439373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// for the target. 1449373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey ScheduleDAG* createDefaultScheduler(SelectionDAGISel *IS, 1459373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey SelectionDAG *DAG, 1469373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey MachineBasicBlock *BB) { 1479373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering &TLI = IS->getTargetLowering(); 1489373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1499373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) { 1509373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createTDListDAGScheduler(IS, DAG, BB); 1519373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } else { 1529373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey assert(TLI.getSchedulingPreference() == 1539373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering::SchedulingForRegPressure && "Unknown sched type!"); 1549373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createBURRListDAGScheduler(IS, DAG, BB); 1559373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1569373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1579373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1589373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1599373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey //===--------------------------------------------------------------------===// 1601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 1611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 162f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 163f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 1651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 1661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 1671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 1681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 1701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 1861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 187571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 188571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner /// isExportedInst - Return true if the specified value is an instruction 189571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner /// exported from its block. 190571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner bool isExportedInst(const Value *V) { 191571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return ValueMap.count(V); 192571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 193edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1943c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned CreateRegForValue(const Value *V); 1953c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 2001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 2021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 205f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// PHI nodes or outside of the basic block that defines it, or used by a 206f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// switch instruction, which may expand to multiple basic blocks. 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 2081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 2101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 211f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI) || 212571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // FIXME: Remove switchinst special case. 213f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman isa<SwitchInst>(*UI)) 2141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 2151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 2161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 218bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 219f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// entry block, return true. This includes arguments used by switches, since 220f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the switch may expand into multiple basic blocks. 221bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 222bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 223bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 224f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != Entry || isa<SwitchInst>(*UI)) 225bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 226bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 227bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 228bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 230edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 2311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 2321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 233bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 234bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 23516ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 23616ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 237bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 238bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 2391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 240bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 241bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 242bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 2432aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 2441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 246b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (ConstantInt *CUI = dyn_cast<ConstantInt>(AI->getArraySize())) { 2471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 248a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 249ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 250a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson std::max((unsigned)TLI.getTargetData()->getTypeAlignment(Ty), 251ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 252a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 253b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer // If the alignment of the value is smaller than the size of the 254b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer // value, and if the size of the value is particularly small 255b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer // (<= 8 bytes), round up to the size of the value for potentially 256b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer // better performance. 257a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // 258a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // FIXME: This could be made better with a preferred alignment hook in 259a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // TargetData. It serves primarily to 8-byte align doubles for X86. 260a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner if (Align < TySize && TySize <= 8) Align = TySize; 261b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer TySize *= CUI->getZExtValue(); // Get total allocated size. 262d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 264f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2672aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 2682aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 2701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 2711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 2721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 2772aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 2781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 2791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 2801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 2811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 2831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 2841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 2851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 286f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 287f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 28870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 28970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NumElements; 29070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) 29170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner NumElements = TLI.getNumElements(VT); 29270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else { 29370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType VT1,VT2; 29470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner NumElements = 29570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 29670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner VT1, VT2); 29770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 298f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 299f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 300f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 301f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 302f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 3031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 3051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3063c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// CreateRegForValue - Allocate the appropriate number of virtual registers of 3073c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// the correctly promoted or expanded types. Assign these registers 3083c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// consecutive vreg numbers and return the first assigned number. 3093c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattnerunsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) { 3103c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 3113c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3123c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The number of multiples of registers that we need, to, e.g., split up 3133c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // a <2 x int64> -> 4 x i32 registers. 3143c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumVectorRegs = 1; 3153c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3163c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a packed type, figure out what type it will decompose into 3173c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // and how many of the elements it will use. 3183c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (VT == MVT::Vector) { 3193c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner const PackedType *PTy = cast<PackedType>(V->getType()); 3203c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumElts = PTy->getNumElements(); 3213c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType EltTy = TLI.getValueType(PTy->getElementType()); 3223c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3233c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // Divide the input until we get to a supported size. This will always 3243c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // end with a scalar if the target doesn't support vectors. 3253c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (NumElts > 1 && !TLI.isTypeLegal(getVectorType(EltTy, NumElts))) { 3263c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumElts >>= 1; 3273c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumVectorRegs <<= 1; 3283c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3296cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner if (NumElts == 1) 3306cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = EltTy; 3316cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner else 3326cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = getVectorType(EltTy, NumElts); 3333c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3343c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3353c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The common case is that we will only create one register for this 3363c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // value. If we have that case, create and return the virtual register. 3373c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NV = TLI.getNumElements(VT); 3383c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (NV == 1) { 3393c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If we are promoting this value, pick the next largest supported type. 3403c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType PromotedType = TLI.getTypeToTransformTo(VT); 3413c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned Reg = MakeReg(PromotedType); 3423c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a vector of supported or promoted types (e.g. 4 x i16), 3433c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // create all of the registers. 3443c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NumVectorRegs; ++i) 3453c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg(PromotedType); 3463c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return Reg; 3473c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3483c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3493c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this value is represented with multiple target registers, make sure 3503c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // to create enough consecutive registers of the right (smaller) type. 3513c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NT = VT-1; // Find the type to use. 3523c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 3533c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner --NT; 3543c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3553c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 3563c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NV*NumVectorRegs; ++i) 3573c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg((MVT::ValueType)NT); 3583c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return R; 3593c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner} 3601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 3621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 3631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 3641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 3651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 3661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 3671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 3681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 3691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 3711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 372d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 373d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 374d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 375d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 376d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 377d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Case - A pair of values to record the Value for a switch case, and the 379f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// case's target basic block. 380f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<Constant*, MachineBasicBlock*> Case; 381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::vector<Case>::iterator CaseItr; 382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<CaseItr, CaseItr> CaseRange; 383f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 384f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseRec - A struct with ctor used in lowering switches to a binary tree 385f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// of conditional branches. 386f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseRec { 387f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec(MachineBasicBlock *bb, Constant *lt, Constant *ge, CaseRange r) : 388f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseBB(bb), LT(lt), GE(ge), Range(r) {} 389f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 390f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseBB - The MBB in which to emit the compare and branch 391f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *CaseBB; 392f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// LT, GE - If nonzero, we know the current case value must be less-than or 393f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// greater-than-or-equal-to these Constants. 394f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *LT; 395f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *GE; 396f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Range - A pair of iterators representing the range of case values to be 397f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// processed at this point in the binary search tree. 398f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange Range; 399f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 400f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 401f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// The comparison function for sorting Case values. 402f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 403f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman bool operator () (const Case& C1, const Case& C2) { 404b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (const ConstantInt* I1 = dyn_cast<const ConstantInt>(C1.first)) 405b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (I1->getType()->isUnsigned()) 406b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer return I1->getZExtValue() < 407b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer cast<const ConstantInt>(C2.first)->getZExtValue(); 408f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 409b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer return cast<const ConstantInt>(C1.first)->getSExtValue() < 410b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer cast<const ConstantInt>(C2.first)->getSExtValue(); 411f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 412f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 413f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 4151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 4171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 4181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 420a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD; 4211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 422f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 423f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 424f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 42537efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGISel::JumpTable JT; 426f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 4281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 4291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 4301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 432edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 4331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 4349453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT(0,0,0,0), FuncInfo(funcinfo) { 4351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 437a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 438a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 439a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 440d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 441d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 442edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 443d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 444d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 445d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 446d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 447d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 448d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 449d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 450d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 451bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, 452bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &PendingLoads[0], PendingLoads.size()); 453d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 454d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 455d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 456a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 457a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 458571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand CopyValueToVirtualRegister(Value *V, unsigned Reg); 459571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 47528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 476466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 47728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile); 4781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 4801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 483199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 4861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4904e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 491864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue GetRegistersForValue(const std::string &ConstrCode, 492864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, 493864635ad7b3046d3042311423071152c613961deChris Lattner bool OutReg, bool InReg, 494864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 495864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &InputRegs); 496f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 497571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void FindMergedConditions(Value *Cond, MachineBasicBlock *TBB, 498571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, MachineBasicBlock *CurBB, 499571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc); 500571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void ExportFromCurrentBlock(Value *V); 501571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 5021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 5031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 5041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 505f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 5061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 5071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 508f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Helper for visitSwitch 509f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 51037efe6764568a3829fee26aba532283131d1a104Nate Begeman void visitJumpTable(SelectionDAGISel::JumpTable &JT); 511f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 5121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 5131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 5141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 5151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5161628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitIntBinary(User &I, unsigned IntOp, unsigned VecOp); 5171628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitFPBinary(User &I, unsigned FPOp, unsigned VecOp); 518e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 5195fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 5201628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer if (I.getType()->isFloatingPoint()) 5211628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitFPBinary(I, ISD::FADD, ISD::VADD); 5221628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 5231628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitIntBinary(I, ISD::ADD, ISD::VADD); 52401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 525b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 5261628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitMul(User &I) { 5271628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer if (I.getType()->isFloatingPoint()) 5281628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitFPBinary(I, ISD::FMUL, ISD::VMUL); 5291628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 5301628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitIntBinary(I, ISD::MUL, ISD::VMUL); 5311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5321628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitUDiv(User &I) { visitIntBinary(I, ISD::UDIV, ISD::VUDIV); } 5331628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitSDiv(User &I) { visitIntBinary(I, ISD::SDIV, ISD::VSDIV); } 5341628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitFDiv(User &I) { visitFPBinary(I, ISD::FDIV, ISD::VSDIV); } 5351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 53601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 5371628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer if (Ty->isFloatingPoint()) 5381628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitFPBinary(I, ISD::FREM, 0); 5391628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 5401628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitIntBinary(I, Ty->isSigned() ? ISD::SREM : ISD::UREM, 0); 5411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5421628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitAnd(User &I) { visitIntBinary(I, ISD::AND, ISD::VAND); } 5431628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitOr (User &I) { visitIntBinary(I, ISD::OR, ISD::VOR); } 5441628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitXor(User &I) { visitIntBinary(I, ISD::XOR, ISD::VXOR); } 545e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShl(User &I) { visitShift(I, ISD::SHL); } 546e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShr(User &I) { 547e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman visitShift(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 5481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 550f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc, 551f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::CondCode FPOpc); 552f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ, 553f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOEQ); } 554f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE, 555f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETUNE); } 556f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE, 557f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOLE); } 558f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE, 559f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOGE); } 560f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT, 561f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOLT); } 562f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT, 563f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::SETOGT); } 5641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5652bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5662bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 5673e104b11168da4692b69cc6b236c1da22adff959Chris Lattner void visitShuffleVector(User &I); 568c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 5711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 580ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner void visitInlineAsm(CallInst &I); 581c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 5820eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 5831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 5851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 5861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 5871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 58839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 5891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5907041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 5911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 5931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 5941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 5971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 5981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 6011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 6021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 603199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 604199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 605199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 606199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 607199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 608199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 609199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 610199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 611199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 612199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 613199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 614199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 615199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 616199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 617199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 618199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 61923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner if (!isa<PackedType>(VTy)) 62023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 62123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 622b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR of undef nodes. 62323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner const PackedType *PTy = cast<PackedType>(VTy); 62423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 62523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 62623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 627bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 62823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 62923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 63023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 63123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 63223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 633bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, 634bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 635199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 636199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 637199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (const PackedType *PTy = dyn_cast<PackedType>(VTy)) { 638199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 639199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 640199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 641199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 642199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 643199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // the packed constant. 644bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 645199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) { 6462bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 6472bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 648199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 649199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 650199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 651199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 652199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 653199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 654199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 655199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 656199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 657199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 658b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR node with generic Vector type. 65923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 66023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 661bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR,MVT::Vector,&Ops[0],Ops.size()); 662199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 663199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 664b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer return N = DAG.getConstant(cast<ConstantIntegral>(C)->getZExtValue(),VT); 665199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 666199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 667199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 668199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 669199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 670199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 671199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 672199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 673199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 674199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 675199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 676199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.ValueMap.find(V); 677199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 678199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 679199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned InReg = VMI->second; 680199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 681199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // If this type is not legal, make it so now. 68270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) { 68370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 684199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 68570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 68670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (DestVT < VT) { 68770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Source must be expanded. This input value is actually coming from the 68870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // register pair VMI->second and VMI->second+1. 68970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 69070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 69170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (DestVT > VT) { // Promotion case 692199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(VT)) 693199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::FP_ROUND, VT, N); 694199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 695199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::TRUNCATE, VT, N); 696199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 69770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 69870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Otherwise, if this is a vector, make it available as a generic vector 69970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // here. 70070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 7012e2ef9535070bb352601482cceac1140c1158cddChris Lattner const PackedType *PTy = cast<PackedType>(VTy); 7022e2ef9535070bb352601482cceac1140c1158cddChris Lattner unsigned NE = TLI.getPackedTypeBreakdown(PTy, PTyElementVT, 70370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyLegalElementVT); 70470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 70570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Build a VBUILD_VECTOR with the input registers. 706bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 70770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 70870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the value types are legal, just VBUILD the CopyFromReg nodes. 70970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) 71070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 71170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT)); 71270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyElementVT < PTyLegalElementVT) { 71370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was promoted, use TRUNCATE of FP_ROUND as appropriate. 71470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 71570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 71670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 71770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyElementVT)) 71870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::FP_ROUND, PTyElementVT, Op); 71970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 72070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::TRUNCATE, PTyElementVT, Op); 72170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(Op); 72270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 72370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 72470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was expanded, use BUILD_PAIR. 72570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner assert((NE & 1) == 0 && "Must expand into a multiple of 2 elements!"); 72670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE/2; ++i) { 72770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op0 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 72870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 72970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op1 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 73070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 73170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Op0, Op1)); 73270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 73370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 73470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 73570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getConstant(NE, MVT::i32)); 73670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getValueType(PTyLegalElementVT)); 737bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, &Ops[0], Ops.size()); 7382e2ef9535070bb352601482cceac1140c1158cddChris Lattner 7392e2ef9535070bb352601482cceac1140c1158cddChris Lattner // Finally, use a VBIT_CONVERT to make this available as the appropriate 7402e2ef9535070bb352601482cceac1140c1158cddChris Lattner // vector type. 7412e2ef9535070bb352601482cceac1140c1158cddChris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 7422e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getConstant(PTy->getNumElements(), 7432e2ef9535070bb352601482cceac1140c1158cddChris Lattner MVT::i32), 7442e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getValueType(TLI.getValueType(PTy->getElementType()))); 745199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 746199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 747199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 748199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 749199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 750199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 7511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 7521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 753a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 7541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 7551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 756bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> NewValues; 757ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 758ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 759ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 7608e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng bool isSigned = I.getOperand(i)->getType()->isSigned(); 761ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman 762ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // If this is an integer return value, we need to promote it ourselves to 763ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // the full width of a register, since LegalizeOp will use ANY_EXTEND rather 764ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // than sign/zero. 7658e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // FIXME: C calling convention requires the return type to be promoted to 7668e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // at least 32-bit. But this is not necessary for non-C calling conventions. 767ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (MVT::isInteger(RetOp.getValueType()) && 768ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp.getValueType() < MVT::i64) { 769ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman MVT::ValueType TmpVT; 770ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 771ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = TLI.getTypeToTransformTo(MVT::i32); 772ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 773ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = MVT::i32; 7741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7758e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng if (isSigned) 776ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, RetOp); 777ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 778ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, RetOp); 779ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 780ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(RetOp); 7818e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng NewValues.push_back(DAG.getConstant(isSigned, MVT::i32)); 7821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 783bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, 784bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &NewValues[0], NewValues.size())); 7851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 787571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// ExportFromCurrentBlock - If this condition isn't known to be exported from 788571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// the current basic block, add it to ValueMap now so that we'll get a 789571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// CopyTo/FromReg. 790571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::ExportFromCurrentBlock(Value *V) { 791571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // No need to export constants. 792571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (!isa<Instruction>(V) && !isa<Argument>(V)) return; 793571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 794571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Already exported? 795571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (FuncInfo.isExportedInst(V)) return; 796571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 797571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg = FuncInfo.InitializeRegForValue(V); 798571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner PendingLoads.push_back(CopyValueToVirtualRegister(V, Reg)); 799571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 800571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 801571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// FindMergedConditions - If Cond is an expression like 802571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::FindMergedConditions(Value *Cond, 803571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TBB, 804571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, 805571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *CurBB, 806571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc) { 807571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // FIXME: HANDLE AND. 808571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // FIXME: HANDLE NOT 809571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 810571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this node is not part of the or/and tree, emit it as a branch. 811571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BinaryOperator *BOp = dyn_cast<BinaryOperator>(Cond); 812571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 813571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (!BOp || (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() || 814571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getParent() != CurBB->getBasicBlock()) { 815571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner const BasicBlock *BB = CurBB->getBasicBlock(); 816571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 817571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If the leaf of the tree is a setcond inst, merge the condition into the 818571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // caseblock. 819571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BOp && isa<SetCondInst>(BOp) && 820571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // The operands of the setcc have to be in this block. We don't know 821571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // how to export them from some other block. 822571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner (!isa<Instruction>(BOp->getOperand(0)) || 823571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner cast<Instruction>(BOp->getOperand(0))->getParent() == BB || 824571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FuncInfo.isExportedInst(BOp->getOperand(0))) && 825571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner (!isa<Instruction>(BOp->getOperand(1)) || 826571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner cast<Instruction>(BOp->getOperand(1))->getParent() == BB || 827571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FuncInfo.isExportedInst(BOp->getOperand(1)))) { 828571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner ExportFromCurrentBlock(BOp->getOperand(0)); 829571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner ExportFromCurrentBlock(BOp->getOperand(1)); 830571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 831571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner ISD::CondCode SignCond, UnsCond, FPCond, Condition; 832571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner switch (BOp->getOpcode()) { 833571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner default: assert(0 && "Unknown setcc opcode!"); 834571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner case Instruction::SetEQ: 835571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SignCond = ISD::SETEQ; 836571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner UnsCond = ISD::SETEQ; 837571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FPCond = ISD::SETOEQ; 838571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner break; 839571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner case Instruction::SetNE: 840571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SignCond = ISD::SETNE; 841571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner UnsCond = ISD::SETNE; 842571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FPCond = ISD::SETUNE; 843571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner break; 844571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner case Instruction::SetLE: 845571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SignCond = ISD::SETLE; 846571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner UnsCond = ISD::SETULE; 847571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FPCond = ISD::SETOLE; 848571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner break; 849571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner case Instruction::SetGE: 850571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SignCond = ISD::SETGE; 851571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner UnsCond = ISD::SETUGE; 852571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FPCond = ISD::SETOGE; 853571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner break; 854571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner case Instruction::SetLT: 855571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SignCond = ISD::SETLT; 856571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner UnsCond = ISD::SETULT; 857571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FPCond = ISD::SETOLT; 858571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner break; 859571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner case Instruction::SetGT: 860571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SignCond = ISD::SETGT; 861571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner UnsCond = ISD::SETUGT; 862571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FPCond = ISD::SETOGT; 863571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner break; 864571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 865571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 866571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner const Type *OpType = BOp->getOperand(0)->getType(); 867571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (const PackedType *PTy = dyn_cast<PackedType>(OpType)) 868571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner OpType = PTy->getElementType(); 869571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 870571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (!FiniteOnlyFPMath() && OpType->isFloatingPoint()) 871571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Condition = FPCond; 872571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner else if (OpType->isUnsigned()) 873571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Condition = UnsCond; 874571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner else 875571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Condition = SignCond; 876571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 877571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SelectionDAGISel::CaseBlock CB(Condition, BOp->getOperand(0), 878571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOperand(1), TBB, FBB, CurBB); 879571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 880571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 881571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 882571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 883571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Create a CaseBlock record representing this branch. 884571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SelectionDAGISel::CaseBlock CB(ISD::SETEQ, Cond, ConstantBool::getTrue(), 885571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner TBB, FBB, CurBB); 886571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 887571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner ExportFromCurrentBlock(Cond); 888571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 889571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 890571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 891d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 892d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Create TmpBB after CurBB. 893571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineFunction::iterator BBI = CurBB; 894571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TmpBB = new MachineBasicBlock(CurBB->getBasicBlock()); 895571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner CurBB->getParent()->getBasicBlockList().insert(++BBI, TmpBB); 896571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 897d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner if (Opc == Instruction::Or) { 898d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X | Y as: 899d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TBB 900d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp TmpBB 901d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 902d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 903d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 904d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 905571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 906d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 907d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, Opc); 908d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 909d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 910d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 911d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } else { 912d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner assert(Opc == Instruction::And && "Unknown merge op!"); 913d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X & Y as: 914d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TmpBB 915d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 916d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 917d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 918d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 919d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 920d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // This requires creation of TmpBB after CurBB. 921d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 922d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 923d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, Opc); 924d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 925d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 926d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 927d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } 928571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 929571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 9301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 9311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 9321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 9331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 9351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 9361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 9371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 9381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 9391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 9411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 9421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 943a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 944dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 94557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 94657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // Update machine-CFG edges. 94757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(Succ0MBB); 94857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 94957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner return; 95057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner } 95157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 95257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // If this condition is one of the special cases we handle, do special stuff 95357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // now. 95457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Value *CondVal = I.getCondition(); 95557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 956571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 957571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this is a series of conditions that are or'd or and'd together, emit 958571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // this as a sequence of branches instead of setcc's with and/or operations. 959571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // For example, instead of something like: 960571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 961571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // C = seteq 962571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 963571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // F = setle 964571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // or C, F 965571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jnz foo 966571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Emit: 967571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 968571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // je foo 969571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 970571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jle foo 971571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // 972571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) { 973571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BOp->hasOneUse() && 974d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner (BOp->getOpcode() == Instruction::And || 975571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOpcode() == Instruction::Or)) { 976d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner if (BOp->getOpcode() == Instruction::And) 977d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner I.getParent()->dump(); 978571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FindMergedConditions(BOp, Succ0MBB, Succ1MBB, CurMBB, BOp->getOpcode()); 979571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner visitSwitchCase(SwitchCases[0]); 980571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.erase(SwitchCases.begin()); 981571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 982571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 983571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 9842452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner 9852452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Create a CaseBlock record representing this branch. 986571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SelectionDAGISel::CaseBlock CB(ISD::SETEQ, CondVal, ConstantBool::getTrue(), 9872452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner Succ0MBB, Succ1MBB, CurMBB); 9882452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Use visitSwitchCase to actually insert the fast branch sequence for this 9892452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // cond branch. 9902452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner visitSwitchCase(CB); 9911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 993f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 994f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 995f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 99657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand Cond; 99757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand CondLHS = getValue(CB.CmpLHS); 99857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 999571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Build the setcc now, fold "(X == true)" to X and "(X == false)" to !X to 1000571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // handle common cases produced by branch lowering. 1001571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (CB.CmpRHS == ConstantBool::getTrue() && CB.CC == ISD::SETEQ) 100257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Cond = CondLHS; 1003571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner else if (CB.CmpRHS == ConstantBool::getFalse() && CB.CC == ISD::SETEQ) { 1004571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand True = DAG.getConstant(1, CondLHS.getValueType()); 1005571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Cond = DAG.getNode(ISD::XOR, CondLHS.getValueType(), CondLHS, True); 1006571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } else 1007571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Cond = DAG.getSetCC(MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC); 1008f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1009f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 1010f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 1011f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1012f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1013f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 1014f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 1015f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1016f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 1017f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 101857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.TrueBB == NextBlock) { 101957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner std::swap(CB.TrueBB, CB.FalseBB); 1020f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 1021f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 1022f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1023f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 102457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.TrueBB)); 102557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.FalseBB == NextBlock) 1026f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 1027f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 1028f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 102957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.FalseBB))); 1030f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 103157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.TrueBB); 103257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.FalseBB); 1033f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1034f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 103537efe6764568a3829fee26aba532283131d1a104Nate Begemanvoid SelectionDAGLowering::visitJumpTable(SelectionDAGISel::JumpTable &JT) { 103637efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code for the jump table 103737efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType PTy = TLI.getPointerTy(); 10388825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng assert((PTy == MVT::i32 || PTy == MVT::i64) && 10398825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng "Jump table entries are 32-bit values"); 10402ae5b87996dca039d0721f1c463835f726979030Evan Cheng bool isPIC = TLI.getTargetMachine().getRelocationModel() == Reloc::PIC_; 10418825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng // PIC jump table entries are 32-bit values. 10422ae5b87996dca039d0721f1c463835f726979030Evan Cheng unsigned EntrySize = isPIC ? 4 : MVT::getSizeInBits(PTy)/8; 104337efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand Copy = DAG.getCopyFromReg(getRoot(), JT.Reg, PTy); 104437efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand IDX = DAG.getNode(ISD::MUL, PTy, Copy, 10458825a485e2e99216adc0c469a7c43895cd4eae40Evan Cheng DAG.getConstant(EntrySize, PTy)); 10462f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman SDOperand TAB = DAG.getJumpTable(JT.JTI,PTy); 10472f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman SDOperand ADD = DAG.getNode(ISD::ADD, PTy, IDX, TAB); 10482ae5b87996dca039d0721f1c463835f726979030Evan Cheng SDOperand LD = DAG.getLoad(isPIC ? MVT::i32 : PTy, Copy.getValue(1), ADD, 1049466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng NULL, 0); 10502ae5b87996dca039d0721f1c463835f726979030Evan Cheng if (isPIC) { 105116113431e84bb8adba21fc73bb5715a1297000aeAndrew Lenharth // For Pic, the sequence is: 105216113431e84bb8adba21fc73bb5715a1297000aeAndrew Lenharth // BRIND(load(Jumptable + index) + RelocBase) 105316113431e84bb8adba21fc73bb5715a1297000aeAndrew Lenharth // RelocBase is the JumpTable on PPC and X86, GOT on Alpha 105482c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth SDOperand Reloc; 105582c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth if (TLI.usesGlobalOffsetTable()) 105682c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth Reloc = DAG.getNode(ISD::GLOBAL_OFFSET_TABLE, PTy); 105782c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth else 105882c3d8f81ab20dc7571f29ffc46a5bb1b7ed8323Andrew Lenharth Reloc = TAB; 1059e236ac64a2b149ccf4216159430de512ec58a504Chris Lattner ADD = (PTy != MVT::i32) ? DAG.getNode(ISD::SIGN_EXTEND, PTy, LD) : LD; 1060e236ac64a2b149ccf4216159430de512ec58a504Chris Lattner ADD = DAG.getNode(ISD::ADD, PTy, ADD, Reloc); 10612f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRIND, MVT::Other, LD.getValue(1), ADD)); 10622f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } else { 10632f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRIND, MVT::Other, LD.getValue(1), LD)); 10642f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } 106537efe6764568a3829fee26aba532283131d1a104Nate Begeman} 106637efe6764568a3829fee26aba532283131d1a104Nate Begeman 1067f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitch(SwitchInst &I) { 1068f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 1069f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1070f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1071c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1072f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 1073f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 1074f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1075d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *Default = FuncInfo.MBBMap[I.getDefaultDest()]; 1076d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1077f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 1078f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 1079f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (I.getNumOperands() == 2) { 1080f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 1081c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1082f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 1083d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (Default != NextBlock) 1084f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1085d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner DAG.getBasicBlock(Default))); 1086c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1087d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurMBB->addSuccessor(Default); 1088f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 1089f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1090f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1091f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 1092f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 1093f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 1094f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<Case> Cases; 1095c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1096f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 1; i < I.getNumSuccessors(); ++i) { 1097f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *SMBB = FuncInfo.MBBMap[I.getSuccessor(i)]; 1098f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cases.push_back(Case(I.getSuccessorValue(i), SMBB)); 1099f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1100c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1101f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::sort(Cases.begin(), Cases.end(), CaseCmp()); 1102f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1103f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 1104f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 1105f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 1106f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Value *SV = I.getOperand(0); 110737efe6764568a3829fee26aba532283131d1a104Nate Begeman 110837efe6764568a3829fee26aba532283131d1a104Nate Begeman // Get the MachineFunction which holds the current MBB. This is used during 110937efe6764568a3829fee26aba532283131d1a104Nate Begeman // emission of jump tables, and when inserting any additional MBBs necessary 111037efe6764568a3829fee26aba532283131d1a104Nate Begeman // to represent the switch. 1111f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction *CurMF = CurMBB->getParent(); 1112f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const BasicBlock *LLVMBB = CurMBB->getBasicBlock(); 1113d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1114d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // If the switch has few cases (two or less) emit a series of specific 1115d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // tests. 1116b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (Cases.size() < 3) { 1117d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // TODO: If any two of the cases has the same destination, and if one value 1118d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // is the same as the other, but has one bit unset that the other has set, 1119d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // use bit manipulation to do two compares at once. For example: 1120d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // "if (X == 6 || X == 4)" -> "if ((X|2) == 6)" 1121d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1122b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner // Rearrange the case blocks so that the last one falls through if possible. 1123b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner if (NextBlock && Default != NextBlock && Cases.back().second != NextBlock) { 1124b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner // The last case block won't fall through into 'NextBlock' if we emit the 1125b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner // branches in this order. See if rearranging a case value would help. 1126b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner for (unsigned i = 0, e = Cases.size()-1; i != e; ++i) { 1127b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner if (Cases[i].second == NextBlock) { 1128b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner std::swap(Cases[i], Cases.back()); 1129b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner break; 1130b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner } 1131b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner } 1132b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner } 1133b354343af79ce7b64e3b32696f37ad0ce29f3ffdChris Lattner 1134d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // Create a CaseBlock record representing a conditional branch to 1135d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // the Case's target mbb if the value being switched on SV is equal 1136d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // to C. 1137d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *CurBlock = CurMBB; 1138d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner for (unsigned i = 0, e = Cases.size(); i != e; ++i) { 1139d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner MachineBasicBlock *FallThrough; 1140d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (i != e-1) { 1141d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner FallThrough = new MachineBasicBlock(CurMBB->getBasicBlock()); 1142d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurMF->getBasicBlockList().insert(BBI, FallThrough); 1143d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } else { 1144d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // If the last case doesn't match, go to the default block. 1145d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner FallThrough = Default; 1146d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } 1147d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1148d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, Cases[i].first, 1149d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner Cases[i].second, FallThrough, CurBlock); 1150d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1151d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // If emitting the first comparison, just call visitSwitchCase to emit the 1152d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // code into the current block. Otherwise, push the CaseBlock onto the 1153d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // vector to be later processed by SDISel, and insert the node's MBB 1154d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner // before the next MBB. 1155d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (CurBlock == CurMBB) 1156d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner visitSwitchCase(CB); 1157d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner else 1158d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner SwitchCases.push_back(CB); 1159d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 1160d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurBlock = FallThrough; 1161d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } 1162d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner return; 1163d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner } 116437efe6764568a3829fee26aba532283131d1a104Nate Begeman 116517c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // If the switch has more than 5 blocks, and at least 31.25% dense, and the 116617c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // target supports indirect branches, then emit a jump table rather than 116717c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman // lowering the switch to a binary tree of conditional branches. 11689453eea49bca1c3904047db495855c93e001d1cdNate Begeman if (TLI.isOperationLegal(ISD::BRIND, TLI.getPointerTy()) && 1169f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman Cases.size() > 5) { 1170b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer uint64_t First =cast<ConstantIntegral>(Cases.front().first)->getZExtValue(); 1171b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer uint64_t Last = cast<ConstantIntegral>(Cases.back().first)->getZExtValue(); 1172f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman double Density = (double)Cases.size() / (double)((Last - First) + 1ULL); 1173f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 117417c275ff2ce9e94d647e781f6dac6320d088f899Nate Begeman if (Density >= 0.3125) { 117537efe6764568a3829fee26aba532283131d1a104Nate Begeman // Create a new basic block to hold the code for loading the address 117637efe6764568a3829fee26aba532283131d1a104Nate Begeman // of the jump table, and jumping to it. Update successor information; 117737efe6764568a3829fee26aba532283131d1a104Nate Begeman // we will either branch to the default case for the switch, or the jump 117837efe6764568a3829fee26aba532283131d1a104Nate Begeman // table. 117937efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *JumpTableBB = new MachineBasicBlock(LLVMBB); 118037efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMF->getBasicBlockList().insert(BBI, JumpTableBB); 118137efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(Default); 118237efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(JumpTableBB); 118337efe6764568a3829fee26aba532283131d1a104Nate Begeman 118437efe6764568a3829fee26aba532283131d1a104Nate Begeman // Subtract the lowest switch case value from the value being switched on 118537efe6764568a3829fee26aba532283131d1a104Nate Begeman // and conditional branch to default mbb if the result is greater than the 118637efe6764568a3829fee26aba532283131d1a104Nate Begeman // difference between smallest and largest cases. 118737efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SwitchOp = getValue(SV); 118837efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType VT = SwitchOp.getValueType(); 118937efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 119037efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(First, VT)); 119137efe6764568a3829fee26aba532283131d1a104Nate Begeman 119237efe6764568a3829fee26aba532283131d1a104Nate Begeman // The SDNode we just created, which holds the value being switched on 119337efe6764568a3829fee26aba532283131d1a104Nate Begeman // minus the the smallest case value, needs to be copied to a virtual 119437efe6764568a3829fee26aba532283131d1a104Nate Begeman // register so it can be used as an index into the jump table in a 119537efe6764568a3829fee26aba532283131d1a104Nate Begeman // subsequent basic block. This value may be smaller or larger than the 119637efe6764568a3829fee26aba532283131d1a104Nate Begeman // target's pointer type, and therefore require extension or truncating. 119737efe6764568a3829fee26aba532283131d1a104Nate Begeman if (VT > TLI.getPointerTy()) 119837efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::TRUNCATE, TLI.getPointerTy(), SUB); 119937efe6764568a3829fee26aba532283131d1a104Nate Begeman else 120037efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), SUB); 1201c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 120237efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JumpTableReg = FuncInfo.MakeReg(TLI.getPointerTy()); 120337efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CopyTo = DAG.getCopyToReg(getRoot(), JumpTableReg, SwitchOp); 120437efe6764568a3829fee26aba532283131d1a104Nate Begeman 120537efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the range check for the jump table, and branch to the default 120637efe6764568a3829fee26aba532283131d1a104Nate Begeman // block for the switch statement if the value being switched on exceeds 120737efe6764568a3829fee26aba532283131d1a104Nate Begeman // the largest case in the switch. 120837efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CMP = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 120937efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(Last-First,VT), ISD::SETUGT); 121037efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, CMP, 121137efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getBasicBlock(Default))); 121237efe6764568a3829fee26aba532283131d1a104Nate Begeman 1213f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Build a vector of destination BBs, corresponding to each target 1214f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // of the jump table. If the value of the jump table slot corresponds to 1215f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // a case statement, push the case's BB onto the vector, otherwise, push 1216f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // the default BB. 121737efe6764568a3829fee26aba532283131d1a104Nate Begeman std::vector<MachineBasicBlock*> DestBBs; 1218f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman uint64_t TEI = First; 1219c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling for (CaseItr ii = Cases.begin(), ee = Cases.end(); ii != ee; ++TEI) 1220b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (cast<ConstantIntegral>(ii->first)->getZExtValue() == TEI) { 1221f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman DestBBs.push_back(ii->second); 1222f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman ++ii; 1223f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } else { 1224f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman DestBBs.push_back(Default); 1225f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 1226f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 1227f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Update successor info 1228c66764c00756d800aede2fd32d55658a236b1912Chris Lattner for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(), 1229c66764c00756d800aede2fd32d55658a236b1912Chris Lattner E = DestBBs.end(); I != E; ++I) 1230c66764c00756d800aede2fd32d55658a236b1912Chris Lattner JumpTableBB->addSuccessor(*I); 1231f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman 1232f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // Create a jump table index for this jump table, or return an existing 1233f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman // one. 123437efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JTI = CurMF->getJumpTableInfo()->getJumpTableIndex(DestBBs); 123537efe6764568a3829fee26aba532283131d1a104Nate Begeman 123637efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the jump table information so that we can codegen it as a second 123737efe6764568a3829fee26aba532283131d1a104Nate Begeman // MachineBasicBlock 123837efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.Reg = JumpTableReg; 123937efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.JTI = JTI; 124037efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.MBB = JumpTableBB; 12419453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT.Default = Default; 124237efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 124337efe6764568a3829fee26aba532283131d1a104Nate Begeman } 124437efe6764568a3829fee26aba532283131d1a104Nate Begeman } 1245f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1246f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Push the initial CaseRec onto the worklist 1247f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<CaseRec> CaseVec; 1248f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 1249f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1250f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman while (!CaseVec.empty()) { 1251f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Grab a record representing a case range to process off the worklist 1252f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec CR = CaseVec.back(); 1253f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.pop_back(); 1254f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1255f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Size is the number of Cases represented by this range. If Size is 1, 1256f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // then we are processing a leaf of the binary search tree. Otherwise, 1257f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // we need to pick a pivot, and push left and right ranges onto the 1258f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // worklist. 1259f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman unsigned Size = CR.Range.second - CR.Range.first; 1260f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1261f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (Size == 1) { 1262f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1263f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the Case's target mbb if the value being switched on SV is equal 1264f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // to C. Otherwise, branch to default. 1265f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = CR.Range.first->first; 1266f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Target = CR.Range.first->second; 1267f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, C, Target, Default, 1268f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CR.CaseBB); 1269c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1270f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the MBB representing the leaf node is the current MBB, then just 1271f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // call visitSwitchCase to emit the code into the current block. 1272f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, push the CaseBlock onto the vector to be later processed 1273f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // by SDISel, and insert the node's MBB before the next MBB. 1274f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1275f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1276c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling else 1277f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1278f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1279f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // split case range at pivot 1280f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseItr Pivot = CR.Range.first + (Size / 2); 1281f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange LHSR(CR.Range.first, Pivot); 1282f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange RHSR(Pivot, CR.Range.second); 1283f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = Pivot->first; 128457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner MachineBasicBlock *FalseBB = 0, *TrueBB = 0; 1285c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1286f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // We know that we branch to the LHS if the Value being switched on is 1287f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // less than the Pivot value, C. We use this to optimize our binary 1288f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // tree a bit, by recognizing that if SV is greater than or equal to the 1289f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // LHS's Case Value, and that Case Value is exactly one less than the 1290f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Pivot's Value, then we can branch directly to the LHS's Target, 1291f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // rather than creating a leaf node for it. 1292f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((LHSR.second - LHSR.first) == 1 && 1293f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSR.first->first == CR.GE && 1294b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer cast<ConstantIntegral>(C)->getZExtValue() == 1295b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer (cast<ConstantIntegral>(CR.GE)->getZExtValue() + 1ULL)) { 129657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner TrueBB = LHSR.first->second; 1297f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 129857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner TrueBB = new MachineBasicBlock(LLVMBB); 129957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMF->getBasicBlockList().insert(BBI, TrueBB); 130057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CaseVec.push_back(CaseRec(TrueBB, C, CR.GE, LHSR)); 1301f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1302c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1303f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Similar to the optimization above, if the Value being switched on is 1304f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // known to be less than the Constant CR.LT, and the current Case Value 1305f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // is CR.LT - 1, then we can branch directly to the target block for 1306f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the current Case Value, rather than emitting a RHS leaf node for it. 1307f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((RHSR.second - RHSR.first) == 1 && CR.LT && 1308b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer cast<ConstantIntegral>(RHSR.first->first)->getZExtValue() == 1309b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer (cast<ConstantIntegral>(CR.LT)->getZExtValue() - 1ULL)) { 131057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner FalseBB = RHSR.first->second; 1311f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 131257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner FalseBB = new MachineBasicBlock(LLVMBB); 131357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMF->getBasicBlockList().insert(BBI, FalseBB); 131457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CaseVec.push_back(CaseRec(FalseBB,CR.LT,C,RHSR)); 1315f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1316c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1317f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1318f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the LHS node if the value being switched on SV is less than C. 1319f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, branch to LHS. 1320f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman ISD::CondCode CC = C->getType()->isSigned() ? ISD::SETLT : ISD::SETULT; 132157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SelectionDAGISel::CaseBlock CB(CC, SV, C, TrueBB, FalseBB, CR.CaseBB); 1322c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 1323f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1324f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1325c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling else 1326f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1327f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1328f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1329f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1330f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1331b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 1332b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 133301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (I.getType()->isFloatingPoint()) { 133401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 133501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 133601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 133701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 133801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 133901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 13401628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitFPBinary(I, ISD::FSUB, ISD::VSUB); 13411628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer } else 13421628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer visitIntBinary(I, ISD::SUB, ISD::VSUB); 1343b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 1344b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 13451628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencervoid 13461628cec4d7fce310d9cde0bcc73997e5a71692c4Reid SpencerSelectionDAGLowering::visitIntBinary(User &I, unsigned IntOp, unsigned VecOp) { 13475fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 13481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 13491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 13502c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 13511628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 13521628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer SDOperand Num = DAG.getConstant(PTy->getNumElements(), MVT::i32); 13531628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer SDOperand Typ = DAG.getValueType(TLI.getValueType(PTy->getElementType())); 13541628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer setValue(&I, DAG.getNode(VecOp, MVT::Vector, Op1, Op2, Num, Typ)); 13555fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 13561628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer setValue(&I, DAG.getNode(IntOp, Op1.getValueType(), Op1, Op2)); 13571628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer } 13581628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer} 13591628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 13601628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencervoid 13611628cec4d7fce310d9cde0bcc73997e5a71692c4Reid SpencerSelectionDAGLowering::visitFPBinary(User &I, unsigned FPOp, unsigned VecOp) { 13621628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer const Type *Ty = I.getType(); 13631628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 13641628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 13651628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 13661628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 1367c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Num = DAG.getConstant(PTy->getNumElements(), MVT::i32); 1368c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Typ = DAG.getValueType(TLI.getValueType(PTy->getElementType())); 1369c7029805ef35ce9805931067b841e6af11db382eChris Lattner setValue(&I, DAG.getNode(VecOp, MVT::Vector, Op1, Op2, Num, Typ)); 13701628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer } else { 13711628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer setValue(&I, DAG.getNode(FPOp, Op1.getValueType(), Op1, Op2)); 13725fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1373e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 13742c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1375e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 1376e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 1377e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 1378e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 1379e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 1380e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 13811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 13821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 1385f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::CondCode UnsignedOpcode, 1386f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng ISD::CondCode FPOpcode) { 13871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 13881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 13891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 139080235d508e5f7a9603ef43ba6625984173ff0323Evan Cheng if (!FiniteOnlyFPMath() && I.getOperand(0)->getType()->isFloatingPoint()) 1391f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng Opcode = FPOpcode; 1392f6f9581983c85f8b4d2775b22870c1a4516fabdfEvan Cheng else if (I.getOperand(0)->getType()->isUnsigned()) 13931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 13947cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 13951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 13981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 13991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 14001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 1401b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner if (!isa<PackedType>(I.getType())) { 1402b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 1403b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner TrueVal, FalseVal)); 1404b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } else { 1405b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::VSELECT, MVT::Vector, Cond, TrueVal, FalseVal, 1406b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-2), 1407b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-1))); 1408b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } 14091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 14101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 14111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 14121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 1413e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 141428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 14151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1416e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner if (DestVT == MVT::Vector) { 1417e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast to a vector from something else. This is always a bit 1418e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1419e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 1420e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 1421e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N, 1422e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getConstant(DestTy->getNumElements(),MVT::i32), 1423e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getValueType(EltVT))); 1424e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (SrcVT == DestVT) { 14251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 142628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (DestVT == MVT::i1) { 1427ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 142828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand Zero = isInteger(SrcVT) ? DAG.getConstant(0, N.getValueType()) : 1429ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 14307cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 143128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isInteger(SrcVT)) { 143228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isInteger(DestVT)) { // Int -> Int cast 143328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Truncating cast? 143428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 1435ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 143628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 1437ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 143828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 14397e358908b885f50fb9258b7d10509bad20ca4c3bChris Lattner } else if (isFloatingPoint(DestVT)) { // Int -> FP cast 1440ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 144128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 1442ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 144328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 1444e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1445e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1446ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 144728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isFloatingPoint(SrcVT)) { 144828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isFloatingPoint(DestVT)) { // FP -> FP cast 144928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Rounding cast? 145028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N)); 1451ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 145228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 1453e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (isInteger(DestVT)) { // FP -> Int cast. 1454ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 145528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 1456ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 145728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 145828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else { 1459e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1460ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 1461e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1462e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(SrcVT == MVT::Vector && "Unknown cast!"); 1463e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(DestVT != MVT::Vector && "Casts to vector already handled!"); 1464e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast from a vector to something else. This is always a bit 1465e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1466e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N)); 14671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 14681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 14691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 14702bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 1471c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1472c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 1473c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1474c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 1475c7029805ef35ce9805931067b841e6af11db382eChris Lattner 14762332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Num = *(InVec.Val->op_end()-2); 14772332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 14782332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner setValue(&I, DAG.getNode(ISD::VINSERT_VECTOR_ELT, MVT::Vector, 14792332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner InVec, InVal, InIdx, Num, Typ)); 1480c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 1481c7029805ef35ce9805931067b841e6af11db382eChris Lattner 14822bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 1483384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1484384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1485384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 1486384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 1487384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner setValue(&I, DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, 1488384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 1489384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 1490c7029805ef35ce9805931067b841e6af11db382eChris Lattner 14913e104b11168da4692b69cc6b236c1da22adff959Chris Lattnervoid SelectionDAGLowering::visitShuffleVector(User &I) { 14923e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V1 = getValue(I.getOperand(0)); 14933e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V2 = getValue(I.getOperand(1)); 14943e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Mask = getValue(I.getOperand(2)); 14953e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 14963e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Num = *(V1.Val->op_end()-2); 14973e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Typ = *(V2.Val->op_end()-1); 14983e104b11168da4692b69cc6b236c1da22adff959Chris Lattner setValue(&I, DAG.getNode(ISD::VVECTOR_SHUFFLE, MVT::Vector, 14993e104b11168da4692b69cc6b236c1da22adff959Chris Lattner V1, V2, Mask, Num, Typ)); 15003e104b11168da4692b69cc6b236c1da22adff959Chris Lattner} 15013e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 15023e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 15031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 15041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 15051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 15061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 15081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 15091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 1510c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 1511b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 15121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 15131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 1514a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t Offset = TD->getStructLayout(StTy)->MemberOffsets[Field]; 15151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 1516dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 15171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 15181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 15191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 15201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 15217c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 15227c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 15237c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 1524b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 15257c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t Offs; 1526b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getType()->isSigned()) 1527b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Offs = (int64_t) 1528b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer TD->getTypeSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 15297c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 1530b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Offs = 1531b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer TD->getTypeSize(Ty)*cast<ConstantInt>(CI)->getZExtValue(); 15327c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 15337c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 15347c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 15357c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 15367c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 1537a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 15387c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 15397c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 15407c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 15417c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 15427c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 15437c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (Idx->getType()->isSigned()) 15447c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 15457c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 15467c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN); 15477c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 15487c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 15497c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 15507c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 15517c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 15527c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 15537c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 15547c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 15556b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 15561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 15577c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 15581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 15597c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 15607c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 15617c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 15627c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 15631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 15641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 15651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 15661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 15671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 15691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 15701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 15711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 15721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 15731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 1575a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t TySize = TLI.getTargetData()->getTypeSize(Ty); 1576a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson unsigned Align = std::max((unsigned)TLI.getTargetData()->getTypeAlignment(Ty), 1577ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman I.getAlignment()); 15781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 158068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 158168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 158268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 158368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 158468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 15851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 158668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 15871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 15881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 15891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 15901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 15911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 15921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 15931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 15941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 15951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 15961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 15971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 15981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 15991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 16001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 16011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 16021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 16031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 16041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1605bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[] = { getRoot(), AllocSize, getIntPtrConstant(Align) }; 1606f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTs = DAG.getNodeValueTypes(AllocSize.getValueType(), 1607f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner MVT::Other); 1608f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, 2, Ops, 3); 16091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 16101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 16121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 16131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 16141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 16171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 1618edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1619d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 1620d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 1621d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 1622d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 1623d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 1624d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 1625d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 162628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 1627466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng setValue(&I, getLoadFrom(I.getType(), Ptr, I.getOperand(0), 162828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner Root, I.isVolatile())); 162928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 163028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 163128b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 1632466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 163328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile) { 16345fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 16358cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 16364ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 1637466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng L = DAG.getVecLoad(PTy->getNumElements(), PVT, Root, Ptr, 1638466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng DAG.getSrcValue(SV)); 16395fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 1640466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SV, isVolatile); 16415fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1642d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 164328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 1644d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 1645d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 1646d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 164728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 164828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 16491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 16531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 16541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 16551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 16568b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng DAG.setRoot(DAG.getStore(getRoot(), Src, Ptr, I.getOperand(1), 16578b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.isVolatile())); 16581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 16591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 16600eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// IntrinsicCannotAccessMemory - Return true if the specified intrinsic cannot 16610eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// access memory and has no other side effects at all. 16620eade319cdb72e24c11d068728a98083737c6435Chris Lattnerstatic bool IntrinsicCannotAccessMemory(unsigned IntrinsicID) { 16630eade319cdb72e24c11d068728a98083737c6435Chris Lattner#define GET_NO_MEMORY_INTRINSICS 16640eade319cdb72e24c11d068728a98083737c6435Chris Lattner#include "llvm/Intrinsics.gen" 16650eade319cdb72e24c11d068728a98083737c6435Chris Lattner#undef GET_NO_MEMORY_INTRINSICS 16660eade319cdb72e24c11d068728a98083737c6435Chris Lattner return false; 16670eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 16680eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1669e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// IntrinsicOnlyReadsMemory - Return true if the specified intrinsic doesn't 1670e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// have any side-effects or if it only reads memory. 1671e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattnerstatic bool IntrinsicOnlyReadsMemory(unsigned IntrinsicID) { 1672e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#define GET_SIDE_EFFECT_INFO 1673e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#include "llvm/Intrinsics.gen" 1674e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#undef GET_SIDE_EFFECT_INFO 1675e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner return false; 1676e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner} 1677e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner 16780eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 16790eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 16800eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 16810eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 16827255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner bool HasChain = !IntrinsicCannotAccessMemory(Intrinsic); 1683e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner bool OnlyLoad = HasChain && IntrinsicOnlyReadsMemory(Intrinsic); 16840eade319cdb72e24c11d068728a98083737c6435Chris Lattner 16850eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 1686bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 1687e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { // If this intrinsic has side-effects, chainify it. 1688e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) { 1689e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner // We don't need to serialize loads against other loads. 1690e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(DAG.getRoot()); 1691e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } else { 1692e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(getRoot()); 1693e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 1694e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 16950eade319cdb72e24c11d068728a98083737c6435Chris Lattner 16960eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 16970eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 16980eade319cdb72e24c11d068728a98083737c6435Chris Lattner 16990eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 17000eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 17010eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 17020eade319cdb72e24c11d068728a98083737c6435Chris Lattner 17030eade319cdb72e24c11d068728a98083737c6435Chris Lattner // If this is a vector type, force it to the right packed type. 17040eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (Op.getValueType() == MVT::Vector) { 17050eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *OpTy = cast<PackedType>(I.getOperand(i)->getType()); 17060eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType()); 17070eade319cdb72e24c11d068728a98083737c6435Chris Lattner 17080eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VVT = MVT::getVectorType(EltVT, OpTy->getNumElements()); 17090eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VVT != MVT::Other && "Intrinsic uses a non-legal type?"); 17100eade319cdb72e24c11d068728a98083737c6435Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, VVT, Op); 17110eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 17120eade319cdb72e24c11d068728a98083737c6435Chris Lattner 17130eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 17140eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 17150eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 17160eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 17170eade319cdb72e24c11d068728a98083737c6435Chris Lattner 17180eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 17190eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 17200eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 17210eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (VT == MVT::Vector) { 17220eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 17230eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 17240eade319cdb72e24c11d068728a98083737c6435Chris Lattner 17250eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 17260eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 17270eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 17280eade319cdb72e24c11d068728a98083737c6435Chris Lattner 17290eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 17300eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 17310eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 17320eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 17330eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 17340eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1735f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTList = DAG.getNodeValueTypes(VTs); 1736f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner 17370eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 173848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 173948b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 1740f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTList, VTs.size(), 1741f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 174248b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 1743f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTList, VTs.size(), 1744f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 174548b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 1746f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTList, VTs.size(), 1747f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 174848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 1749e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { 1750e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner SDOperand Chain = Result.getValue(Result.Val->getNumValues()-1); 1751e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) 1752e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner PendingLoads.push_back(Chain); 1753e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner else 1754e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner DAG.setRoot(Chain); 1755e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 17560eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 17570eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (const PackedType *PTy = dyn_cast<PackedType>(I.getType())) { 17580eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EVT = TLI.getValueType(PTy->getElementType()); 17590eade319cdb72e24c11d068728a98083737c6435Chris Lattner Result = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Result, 17600eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getConstant(PTy->getNumElements(), MVT::i32), 17610eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getValueType(EVT)); 17620eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 17630eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 17640eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 17650eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 17660eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1767c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 1768c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 1769c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 1770c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 1771c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 1772c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 17730eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 17740eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 17750eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 17760eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 1777c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 1778c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 1779c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 1780c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return 0; 1781c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return 0; 1782c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 1783c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1784c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 1785c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 1786c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1787c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 178803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 178903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 179003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 179103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 179203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 179303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 179403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 179503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 179603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 179703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 179803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 179903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 1800c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 180186cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 1802ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 180343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 1804fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && SPI.getContext() && DebugInfo->Verify(SPI.getContext())) { 1805bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[5]; 180636ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 1807bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[0] = getRoot(); 1808bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[1] = getValue(SPI.getLineValue()); 1809bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[2] = getValue(SPI.getColumnValue()); 1810ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 181143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfoDesc *DD = DebugInfo->getDescFor(SPI.getContext()); 1812ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 181343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 181443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1815bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[3] = DAG.getString(CompileUnit->getFileName()); 1816bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[4] = DAG.getString(CompileUnit->getDirectory()); 1817ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 1818bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops, 5)); 181986cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 182043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1821b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 182236ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 182343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 182443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 182543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 1826fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && RSI.getContext() && DebugInfo->Verify(RSI.getContext())) { 182743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(RSI.getContext()); 1828bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, getRoot(), 1829bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.getConstant(LabelID, MVT::i32))); 183043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 183143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1832b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 183343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 183443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 183543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 183643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 1837fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && REI.getContext() && DebugInfo->Verify(REI.getContext())) { 183843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionEnd(REI.getContext()); 1839bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, 1840bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 184143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 184243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1843b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 184443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 184543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 184643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 184743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 1848fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && FSI.getSubprogram() && 1849fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey DebugInfo->Verify(FSI.getSubprogram())) { 185043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(FSI.getSubprogram()); 1851bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, 1852bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner getRoot(), DAG.getConstant(LabelID, MVT::i32))); 185343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 185443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1855b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 185643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 185743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 185843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 185943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 1860bf7637d59028a5d9911769810f537c499e23bb8eJim Laskey if (DebugInfo && DI.getVariable() && DebugInfo->Verify(DI.getVariable())) { 18610892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey SDOperand AddressOp = getValue(DI.getAddress()); 1862bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(AddressOp)) 186343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfo->RecordVariable(DI.getVariable(), FI->getIndex()); 186443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 186543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 186643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 186743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 1868c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 18690b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f32: 18700b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f64: 1871c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 1872c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 1873c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1874c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 18750b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 18760b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 1877c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 1878c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1879c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1880c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 18816ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f32: 18826ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner case Intrinsic::powi_f64: 18836ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner setValue(&I, DAG.getNode(ISD::FPOWI, 18846ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)).getValueType(), 18856ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)), 18866ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(2)))); 18876ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner return 0; 1888c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 1889c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1890c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 1891c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1892c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 18938b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 1894bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 1895f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, 1896f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::i64, MVT::Other), 2, 1897f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Op, 1); 18988b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 18998b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 190051b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 19018b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 1902d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 1903d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 1904d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 1905d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 1906d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 1907d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 1908d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 19090b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 19100b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 19110b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 19120b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 1913c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 1914c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1915c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1916c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 19170b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 19180b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 19190b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 19200b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 1921c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 1922c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1923c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1924c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 19250b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 19260b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 19270b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 19280b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 1929c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 1930c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1931c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1932c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1933140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 1934bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 1935f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, 1936f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(TLI.getPointerTy(), MVT::Other), 2, &Op, 1); 1937140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 1938140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 1939140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 1940140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 194139a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 194239a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 194339a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 1944140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 194539a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 1946ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 1947ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 1948ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 1949c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1950c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 1951c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 1952c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 19531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 195464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 1955c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 1956c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 1957c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 1958c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 1959c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 1960c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 1961c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 1962c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 1963a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (Name[0] == 'c' && (Name == "copysign" || Name == "copysignf")) { 1964a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 1965a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1966a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(1)->getType() && 1967a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(2)->getType()) { 1968a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand LHS = getValue(I.getOperand(1)); 1969a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand RHS = getValue(I.getOperand(2)); 1970a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 1971a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner LHS, RHS)); 1972a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner return; 1973a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 1974a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } else if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 1975c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1976c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1977c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1978c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1979c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 1980c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 1981c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1982c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 1983f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1984f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 198506a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1986c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1987f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 1988f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1989f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1990c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 1991f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1992f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 199306a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1994c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1995f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 1996f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1997f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1998f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1999c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 2000ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 2001ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner visitInlineAsm(I); 2002ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 2003c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 2004edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 200564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 200664e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 200764e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 200864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 200964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 20101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 2011c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 20121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 20131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 20141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 20151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 20161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2017edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 20188e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 20198e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 2020edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2021cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 20229092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 2023adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 20241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 2025cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 2026cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 20271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 20281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2029864635ad7b3046d3042311423071152c613961deChris LattnerSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 20309f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag)const{ 2031864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Val = DAG.getCopyFromReg(Chain, Regs[0], RegVT, Flag); 2032864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 2033864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 2034864635ad7b3046d3042311423071152c613961deChris Lattner 2035864635ad7b3046d3042311423071152c613961deChris Lattner // If the result was expanded, copy from the top part. 2036864635ad7b3046d3042311423071152c613961deChris Lattner if (Regs.size() > 1) { 2037864635ad7b3046d3042311423071152c613961deChris Lattner assert(Regs.size() == 2 && 2038864635ad7b3046d3042311423071152c613961deChris Lattner "Cannot expand to more than 2 elts yet!"); 2039864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Hi = DAG.getCopyFromReg(Chain, Regs[1], RegVT, Flag); 2040693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Chain = Hi.getValue(1); 2041693163e74d047a05799eaaf619ba4972fdc3a0e9Evan Cheng Flag = Hi.getValue(2); 20429f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (DAG.getTargetLoweringInfo().isLittleEndian()) 20439f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Val, Hi); 20449f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner else 20459f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Hi, Val); 2046864635ad7b3046d3042311423071152c613961deChris Lattner } 2047864635ad7b3046d3042311423071152c613961deChris Lattner 2048cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Otherwise, if the return value was promoted or extended, truncate it to the 2049864635ad7b3046d3042311423071152c613961deChris Lattner // appropriate type. 2050864635ad7b3046d3042311423071152c613961deChris Lattner if (RegVT == ValueVT) 2051864635ad7b3046d3042311423071152c613961deChris Lattner return Val; 2052864635ad7b3046d3042311423071152c613961deChris Lattner 2053cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (MVT::isInteger(RegVT)) { 2054cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner if (ValueVT < RegVT) 2055cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 2056cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner else 2057cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner return DAG.getNode(ISD::ANY_EXTEND, ValueVT, Val); 2058cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } else { 2059864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::FP_ROUND, ValueVT, Val); 2060cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner } 2061864635ad7b3046d3042311423071152c613961deChris Lattner} 2062864635ad7b3046d3042311423071152c613961deChris Lattner 2063c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 2064c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// specified value into the registers specified by this object. This uses 2065c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// Chain/Flag as the input and updates them for the output Chain/Flag. 2066c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 2067a844126c43976387a66dafbe5137a762169f1f34Evan Cheng SDOperand &Chain, SDOperand &Flag, 2068a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MVT::ValueType PtrVT) const { 2069c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (Regs.size() == 1) { 2070c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // If there is a single register and the types differ, this must be 2071c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // a promotion. 2072c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (RegVT != ValueVT) { 20730c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (MVT::isInteger(RegVT)) { 20740c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner if (RegVT < ValueVT) 20750c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::TRUNCATE, RegVT, Val); 20760c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner else 20770c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner Val = DAG.getNode(ISD::ANY_EXTEND, RegVT, Val); 20780c48fd4610cc7a90a998428c93a0c68246e79e57Chris Lattner } else 2079c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::FP_EXTEND, RegVT, Val); 2080c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2081c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Chain = DAG.getCopyToReg(Chain, Regs[0], Val, Flag); 2082c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 2083c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } else { 20849f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<unsigned> R(Regs); 20859f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (!DAG.getTargetLoweringInfo().isLittleEndian()) 20869f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::reverse(R.begin(), R.end()); 20879f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner 20889f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner for (unsigned i = 0, e = R.size(); i != e; ++i) { 2089c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner SDOperand Part = DAG.getNode(ISD::EXTRACT_ELEMENT, RegVT, Val, 2090a844126c43976387a66dafbe5137a762169f1f34Evan Cheng DAG.getConstant(i, PtrVT)); 20919f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner Chain = DAG.getCopyToReg(Chain, R[i], Part, Flag); 2092c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 2093c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2094c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2095c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 2096864635ad7b3046d3042311423071152c613961deChris Lattner 2097c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 2098c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 2099c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 2100c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 21019f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 2102c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getConstant(Code | (Regs.size() << 3), MVT::i32)); 2103c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 2104c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 2105c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 2106864635ad7b3046d3042311423071152c613961deChris Lattner 2107864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 2108864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 2109864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 2110864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 21119b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 21129b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetLowering &TLI, const MRegisterInfo *MRI) { 2113f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType FoundVT = MVT::Other; 2114f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner const TargetRegisterClass *FoundRC = 0; 21159b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (MRegisterInfo::regclass_iterator RCI = MRI->regclass_begin(), 21169b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = MRI->regclass_end(); RCI != E; ++RCI) { 2117f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType ThisVT = MVT::Other; 2118f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner 21199b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 21209b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 21219b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 21229b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 21239b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 21249b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 2125f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // If we have already found this register in a different register class, 2126f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // choose the one with the largest VT specified. For example, on 2127f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // PowerPC, we favor f64 register classes over f32. 2128f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (FoundVT == MVT::Other || 2129f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::getSizeInBits(FoundVT) < MVT::getSizeInBits(*I)) { 2130f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner ThisVT = *I; 2131f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 2132f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 21339b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 21349b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 21359b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 2136f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (ThisVT == MVT::Other) continue; 21379b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 2138864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 2139864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 2140864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 2141864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 21429b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 21439b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 2144f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (*I == Reg) { 2145f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // We found a matching register class. Keep looking at others in case 2146f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // we find one with larger registers that this physreg is also in. 2147f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundRC = RC; 2148f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundVT = ThisVT; 2149f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 2150f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 2151864635ad7b3046d3042311423071152c613961deChris Lattner } 2152f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner return FoundRC; 2153864635ad7b3046d3042311423071152c613961deChris Lattner} 2154864635ad7b3046d3042311423071152c613961deChris Lattner 2155864635ad7b3046d3042311423071152c613961deChris LattnerRegsForValue SelectionDAGLowering:: 2156864635ad7b3046d3042311423071152c613961deChris LattnerGetRegistersForValue(const std::string &ConstrCode, 2157864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, bool isOutReg, bool isInReg, 2158864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 21594e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 2160864635ad7b3046d3042311423071152c613961deChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 2161864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegForInlineAsmConstraint(ConstrCode, VT); 2162864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 2163864635ad7b3046d3042311423071152c613961deChris Lattner 2164864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumRegs = VT != MVT::Other ? TLI.getNumElements(VT) : 1; 2165864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 2166864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT = VT; 2167864635ad7b3046d3042311423071152c613961deChris Lattner 2168864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 2169864635ad7b3046d3042311423071152c613961deChris Lattner if (VT == MVT::Other) 2170864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 2171cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner 2172cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Get the actual register value type. This is important, because the user 2173cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // may have asked for (e.g.) the AX register in i32 type. We need to 2174cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // remember that AX is actually i16 to get the right extension. 2175cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner RegVT = *PhysReg.second->vt_begin(); 2176864635ad7b3046d3042311423071152c613961deChris Lattner 2177864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 2178864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 2179864635ad7b3046d3042311423071152c613961deChris Lattner 2180864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 2181864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 2182864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 2183864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 2184864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 2185864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 2186864635ad7b3046d3042311423071152c613961deChris Lattner 2187864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 2188864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 2189864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 2190864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 2191864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 2192864635ad7b3046d3042311423071152c613961deChris Lattner } 2193864635ad7b3046d3042311423071152c613961deChris Lattner } 2194864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 2195864635ad7b3046d3042311423071152c613961deChris Lattner } 2196864635ad7b3046d3042311423071152c613961deChris Lattner 2197864635ad7b3046d3042311423071152c613961deChris Lattner // This is a reference to a register class. Allocate NumRegs consecutive, 2198864635ad7b3046d3042311423071152c613961deChris Lattner // available, registers from the class. 2199864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> RegClassRegs = 2200864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegClassForInlineAsmConstraint(ConstrCode, VT); 2201864635ad7b3046d3042311423071152c613961deChris Lattner 22024e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner const MRegisterInfo *MRI = DAG.getTarget().getRegisterInfo(); 22034e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner MachineFunction &MF = *CurMBB->getParent(); 2204864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 2205864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 2206864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 22074e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 2208864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 2209864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 2210864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 2211864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 2212864635ad7b3046d3042311423071152c613961deChris Lattner continue; 2213864635ad7b3046d3042311423071152c613961deChris Lattner } 2214864635ad7b3046d3042311423071152c613961deChris Lattner 22154e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 22164e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 22179b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, MRI); 2218864635ad7b3046d3042311423071152c613961deChris Lattner if (!RC) { 2219864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 2220864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 2221864635ad7b3046d3042311423071152c613961deChris Lattner continue; 22224e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 22234e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 2224864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 2225864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 2226864635ad7b3046d3042311423071152c613961deChris Lattner 2227864635ad7b3046d3042311423071152c613961deChris Lattner // If we allocated enough consecutive 2228864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 2229864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 2230864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 2231864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 2232864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) { 2233864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 2234864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 2235864635ad7b3046d3042311423071152c613961deChris Lattner if (isOutReg) OutputRegs.insert(Reg); // Mark reg used. 2236864635ad7b3046d3042311423071152c613961deChris Lattner if (isInReg) InputRegs.insert(Reg); // Mark reg used. 2237864635ad7b3046d3042311423071152c613961deChris Lattner } 2238864635ad7b3046d3042311423071152c613961deChris Lattner 2239864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, *RC->vt_begin(), VT); 2240864635ad7b3046d3042311423071152c613961deChris Lattner } 22414e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 2242864635ad7b3046d3042311423071152c613961deChris Lattner 2243864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 2244864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(); 22454e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 22464e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 2247864635ad7b3046d3042311423071152c613961deChris Lattner 2248ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 2249ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 2250ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattnervoid SelectionDAGLowering::visitInlineAsm(CallInst &I) { 2251ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner InlineAsm *IA = cast<InlineAsm>(I.getOperand(0)); 2252ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2253ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand AsmStr = DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), 2254ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner MVT::Other); 2255ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2256ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Note, we treat inline asms both with and without side-effects as the same. 2257ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // If an inline asm doesn't have side effects and doesn't access memory, we 2258ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // could not choose to not chain it. 2259ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner bool hasSideEffects = IA->hasSideEffects(); 2260ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22612cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); 22621efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner std::vector<MVT::ValueType> ConstraintVTs; 2263ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2264ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// AsmNodeOperands - A list of pairs. The first element is a register, the 2265ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// second is a bitfield where bit #0 is set if it is a use and bit #1 is set 2266ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// if it is a def of that register. 2267ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> AsmNodeOperands; 2268ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 2269ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(AsmStr); 2270ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2271ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 2272ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 2273ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22744e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We fully assign registers here at isel time. This is not optimal, but 22754e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // should work. For register classes that correspond to LLVM classes, we 22764e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // could let the LLVM RA do its thing, but we currently don't. Do a prepass 22774e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // over the constraints, collecting fixed registers that we know we can't use. 22784e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 22791efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner unsigned OpNum = 1; 22804e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 22814e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 22824e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 22832223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 22841efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner MVT::ValueType OpVT; 22851efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 22861efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Compute the value type for each operand and add it to ConstraintVTs. 22871efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner switch (Constraints[i].Type) { 22881efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 22891efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (!Constraints[i].isIndirectOutput) { 22901efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 22911efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getType()); 22921efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 229322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner const Type *OpTy = I.getOperand(OpNum)->getType(); 22941efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(cast<PointerType>(OpTy)->getElementType()); 22951efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 22961efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 22971efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 22981efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 22991efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getOperand(OpNum)->getType()); 23001efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 23011efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 23021efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 23031efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = MVT::Other; 23041efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 23051efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 23061efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 23071efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner ConstraintVTs.push_back(OpVT); 23081efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2309864635ad7b3046d3042311423071152c613961deChris Lattner if (TLI.getRegForInlineAsmConstraint(ConstraintCode, OpVT).first == 0) 2310864635ad7b3046d3042311423071152c613961deChris Lattner continue; // Not assigned a fixed reg. 23111efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2312864635ad7b3046d3042311423071152c613961deChris Lattner // Build a list of regs that this operand uses. This always has a single 2313864635ad7b3046d3042311423071152c613961deChris Lattner // element for promoted/expanded operands. 2314864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = GetRegistersForValue(ConstraintCode, OpVT, 2315864635ad7b3046d3042311423071152c613961deChris Lattner false, false, 2316864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 23174e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 23184e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner switch (Constraints[i].Type) { 23194e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isOutput: 23204e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We can't assign any other output to this register. 2321864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 23224e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // If this is an early-clobber output, it cannot be assigned to the same 23234e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // value as the input reg. 23242223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2325864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 23264e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 23271efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 23281efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // We can't assign any other input to this register. 2329864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 23301efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 23314e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isClobber: 23324e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Clobbered regs cannot be used as inputs or outputs. 2333864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 2334864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 23354e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 23364e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 23374e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 23382cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 23390f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 23400f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 2341864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 2342864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 23431efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum = 1; 23440f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 23456656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 23462cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 23472cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 23481efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 23492cc2f66c25d9576743026688fdae5ed402726532Chris Lattner switch (Constraints[i].Type) { 23502cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 235122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 235222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 235322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 235422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 235522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (CTy == TargetLowering::C_Memory) { 235622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Memory output. 235722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 235822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 235922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Check that the operand (the address to store to) isn't a float. 236022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 236122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 236222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 236322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!Constraints[i].isIndirectOutput) 236422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 236522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 236622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner OpNum++; // Consumes a call operand. 236722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 236822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Extend/truncate to the right pointer type if needed. 236922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 237022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (InOperandVal.getValueType() < PtrType) 237122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 237222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner else if (InOperandVal.getValueType() > PtrType) 237322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 237422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 237522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 237622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 237722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 237822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(InOperandVal); 237922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 238022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 238122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 238222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Otherwise, this is a register output. 238322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 238422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 2385864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an early-clobber output, or if there is an input 2386864635ad7b3046d3042311423071152c613961deChris Lattner // constraint that matches this, we need to reserve the input register 2387864635ad7b3046d3042311423071152c613961deChris Lattner // so no other inputs allocate to it. 2388864635ad7b3046d3042311423071152c613961deChris Lattner bool UsesInputRegister = false; 2389864635ad7b3046d3042311423071152c613961deChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2390864635ad7b3046d3042311423071152c613961deChris Lattner UsesInputRegister = true; 23912223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 2392864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 2393864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 2394864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = 2395864635ad7b3046d3042311423071152c613961deChris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 2396864635ad7b3046d3042311423071152c613961deChris Lattner true, UsesInputRegister, 2397864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 2398864635ad7b3046d3042311423071152c613961deChris Lattner assert(!Regs.Regs.empty() && "Couldn't allocate output reg!"); 23992cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 24002cc2f66c25d9576743026688fdae5ed402726532Chris Lattner if (!Constraints[i].isIndirectOutput) { 2401864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 24022cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 24032cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 2404864635ad7b3046d3042311423071152c613961deChris Lattner RetValRegs = Regs; 24052cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 240622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner IndirectStoresToEmit.push_back(std::make_pair(Regs, 240722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner I.getOperand(OpNum))); 24082cc2f66c25d9576743026688fdae5ed402726532Chris Lattner OpNum++; // Consumes a call operand. 24092cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 24106656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 24116656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 24126656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 2413c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Regs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, AsmNodeOperands); 24146656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 24156656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 24166656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 241722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 24184e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner OpNum++; // Consumes a call operand. 24193d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 24202223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (isdigit(ConstraintCode[0])) { // Matching constraint? 24212223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 24222223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 24232223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner unsigned OperandNo = atoi(ConstraintCode.c_str()); 24243d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 2425c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 2426c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 2427c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 2428c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 2429c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 2430c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2431c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2432a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner assert(((NumOps & 7) == 2 /*REGDEF*/ || 2433a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner (NumOps & 7) == 4 /*MEM*/) && 2434c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2435c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 2436c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2437c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2438c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2439c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2440c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner assert((NumOps & 7) == 2 /*REGDEF*/ && 2441c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2442c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2443c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 2444c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue MatchedRegs; 2445c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 2446c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 2447c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 2448c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned Reg=cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 2449c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.Regs.push_back(Reg); 2450c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2451c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2452c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Use the produced MatchedRegs object to 2453a844126c43976387a66dafbe5137a762169f1f34Evan Cheng MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, 2454a844126c43976387a66dafbe5137a762169f1f34Evan Cheng TLI.getPointerTy()); 2455c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 245687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 245787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 245887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 245987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 246087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 246187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 24623d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 246387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (CTy == TargetLowering::C_Other) { 246487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!TLI.isOperandValidForConstraint(InOperandVal, ConstraintCode[0])) 246587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2466c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 246787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 246887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 3 /*IMM*/ | (1 << 3); 246987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 247087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 247187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 247287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } else if (CTy == TargetLowering::C_Memory) { 247387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Memory input. 247487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 247587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Check that the operand isn't a float. 247687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 247787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2478c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 247987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Extend/truncate to the right pointer type if needed. 248087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 248187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (InOperandVal.getValueType() < PtrType) 248287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 248387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner else if (InOperandVal.getValueType() > PtrType) 248487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 248587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 248687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 248787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 248887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 248987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 2490c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 24912223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 249287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 249387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 249487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 249587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 249687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner RegsForValue InRegs = 249787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 249887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner false, true, OutputRegs, InputRegs); 249987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // FIXME: should be match fail. 250087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(!InRegs.Regs.empty() && "Couldn't allocate input reg!"); 250187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 2502a844126c43976387a66dafbe5137a762169f1f34Evan Cheng InRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag, TLI.getPointerTy()); 250387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 250487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, AsmNodeOperands); 25056656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 25066656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2507c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 2508c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue ClobberedRegs = 2509c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner GetRegistersForValue(ConstraintCode, MVT::Other, false, false, 2510c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner OutputRegs, InputRegs); 2511c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 2512c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 2513c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (!ClobberedRegs.Regs.empty()) 2514c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner ClobberedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, AsmNodeOperands); 25156656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 25166656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2517c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 25186656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2519ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2520ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 2521ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 2522ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 2523ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2524f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, 2525f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::Other, MVT::Flag), 2, 2526bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &AsmNodeOperands[0], AsmNodeOperands.size()); 2527ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 2528ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 25296656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 25306656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 2531864635ad7b3046d3042311423071152c613961deChris Lattner if (!RetValRegs.Regs.empty()) 2532864635ad7b3046d3042311423071152c613961deChris Lattner setValue(&I, RetValRegs.getCopyFromRegs(DAG, Chain, Flag)); 25336656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 25346656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 25356656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 25366656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 25376656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 25386656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 2539864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 25406656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 2541864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, Flag); 2542864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 25436656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2544ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 25456656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 2546bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 25476656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 2548786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng OutChains.push_back(DAG.getStore(Chain, StoresToEmit[i].first, 25496656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 25508b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoresToEmit[i].second, 0)); 25516656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 2552bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, 2553bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 2554ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 2555ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 2556ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2557ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 25581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 25591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 25601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 256268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 256368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 256468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 256568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 256668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 25671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 2569a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(I.getType()->getElementType()); 25701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 25711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 25721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 2574a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson Args.push_back(std::make_pair(Src, TLI.getTargetData()->getIntPtrType())); 2575cf5734dddd66af9388a171b44996505ede47feedChris Lattner 2576cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2577adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 2578cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 2579cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 2580cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 2581cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 25821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 25831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 25851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 25861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 2587a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson TLI.getTargetData()->getIntPtrType())); 25881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 2589cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2590adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 2591cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 2592cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 25931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 25941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2595025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 2596025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 2597025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 2598025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 2599025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 2600025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 2601025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 2602025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 2603025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 2604025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 2605025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 2606025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 2607025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 2608025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 260939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 2610acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 2611acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2612acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 261339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 261439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 26151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 2616acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 2617acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 2618acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 2619acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 2620acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 26211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 26221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 26231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 2624acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 2625acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2626acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 26271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 26281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 26291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 2630acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 2631acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2632acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 2633acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 2634acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 26351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 26361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2637fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// TargetLowering::LowerArguments - This is the default LowerArguments 2638fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// implementation, which just inserts a FORMAL_ARGUMENTS node. FIXME: When all 2639f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// targets are migrated to using FORMAL_ARGUMENTS, this hook should be 2640f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// integrated into SDISel. 2641fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattnerstd::vector<SDOperand> 2642fdfded55888e35b76bb70231a5bb2f60877c2f6aChris LattnerTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { 2643fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. 2644fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<SDOperand> Ops; 26458c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner Ops.push_back(DAG.getRoot()); 2646fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.getCallingConv(), getPointerTy())); 2647fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.isVarArg(), getPointerTy())); 2648fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2649fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add one result value for each formal argument. 2650fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<MVT::ValueType> RetVals; 2651fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { 2652fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2653fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2654fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2655fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2656fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2657fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(VT); 2658fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2659fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: 2660fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(getTypeToTransformTo(VT)); 2661fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2662fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2663fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2664fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be broken up into small 2665fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the destination type is and how many small 2666fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it turns into. 2667fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2668fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2669fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (unsigned i = 0; i != NumVals; ++i) 2670fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(NVT); 2671fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2672fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2673fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2674fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumElems = cast<PackedType>(I->getType())->getNumElements(); 2675fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner const Type *EltTy = cast<PackedType>(I->getType())->getElementType(); 2676f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 2677fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2678fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2679fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2680fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2681fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(TVT); 2682fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2683fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2684fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2685fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2686fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2687fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2688fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 26893b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng 26908c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner RetVals.push_back(MVT::Other); 2691fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2692fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Create the node. 2693f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDNode *Result = DAG.getNode(ISD::FORMAL_ARGUMENTS, 2694f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(RetVals), RetVals.size(), 2695bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()).Val; 26968c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner 26978c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner DAG.setRoot(SDOperand(Result, Result->getNumValues()-1)); 2698fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2699fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Set up the return result vector. 2700fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.clear(); 2701fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned i = 0; 2702fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { 2703fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2704fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2705fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2706fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2707fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2708fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(SDOperand(Result, i++)); 2709fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2710fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: { 2711fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Op(Result, i++); 2712fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (MVT::isInteger(VT)) { 2713fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned AssertOp = I->getType()->isSigned() ? ISD::AssertSext 2714fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner : ISD::AssertZext; 2715fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(AssertOp, Op.getValueType(), Op, DAG.getValueType(VT)); 2716fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::TRUNCATE, VT, Op); 2717fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2718fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 2719fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::FP_ROUND, VT, Op); 2720fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2721fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(Op); 2722fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2723fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2724fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2725fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2726fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be reassembled from small 2727fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the source elt type is and how many small 2728fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it is. 2729fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2730fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2731fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (NumVals == 2) { 2732fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Lo = SDOperand(Result, i++); 2733fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Hi = SDOperand(Result, i++); 2734fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2735fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (!isLittleEndian()) 2736fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::swap(Lo, Hi); 2737fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2738fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Lo, Hi)); 2739fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2740fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Value scalarized into many values. Unimp for now. 2741fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Cannot expand i64 -> i16 yet!"); 2742fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2743fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2744fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2745fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2746020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const PackedType *PTy = cast<PackedType>(I->getType()); 2747020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng unsigned NumElems = PTy->getNumElements(); 2748020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng const Type *EltTy = PTy->getElementType(); 2749f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 2750fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2751fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2752fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2753d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2754020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng SDOperand N = SDOperand(Result, i++); 2755020c41f21e8b6b01bc40db69e660c3c6e29b0978Evan Cheng // Handle copies from generic vectors to registers. 2756d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 2757d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 2758d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 2759d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner Ops.push_back(N); 2760d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner } else { 2761fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2762da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2763fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2764fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2765fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2766fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2767fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2768fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner return Ops; 2769fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner} 2770fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2771f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2772f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// TargetLowering::LowerCallTo - This is the default LowerCallTo 2773f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// implementation, which just inserts an ISD::CALL node, which is later custom 2774f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// lowered by the target to something concrete. FIXME: When all targets are 2775f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// migrated to using ISD::CALL, this hook should be integrated into SDISel. 2776f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattnerstd::pair<SDOperand, SDOperand> 2777f4ec817299a4187044a6162c2f520772b3ad69a0Chris LattnerTargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg, 2778f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned CallingConv, bool isTailCall, 2779f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Callee, 2780f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ArgListTy &Args, SelectionDAG &DAG) { 2781be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<SDOperand, 32> Ops; 2782f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Chain); // Op#0 - Chain 2783f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(CallingConv, getPointerTy())); // Op#1 - CC 2784f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isVarArg, getPointerTy())); // Op#2 - VarArg 2785f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isTailCall, getPointerTy())); // Op#3 - Tail 2786f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Callee); 2787f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2788f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Handle all of the outgoing arguments. 2789f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) { 2790f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(Args[i].second); 2791f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Op = Args[i].first; 2792f6d62c2e2a53e3ebf2e25f0891e5f1a0b772b368Evan Cheng bool isSigned = Args[i].second->isSigned(); 2793f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 2794f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 2795f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 2796f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 2797d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2798f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2799f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 2800f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (MVT::isInteger(VT)) { 2801f6d62c2e2a53e3ebf2e25f0891e5f1a0b772b368Evan Cheng unsigned ExtOp = isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; 2802f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ExtOp, getTypeToTransformTo(VT), Op); 2803f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2804f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 2805f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, getTypeToTransformTo(VT), Op); 2806f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2807f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Op); 2808d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2809f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2810f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 2811f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 2812f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be broken down into small 2813f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 2814f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 2815f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2816f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2817f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (NumVals == 2) { 2818f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Op, 2819f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getConstant(0, getPointerTy())); 2820f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Op, 2821f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getConstant(1, getPointerTy())); 2822f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (!isLittleEndian()) 2823f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner std::swap(Lo, Hi); 2824f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2825f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Lo); 2826d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2827f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Hi); 2828d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 2829f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2830f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Value scalarized into many values. Unimp for now. 2831f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(0 && "Cannot expand i64 -> i16 yet!"); 2832f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2833f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2834da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 2835da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 2836da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const PackedType *PTy = cast<PackedType>(Args[i].second); 2837da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 2838da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 2839da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 2840da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 2841da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 2842da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 28431b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 28441b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner // Insert a VBIT_CONVERT of the MVT::Vector type to the packed type. 28451b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, TVT, Op); 28461b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner Ops.push_back(Op); 2847d61c4820c9e39500a67bec4d6cfe521a833afdccEvan Cheng Ops.push_back(DAG.getConstant(isSigned, MVT::i32)); 28481b8daae71b0118b489cbecf2f1b8ed86b6bc8e57Chris Lattner } else { 2849da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call args yet!"); 2850da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2851da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 2852f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2853f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2854f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2855f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2856f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2857f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Figure out the result value types. 2858be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<MVT::ValueType, 4> RetTys; 2859f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2860f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTy != Type::VoidTy) { 2861f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 2862f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner switch (getTypeAction(VT)) { 2863f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner default: assert(0 && "Unknown type action!"); 2864f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Legal: 2865f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(VT); 2866f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2867f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Promote: 2868f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(getTypeToTransformTo(VT)); 2869f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner break; 2870f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner case Expand: 2871f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (VT != MVT::Vector) { 2872f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this is a large integer, it needs to be reassembled from small 2873f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers. Figure out what the source elt type is and how many small 2874f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // integers it is. 2875f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2876f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2877f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0; i != NumVals; ++i) 2878f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(NVT); 2879f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2880da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Otherwise, this is a vector type. We only support legal vectors 2881da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // right now. 2882da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const PackedType *PTy = cast<PackedType>(RetTy); 2883da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = PTy->getNumElements(); 2884da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = PTy->getElementType(); 2885da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 2886da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 2887da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 2888da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2889da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2890da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner RetTys.push_back(TVT); 2891da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 2892da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner assert(0 && "Don't support illegal by-val vector call results yet!"); 2893da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2894da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 2895f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2896f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2897f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2898f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2899f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(MVT::Other); // Always has a chain. 2900f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2901f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Finally, create the CALL node. 2902be384162c68641233deba8702666af51bdfd4b83Chris Lattner SDOperand Res = DAG.getNode(ISD::CALL, 2903be384162c68641233deba8702666af51bdfd4b83Chris Lattner DAG.getVTList(&RetTys[0], RetTys.size()), 2904be384162c68641233deba8702666af51bdfd4b83Chris Lattner &Ops[0], Ops.size()); 2905f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2906f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // This returns a pair of operands. The first element is the 2907f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // return value for the function (if RetTy is not VoidTy). The second 2908f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // element is the outgoing token chain. 2909f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand ResVal; 2910f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() != 1) { 2911f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner MVT::ValueType VT = getValueType(RetTy); 2912f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (RetTys.size() == 2) { 2913f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = Res; 2914f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2915f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // If this value was promoted, truncate it down. 2916f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner if (ResVal.getValueType() != VT) { 2917da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (VT == MVT::Vector) { 2918da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBITCONVERT to convert from the packed result type to the 2919da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // MVT::Vector type. 2920da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner unsigned NumElems = cast<PackedType>(RetTy)->getNumElements(); 2921da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner const Type *EltTy = cast<PackedType>(RetTy)->getElementType(); 2922da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner 2923da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Figure out if there is a Packed type corresponding to this Vector 2924da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // type. If so, convert to the packed type. 2925da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2926da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2927da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // Insert a VBIT_CONVERT of the FORMAL_ARGUMENTS to a 2928da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner // "N x PTyElementVT" MVT::Vector type. 2929da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner ResVal = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, ResVal, 2930d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getConstant(NumElems, MVT::i32), 2931d202ca4d988b5ee3f30656a7e82443db4752dd91Chris Lattner DAG.getValueType(getValueType(EltTy))); 2932da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else { 2933da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner abort(); 2934da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } 2935da098e7d1017e9435617d4c3de58ff72ae01ca22Chris Lattner } else if (MVT::isInteger(VT)) { 2936f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned AssertOp = RetTy->isSigned() ? 2937f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ISD::AssertSext : ISD::AssertZext; 2938f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(AssertOp, ResVal.getValueType(), ResVal, 2939f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner DAG.getValueType(VT)); 2940f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::TRUNCATE, VT, ResVal); 2941f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2942f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(MVT::isFloatingPoint(VT)); 2943f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::FP_ROUND, VT, ResVal); 2944f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2945f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2946f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else if (RetTys.size() == 3) { 2947f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ResVal = DAG.getNode(ISD::BUILD_PAIR, VT, 2948f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Res.getValue(0), Res.getValue(1)); 2949f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2950f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } else { 2951f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner assert(0 && "Case not handled yet!"); 2952f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2953f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 2954f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2955f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner return std::make_pair(ResVal, Res.getValue(Res.Val->getNumValues()-1)); 2956f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner} 2957f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2958f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 2959f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 296039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 296139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 2962f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner// 2963f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner// FIXME: Change this to insert a FRAMEADDR/RETURNADDR node, and have that be 2964f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner// expanded to 0 if the target wants. 296539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 296639ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 296739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 296839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 29691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 29701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 297150381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 2972171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 2973171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 2974d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 2975171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 2976171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 29770aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 29780aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 29790aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 29800aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 29810aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 29820aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 29830aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 298439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 2985b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Depth = (unsigned)cast<ConstantInt>(I.getOperand(1))->getZExtValue(); 298639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 2987a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 298839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 298939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 299039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 29911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 299274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 29931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 29941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 2995a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 29961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 29971db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 29981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 29991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 30001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 30011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 30021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 30031db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 30041db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 30051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 30061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 30071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 30081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 30091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 30101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 30111db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 30121db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 30131db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 30141db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 30151db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 30161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 30171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 30181db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 30191db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 30201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 30211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 302274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 302374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 302474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 302574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 302674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 302774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 302874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng MVT::ValueType CurVT = VT; 302974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 303074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng unsigned MSB = getSizeInBits(VT) / 8; 303174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 303274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 303374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 303474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Val = (Val << 8) | Str[Offset]; 303574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 303674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 303774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 303874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 303974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 30401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 30411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 30421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 30431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 30441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 30451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 30461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 3047c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 304880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 304980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 3050c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 3051c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 3052c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 30531db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 30541db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 30551db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 30561db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 30571db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 30581db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 30591db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 30601db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 30611db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 30621db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 30631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 30641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 30651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 30661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 30671db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 30681db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 30691db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 30701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 30711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 30721db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 30731db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 307480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 307580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 307680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 307780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 30781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 307980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 308080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 308180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 3082dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 30831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 30841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 30851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 30861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 30871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 30881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 308980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 309080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 309180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 309280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 30931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 30941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 30951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 309680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 309780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 30981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 30991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 31007041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 31011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 31021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 31031db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 31041db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 31051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 31061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 31071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 31081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 31091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 31101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 31111db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 31121db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 3113bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 31141db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 3115ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 31161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 3117c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 3118c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 311980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 31201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 31211db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 31221db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 31231db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 3124a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 3125786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng SDOperand Store = DAG.getStore(getRoot(), Value, 3126864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 31278b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), Offset); 3128c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 3129c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 3130c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3131c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3132c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 3133c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 3134c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 3135c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 3136c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 3137c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 3138cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 313974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 314074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 3141cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 314274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 314374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 314474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 314574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 314674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 314774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 314874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 3149cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 315074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 315174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 315274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 3153cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (GV) { 31540937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 3155cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 3156cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 3157cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 3158cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 3159cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 316074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 316174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 3162c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 3163c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 3164c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 316574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 316674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 3167cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 316874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 316974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 317074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 3171786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 3172786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 31738b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 317474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 317574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 317674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 3177466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng I.getOperand(2), SrcOff); 317874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 317974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 3180786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 3181786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 31828b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 318374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 3184c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 318574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 318674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 31871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 31881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 3189c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 31901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 31911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 3192c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 3193c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 3194bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 3195bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size())); 3196c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 3197c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 31981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 31991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 3200bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, getRoot(), Op1, Op2, Op3, Op4)); 32011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 32021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 32037041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 32047041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 32057041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 32061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 32071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 32081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 32091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 32101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3211495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 321236b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 321336b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 3214c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AU.addRequired<AliasAnalysis>(); 3215495a0b51915eb763576874f29192820b731edc22Chris Lattner} 32161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3217c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 32187e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// OptimizeNoopCopyExpression - We have determined that the specified cast 32197e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// instruction is a noop copy (e.g. it's casting from one pointer type to 32207e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner/// another, int->uint, or int->sbyte on PPC. 3221903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// 3222903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// Return true if any changes are made. 3223903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeNoopCopyExpression(CastInst *CI) { 32247e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *DefBB = CI->getParent(); 32257e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32267e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner /// InsertedCasts - Only insert a cast in each block once. 32277e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner std::map<BasicBlock*, CastInst*> InsertedCasts; 32287e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 3229903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = false; 32307e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end(); 32317e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UI != E; ) { 32327e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Use &TheUse = UI.getUse(); 32337e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *User = cast<Instruction>(*UI); 32347e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32357e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Figure out which BB this cast is used in. For PHI's this is the 32367e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // appropriate predecessor block. 32377e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock *UserBB = User->getParent(); 32387e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(User)) { 32397e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner unsigned OpVal = UI.getOperandNo()/2; 32407e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner UserBB = PN->getIncomingBlock(OpVal); 32417e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 32427e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32437e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Preincrement use iterator so we don't invalidate it. 32447e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner ++UI; 32457e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32467e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this user is in the same block as the cast, don't change the cast. 32477e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (UserBB == DefBB) continue; 32487e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32497e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If we have already inserted a cast into this block, use it. 32507e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner CastInst *&InsertedCast = InsertedCasts[UserBB]; 32517e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32527e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (!InsertedCast) { 32537e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner BasicBlock::iterator InsertPt = UserBB->begin(); 32547e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 32557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32567e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner InsertedCast = 32577e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 3258903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = true; 32597e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 32607e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 32617e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // Replace a use of the cast with a use of the new casat. 32627e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner TheUse = InsertedCast; 32637e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 3264903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3265903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If we removed all uses, nuke the cast. 3266903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->use_empty()) 3267903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner CI->eraseFromParent(); 3268903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3269903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return MadeChange; 32707e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner} 3271c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3272903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 3273903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// casting to the type of GEPI. 3274f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattnerstatic Instruction *InsertGEPComputeCode(Instruction *&V, BasicBlock *BB, 3275f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *GEPI, Value *Ptr, 3276f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Value *PtrOffset) { 3277903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (V) return V; // Already computed. 3278903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3279903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner BasicBlock::iterator InsertPt; 3280903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (BB == GEPI->getParent()) { 3281903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If insert into the GEP's block, insert right after the GEP. 3282903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = GEPI; 3283903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ++InsertPt; 3284903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3285903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 3286903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner InsertPt = BB->begin(); 3287903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 3288903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3289903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3290903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 3291903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // BB so that there is only one value live across basic blocks (the cast 3292903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // operand). 3293903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 3294903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 3295903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr = new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 3296903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3297903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Add the offset, cast it to the right type. 3298903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 3299f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner return V = new CastInst(Ptr, GEPI->getType(), "", InsertPt); 3300903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3301903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3302903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// ReplaceUsesOfGEPInst - Replace all uses of RepPtr with inserted code to 3303903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// compute its value. The RepPtr value can be computed with Ptr+PtrOffset. One 3304903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// trivial way of doing this would be to evaluate Ptr+PtrOffset in RepPtr's 3305903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// block, then ReplaceAllUsesWith'ing everything. However, we would prefer to 3306903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// sink PtrOffset into user blocks where doing so will likely allow us to fold 3307903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// the constant add into a load or store instruction. Additionally, if a user 3308903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner/// is a pointer-pointer cast, we look through it to find its users. 3309903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic void ReplaceUsesOfGEPInst(Instruction *RepPtr, Value *Ptr, 3310903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Constant *PtrOffset, BasicBlock *DefBB, 3311903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GetElementPtrInst *GEPI, 3312f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> &InsertedExprs) { 3313903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (!RepPtr->use_empty()) { 3314903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Instruction *User = cast<Instruction>(RepPtr->use_back()); 3315903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3316903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If the user is a Pointer-Pointer cast, recurse. 3317903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (isa<CastInst>(User) && isa<PointerType>(User->getType())) { 3318903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(User, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3319903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3320903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // Drop the use of RepPtr. The cast is dead. Don't delete it now, else we 3321903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // could invalidate an iterator. 3322903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->setOperand(0, UndefValue::get(RepPtr->getType())); 3323903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner continue; 3324903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3325903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3326903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a load of the pointer, or a store through the pointer, emit 3327903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // the increment into the load/store block. 3328f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner Instruction *NewVal; 3329903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (isa<LoadInst>(User) || 3330903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner (isa<StoreInst>(User) && User->getOperand(0) != RepPtr)) { 3331903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 3332903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->getParent(), GEPI, 3333903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3334903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3335903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this use is not foldable into the addressing mode, use a version 3336903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // emitted in the GEP block. 3337903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 3338903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Ptr, PtrOffset); 3339903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3340903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3341f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner if (GEPI->getType() != RepPtr->getType()) { 3342f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner BasicBlock::iterator IP = NewVal; 3343f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner ++IP; 3344f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner NewVal = new CastInst(NewVal, RepPtr->getType(), "", IP); 3345f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner } 3346903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner User->replaceUsesOfWith(RepPtr, NewVal); 3347903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3348903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner} 3349903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3350903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3351c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 3352c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 3353c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 3354c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 3355c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 3356c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 3357903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattnerstatic bool OptimizeGEPExpression(GetElementPtrInst *GEPI, 3358a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD) { 3359c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 3360c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 3361c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 3362c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 3363c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 3364c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 3365c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 3366c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 3367c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3368c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3369c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3370903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!isUsedOutsideDefBB) return false; 3371c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3372c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 3373c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 3374c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 3375903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool hasVariableIndex = false; 3376c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 3377c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 3378903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) { 3379b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue()) { 3380c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 3381c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 3382c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3383903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } else { 3384903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner hasVariableIndex = true; 3385903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3386c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3387903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3388903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner // If this is a "GEP X, 0, 0, 0", turn this into a cast. 3389903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !hasVariableIndex) { 3390903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner Value *NC = new CastInst(GEPI->getOperand(0), GEPI->getType(), 3391903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->getName(), GEPI); 3392903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->replaceAllUsesWith(NC); 3393903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner GEPI->eraseFromParent(); 3394903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 3395903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3396903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 33973802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 3398903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) 3399903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return false; 3400c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3401c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 3402c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 3403c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 3404a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const Type *UIntPtrTy = TD->getIntPtrType(); 3405c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr = new CastInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 3406c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 3407c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3408c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 3409c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 3410c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 3411c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 3412b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 3413c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 3414a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson ConstantOffset += TD->getStructLayout(StTy)->MemberOffsets[Field]; 3415c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 3416c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 3417c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 3418c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3419c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 3420c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 3421b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 3422b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getType()->isSigned()) 3423b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer ConstantOffset += (int64_t)TD->getTypeSize(Ty)*CI->getSExtValue(); 3424c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner else 3425b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer ConstantOffset += TD->getTypeSize(Ty)*CI->getZExtValue(); 3426c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 3427c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3428c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3429c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 3430c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3431c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 3432c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = new CastInst(Idx, UIntPtrTy, "", GEPI); 3433c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3434a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson uint64_t ElementSize = TD->getTypeSize(Ty); 3435c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 3436c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 3437b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Constant *SizeCst = ConstantInt::get(UIntPtrTy, ElementSize); 3438c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3439c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 3440c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 3441c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 3442c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3443c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 3444c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3445c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 3446c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 3447b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Constant *PtrOffset = ConstantInt::get(UIntPtrTy, ConstantOffset); 3448c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3449c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 3450c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 3451c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 3452c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 3453c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 3454c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 3455c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 3456c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 3457f0df8824eb2bf8a5fb91ce6fd1db590caf34f994Chris Lattner std::map<BasicBlock*,Instruction*> InsertedExprs; 3458903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner ReplaceUsesOfGEPInst(GEPI, Ptr, PtrOffset, DefBB, GEPI, InsertedExprs); 3459c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 3460c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 3461c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 3462903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner 3463903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner return true; 3464c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 3465c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 346657f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// SplitCritEdgesForPHIConstants - If this block has any PHI nodes with 346757f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// constant operands, and if any of the edges feeding the PHI node are 346857f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// critical, split them so that the assignments of a constant to a register 346957f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner/// will not be executed on a path that isn't relevant. 347057f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattnervoid SelectionDAGISel::SplitCritEdgesForPHIConstants(BasicBlock *BB) { 3471755480681c795d585c73556c028b6143c46bda86Chris Lattner // The most common case is that this is a PHI node with two incoming 3472755480681c795d585c73556c028b6143c46bda86Chris Lattner // successors handle this case efficiently, because it is simple. 3473755480681c795d585c73556c028b6143c46bda86Chris Lattner PHINode *PN = cast<PHINode>(BB->begin()); 3474755480681c795d585c73556c028b6143c46bda86Chris Lattner if (PN->getNumIncomingValues() == 2) { 3475755480681c795d585c73556c028b6143c46bda86Chris Lattner // If neither edge is critical, we never need to split. 3476755480681c795d585c73556c028b6143c46bda86Chris Lattner if (PN->getIncomingBlock(0)->getTerminator()->getNumSuccessors() == 1 && 3477755480681c795d585c73556c028b6143c46bda86Chris Lattner PN->getIncomingBlock(1)->getTerminator()->getNumSuccessors() == 1) 3478755480681c795d585c73556c028b6143c46bda86Chris Lattner return; 3479755480681c795d585c73556c028b6143c46bda86Chris Lattner 3480755480681c795d585c73556c028b6143c46bda86Chris Lattner BasicBlock::iterator BBI = BB->begin(); 3481755480681c795d585c73556c028b6143c46bda86Chris Lattner while ((PN = dyn_cast<PHINode>(BBI++))) { 3482755480681c795d585c73556c028b6143c46bda86Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 3483755480681c795d585c73556c028b6143c46bda86Chris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 3484755480681c795d585c73556c028b6143c46bda86Chris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 3485755480681c795d585c73556c028b6143c46bda86Chris Lattner } 3486755480681c795d585c73556c028b6143c46bda86Chris Lattner return; 3487755480681c795d585c73556c028b6143c46bda86Chris Lattner } 3488755480681c795d585c73556c028b6143c46bda86Chris Lattner 3489755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, things are a bit trickier. 3490755480681c795d585c73556c028b6143c46bda86Chris Lattner 3491755480681c795d585c73556c028b6143c46bda86Chris Lattner // BE SMART HERE. 3492755480681c795d585c73556c028b6143c46bda86Chris Lattner 349357f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner BasicBlock::iterator BBI = BB->begin(); 349457f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner while ((PN = dyn_cast<PHINode>(BBI++))) { 349557f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 349657f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 349757f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 349857f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner } 349957f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner} 350057f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner 350157f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner 35021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 35031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 35041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 35051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 35061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3507c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // First, split all critical edges for PHI nodes with incoming values that are 3508c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constants, this way the load of the constant into a vreg will not be placed 3509c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // into MBBs that are used some other way. 3510c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 35117e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // In this pass we also look for GEP and cast instructions that are used 35127e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // across basic blocks and rewrite them to improve basic-block-at-a-time 35137e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // selection. 35147e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // 3515c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 3516903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner bool MadeChange = true; 3517903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner while (MadeChange) { 3518903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange = false; 351936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 352057f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner // If this block has any PHI nodes with constant operands, and if any of the 352157f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner // edges feeding the PHI node are critical, split them. 352257f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner if (isa<PHINode>(BB->begin())) 352357f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner SplitCritEdgesForPHIConstants(BB); 3524c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 352557f9a43c64e8c5c8b2566fb6649754c11b59b98aChris Lattner for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) { 35267e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner Instruction *I = BBI++; 35277e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) { 3528903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeGEPExpression(GEPI, TLI.getTargetData()); 35297e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } else if (CastInst *CI = dyn_cast<CastInst>(I)) { 3530c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // If the source of the cast is a constant, then this should have 3531c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // already been constant folded. The only reason NOT to constant fold 3532c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // it is if something (e.g. LSR) was careful to place the constant 3533c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // evaluation in a block other than then one that uses it (e.g. to hoist 3534c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // the address of globals out of a loop). If this is the case, we don't 3535c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner // want to forward-subst the cast. 3536c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner if (isa<Constant>(CI->getOperand(0))) 3537c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner continue; 3538c970f062e0a66d97a06eca213486a16fae1b37a4Chris Lattner 35397e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is a noop copy, sink it into user blocks to reduce the number 35407e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // of virtual registers that must be created and coallesced. 35417e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType SrcVT = TLI.getValueType(CI->getOperand(0)->getType()); 35427e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner MVT::ValueType DstVT = TLI.getValueType(CI->getType()); 35437e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35447e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // This is an fp<->int conversion? 35457e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (MVT::isInteger(SrcVT) != MVT::isInteger(DstVT)) 35467e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner continue; 35477e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35487e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If this is an extension, it will be a zero or sign extension, which 35497e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // isn't a noop. 35507e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT < DstVT) continue; 35517e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35527e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If these values will be promoted, find out what they will be promoted 35537e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // to. This helps us consider truncates on PPC as noop copies when they 35547e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // are. 35557e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(SrcVT) == TargetLowering::Promote) 35567e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner SrcVT = TLI.getTypeToTransformTo(SrcVT); 35577e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (TLI.getTypeAction(DstVT) == TargetLowering::Promote) 35587e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner DstVT = TLI.getTypeToTransformTo(DstVT); 35597e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner 35607e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner // If, after promotion, these are the same types, this is a noop copy. 35617e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner if (SrcVT == DstVT) 3562903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner MadeChange |= OptimizeNoopCopyExpression(CI); 35637e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 35647e598096ea8db3f19f4ec8f4cb407aea996bd7c2Chris Lattner } 356536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 3566903236468c3ebb3f9ae8f51b6f2e68f10c7e1d3aChris Lattner } 3567c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 35681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 35691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 35701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 35711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 3572edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 35731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 35741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 35751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3576571e434a34e26f295f13db2dd07551de7e25f8a9Chris LattnerSDOperand SelectionDAGLowering::CopyValueToVirtualRegister(Value *V, 3577571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg) { 3578571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Op = getValue(V); 357918c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 3580d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 358118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 3582d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 3583d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 3584d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 3585d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 3586d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 3587d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 3588571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return DAG.getCopyToReg(getRoot(), Reg, Op); 35891c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } else if (SrcVT == MVT::Vector) { 359070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Handle copies from generic vectors to registers. 359170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 359270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NE = TLI.getPackedTypeBreakdown(cast<PackedType>(V->getType()), 359370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT, PTyLegalElementVT); 35941c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 359570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Insert a VBIT_CONVERT of the input vector to a "N x PTyElementVT" 359670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // MVT::Vector type. 359770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Op, 359870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getConstant(NE, MVT::i32), 359970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getValueType(PTyElementVT)); 360070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 360170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Loop over all of the elements of the resultant vector, 360270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // VEXTRACT_VECTOR_ELT'ing them, converting them to PTyLegalElementVT, then 360370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // copying them into output registers. 3604bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 3605571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Root = getRoot(); 360670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 360770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Elt = DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, PTyElementVT, 3608a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(i, TLI.getPointerTy())); 360970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 361070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are legal. 361170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 361270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyLegalElementVT > PTyElementVT) { 361370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are promoted. 361470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyLegalElementVT)) 361570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::FP_EXTEND, PTyLegalElementVT, Elt); 361670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 361770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::ANY_EXTEND, PTyLegalElementVT, Elt); 361870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 361970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 362070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are expanded. 362170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // The src value is expanded into multiple registers. 362270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 3623a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(0, TLI.getPointerTy())); 362470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 3625a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Elt, DAG.getConstant(1, TLI.getPointerTy())); 362670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Lo)); 362770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Hi)); 362870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 36291c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } 3630bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, 3631bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 3632d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 3633d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 3634fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 3635fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 3636fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 3637fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 3638571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return DAG.getCopyToReg(getRoot(), Reg, Op); 3639d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 3640d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 3641d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 3642a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(0, TLI.getPointerTy())); 3643d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 3644a844126c43976387a66dafbe5137a762169f1f34Evan Cheng Op, DAG.getConstant(1, TLI.getPointerTy())); 3645571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner Op = DAG.getCopyToReg(getRoot(), Reg, Lo); 3646d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 3647d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 36481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 36491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3650068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 3651068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 3652068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 36531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 3654068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 36550afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 3656bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 3657bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 3658bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3659bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 3660bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 3661bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 3662bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 3663bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 3664f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 3665bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 3666bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 3667bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 3668bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 3669571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(AI, FuncInfo.ValueMap[AI]); 3670bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 3671bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 36720afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 3673bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3674bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 3675966454129dc62260df1f438f0243f6877dcd185cChris Lattner // FIXME: this should insert code into the DAG! 3676bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 3677068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 3678068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3679068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 3680068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 3681f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 3682068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 3683068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3684068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 3685edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3686bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 3687bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 3688bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 36891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 36901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 36911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 36921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 36931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 36941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 36951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 36961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 3697f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 36981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 36991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 37001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 3701f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 3702ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 37031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 3704ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3705571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(I, VMI->second)); 37061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 37071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 37081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 37091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 37101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 37111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 37121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 37131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 3714edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 37151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 37161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 37171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 3718d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 37191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 37201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 37211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 37221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 37231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 3724d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (!isa<PHINode>(SuccBB->begin())) continue; 3725d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 37261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 37271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 37281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 37291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 37301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 37311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 37321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 3733f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 3734f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 3735f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 3736f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 3737f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 3738f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 3739f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 3740f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 3741ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3742571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(C, RegOut)); 3743f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 3744f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 3745f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 3746f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 3747ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 3748edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 3749ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 3750ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 3751ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 3752ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3753571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(PHIOp, Reg)); 3754ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 37551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3756edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3757f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 3758f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 37597e02151ce2686687446ba7293e66d6b096106e68Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 37607e02151ce2686687446ba7293e66d6b096106e68Chris Lattner unsigned NumElements; 37617e02151ce2686687446ba7293e66d6b096106e68Chris Lattner if (VT != MVT::Vector) 37627e02151ce2686687446ba7293e66d6b096106e68Chris Lattner NumElements = TLI.getNumElements(VT); 37637e02151ce2686687446ba7293e66d6b096106e68Chris Lattner else { 37647e02151ce2686687446ba7293e66d6b096106e68Chris Lattner MVT::ValueType VT1,VT2; 37657e02151ce2686687446ba7293e66d6b096106e68Chris Lattner NumElements = 37667e02151ce2686687446ba7293e66d6b096106e68Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 37677e02151ce2686687446ba7293e66d6b096106e68Chris Lattner VT1, VT2); 37687e02151ce2686687446ba7293e66d6b096106e68Chris Lattner } 3769f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 3770f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 37711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 37721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 37731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 37741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3775ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 37765a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 37777436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 37787436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 37797436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 37807436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 37817436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 37827436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 37837436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 37847436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 37857436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 37867436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 37877436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 37887436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 3789bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 3790bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &UnorderedChains[0], UnorderedChains.size())); 3791ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 3792ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 37931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 37941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 3795a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 3796f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 379737efe6764568a3829fee26aba532283131d1a104Nate Begeman // lowering, as well as any jump table information. 3798f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 3799f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 380037efe6764568a3829fee26aba532283131d1a104Nate Begeman JT = SDL.JT; 3801f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3802a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 3803a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 38041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 38051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3806f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 3807c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey // Get alias analysis for load/store combining. 3808c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AliasAnalysis &AA = getAnalysis<AliasAnalysis>(); 3809c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey 3810af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 3811c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey DAG.Combine(false, AA); 38122300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 38131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 38141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 3815f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 38161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 38171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 3818ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 3819f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 38201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 38211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 3822f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3823af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 3824c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey DAG.Combine(true, AA); 38252300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 3826a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 3827552c4a849422ad91fa9988255ae35aebbf3acf7bEvan Cheng 3828a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 3829a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 38301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 3831f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 38321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 38331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 3834f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 3835f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3836f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 3837f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 3838f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 3839f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 3840f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 3841f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 3842f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3843f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 3844f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 3845f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 38461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3847f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 3848f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 3849f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3850f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3851a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 38521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 385337efe6764568a3829fee26aba532283131d1a104Nate Begeman if (SwitchCases.empty() && JT.Reg == 0) { 3854f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 3855f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 3856f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 3857f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 385809e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 3859f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 3860f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3861f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 38621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3863f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 38649453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 38659453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 38669453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 386737efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.Reg) { 386837efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(SwitchCases.empty() && "Cannot have jump table and lowered switch"); 386937efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 387037efe6764568a3829fee26aba532283131d1a104Nate Begeman CurDAG = &SDAG; 387137efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 38729453eea49bca1c3904047db495855c93e001d1cdNate Begeman MachineBasicBlock *RangeBB = BB; 387337efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 387437efe6764568a3829fee26aba532283131d1a104Nate Begeman BB = JT.MBB; 387537efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.setCurrentBasicBlock(BB); 387637efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 387737efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.visitJumpTable(JT); 387837efe6764568a3829fee26aba532283131d1a104Nate Begeman SDAG.setRoot(SDL.getRoot()); 387937efe6764568a3829fee26aba532283131d1a104Nate Begeman CodeGenAndEmitDAG(SDAG); 388037efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 388137efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 388237efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 388337efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 388437efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 388537efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 3886f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (PHIBB == JT.Default) { 388709e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 3888f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(RangeBB); 3889f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 3890f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (BB->succ_end() != std::find(BB->succ_begin(),BB->succ_end(), PHIBB)) { 389109e460662a8d7328da1b938d5581a6ef3740b51dChris Lattner PHI->addRegOperand(PHINodesToUpdate[pi].second, false); 3892f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman PHI->addMachineBasicBlockOperand(BB); 389337efe6764568a3829fee26aba532283131d1a104Nate Begeman } 389437efe6764568a3829fee26aba532283131d1a104Nate Begeman } 389537efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 389637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 389737efe6764568a3829fee26aba532283131d1a104Nate Begeman 3898b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // If the switch block involved a branch to one of the actual successors, we 3899b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // need to update PHI nodes in that block. 3900b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 3901b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 3902b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 3903b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner "This is not a machine PHI node that we are updating!"); 3904b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (BB->isSuccessor(PHI->getParent())) { 3905b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner PHI->addRegOperand(PHINodesToUpdate[i].second, false); 3906b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner PHI->addMachineBasicBlockOperand(BB); 3907b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 3908b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 3909b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner 3910f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 3911f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 3912d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 3913f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 3914f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 3915f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 3916d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3917f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 3918f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 3919f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 3920d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3921f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 3922f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 3923f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 3924f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 3925d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3926d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Handle any PHI nodes in successors of this chunk, as if we were coming 3927d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // from the original BB before switch expansion. Note that PHI nodes can 3928d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // occur multiple times in PHINodesToUpdate. We have to be very careful to 3929d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // handle them the right number of times. 393057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner while ((BB = SwitchCases[i].TrueBB)) { // Handle LHS and RHS. 3931d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (MachineBasicBlock::iterator Phi = BB->begin(); 3932d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi != BB->end() && Phi->getOpcode() == TargetInstrInfo::PHI; ++Phi){ 3933d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // This value for this PHI node is recorded in PHINodesToUpdate, get it. 3934d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned pn = 0; ; ++pn) { 3935d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner assert(pn != PHINodesToUpdate.size() && "Didn't find PHI entry!"); 3936d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (PHINodesToUpdate[pn].first == Phi) { 3937d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addRegOperand(PHINodesToUpdate[pn].second, false); 3938d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi->addMachineBasicBlockOperand(SwitchCases[i].ThisBB); 3939d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner break; 3940d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 3941d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 3942f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3943d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3944d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Don't process RHS if same block as LHS. 394557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (BB == SwitchCases[i].FalseBB) 394657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 3947d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 3948d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // If we haven't handled the RHS, do so now. Otherwise, we're done. 39492452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner SwitchCases[i].TrueBB = SwitchCases[i].FalseBB; 395057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 3951f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 395257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner assert(SwitchCases[i].TrueBB == 0 && SwitchCases[i].FalseBB == 0); 3953a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 39541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 3955a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 395613ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 3957a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 3958a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 3959a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 3960a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 3961a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 396213ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 3963eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterScheduler::FunctionPassCtor Ctor = RegisterScheduler::getDefault(); 396413ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 396513ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 3966eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = ISHeuristic; 39679373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey RegisterScheduler::setDefault(Ctor); 39684ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 396913ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 39709ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey ScheduleDAG *SL = Ctor(this, &DAG, BB); 3971a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 3972cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 3973a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 39740e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 397503fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 39769ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim LaskeyHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 39779ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey return new HazardRecognizer(); 39789ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey} 39799ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 3980755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 3981755480681c795d585c73556c028b6143c46bda86Chris Lattner// Helper functions used by the generated instruction selector. 3982755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 3983755480681c795d585c73556c028b6143c46bda86Chris Lattner// Calls to these methods are generated by tblgen. 3984755480681c795d585c73556c028b6143c46bda86Chris Lattner 3985755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckAndMask - The isel is trying to match something like (and X, 255). If 3986755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 3987755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an AND, and DesiredMaskS is the value 3988755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 3989755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckAndMask(SDOperand LHS, ConstantSDNode *RHS, 3990755480681c795d585c73556c028b6143c46bda86Chris Lattner int64_t DesiredMaskS) { 3991755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 3992755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 3993755480681c795d585c73556c028b6143c46bda86Chris Lattner 3994755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 3995755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 3996755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 3997755480681c795d585c73556c028b6143c46bda86Chris Lattner 3998755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 3999755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 4000755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4001755480681c795d585c73556c028b6143c46bda86Chris Lattner 4002755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 4003755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 4004755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 4005755480681c795d585c73556c028b6143c46bda86Chris Lattner if (getTargetLowering().MaskedValueIsZero(LHS, NeededMask)) 4006755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4007755480681c795d585c73556c028b6143c46bda86Chris Lattner 4008755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 4009755480681c795d585c73556c028b6143c46bda86Chris Lattner 4010755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 4011755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4012755480681c795d585c73556c028b6143c46bda86Chris Lattner} 4013755480681c795d585c73556c028b6143c46bda86Chris Lattner 4014755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckOrMask - The isel is trying to match something like (or X, 255). If 4015755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 4016755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an OR, and DesiredMaskS is the value 4017755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 4018755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckOrMask(SDOperand LHS, ConstantSDNode *RHS, 4019755480681c795d585c73556c028b6143c46bda86Chris Lattner int64_t DesiredMaskS) { 4020755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 4021755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 4022755480681c795d585c73556c028b6143c46bda86Chris Lattner 4023755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 4024755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 4025755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4026755480681c795d585c73556c028b6143c46bda86Chris Lattner 4027755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 4028755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 4029755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4030755480681c795d585c73556c028b6143c46bda86Chris Lattner 4031755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 4032755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 4033755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 4034755480681c795d585c73556c028b6143c46bda86Chris Lattner 4035755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t KnownZero, KnownOne; 4036755480681c795d585c73556c028b6143c46bda86Chris Lattner getTargetLowering().ComputeMaskedBits(LHS, NeededMask, KnownZero, KnownOne); 4037755480681c795d585c73556c028b6143c46bda86Chris Lattner 4038755480681c795d585c73556c028b6143c46bda86Chris Lattner // If all the missing bits in the or are already known to be set, match! 4039755480681c795d585c73556c028b6143c46bda86Chris Lattner if ((NeededMask & KnownOne) == NeededMask) 4040755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 4041755480681c795d585c73556c028b6143c46bda86Chris Lattner 4042755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 4043755480681c795d585c73556c028b6143c46bda86Chris Lattner 4044755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 4045755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 4046755480681c795d585c73556c028b6143c46bda86Chris Lattner} 4047755480681c795d585c73556c028b6143c46bda86Chris Lattner 40489ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 40490e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 40500e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 40510e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 40520e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 40530e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 40540e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 40550e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 40560e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 40570e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 40580e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 40590e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 40600e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 40610e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 40620e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 40630e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 40640e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 40650e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 40660e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 40670e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 40680e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 40690e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 40700e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 40710e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 40720e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 40730e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 40740e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::cerr << "Could not match memory address. Inline asm failure!\n"; 40750e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 40760e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 40770e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 40780e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 40790e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(DAG.getConstant(4/*MEM*/ | (SelOps.size() << 3), MVT::i32)); 40800e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 40810e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 40820e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 40830e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 40840e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 40850e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 40860e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 40870e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 40880e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 4089