SelectionDAGISel.cpp revision 86ca3cacc5a56e862c8258ac9c9ee1e37598ebd8
11c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 31c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// The LLVM Compiler Infrastructure 41c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// 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" 155502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov#include "llvm/ADT/BitVector.h" 16c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey#include "llvm/Analysis/AliasAnalysis.h" 171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 18a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng#include "llvm/CodeGen/ScheduleDAG.h" 195502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov#include "llvm/Constants.h" 20adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 2336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner#include "llvm/GlobalVariable.h" 24ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner#include "llvm/InlineAsm.h" 251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 2743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey#include "llvm/IntrinsicInst.h" 285694b6e90eaf94fa7a21f101a8e4424d813a85ceReid Spencer#include "llvm/ParameterAttributes.h" 29ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen#include "llvm/CodeGen/Collector.h" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 3384bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineJumpTableInfo.h" 3484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 3584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 36eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey#include "llvm/CodeGen/SchedulerRegistry.h" 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 386f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman#include "llvm/Target/TargetRegisterInfo.h" 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 44124729155d860a0850eb4ef2a7cea4145e13a057Vladimir Prus#include "llvm/Target/TargetOptions.h" 457c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 47a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 487e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 51da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 527944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 53a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 54a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 55a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 56a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 57a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 583e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohmanstatic cl::opt<bool> 593e1a7aef17575d9c7058a035449d57e3c7295ed0Dan GohmanViewSUnitDAGs("view-sunit-dags", cl::Hidden, 605bab78527a946632cd9614daa0b9a82ee7b5e1ccChris Lattner cl::desc("Pop up a window to show SUnit dags after they are processed")); 617944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 623e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohmanstatic const bool ViewISelDAGs = 0, ViewSchedDAGs = 0, ViewSUnitDAGs = 0; 637944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 647944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 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> > 80e7e7d0d7e39d0c7c659d26b97e8081fce0fcd749Dale Johannesen ISHeuristic("pre-RA-sched", 813700f90c19f51deae00f85b80d31e1f7fbda1f99Chris Lattner cl::init(&createDefaultScheduler), 825bab78527a946632cd9614daa0b9a82ee7b5e1ccChris Lattner cl::desc("Instruction schedulers available (before register" 835bab78527a946632cd9614daa0b9a82ee7b5e1ccChris Lattner " allocation):")); 8413ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 859ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey static RegisterScheduler 869373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey defaultListDAGScheduler("default", " Best scheduler for the target", 879373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey createDefaultScheduler); 884ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng} // namespace 894ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 90bf996f1d5e441c7504ff155d818190f593d54672Chris Lattnernamespace { struct AsmOperandInfo; } 91bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 92864635ad7b3046d3042311423071152c613961deChris Lattnernamespace { 93864635ad7b3046d3042311423071152c613961deChris Lattner /// RegsForValue - This struct represents the physical registers that a 94864635ad7b3046d3042311423071152c613961deChris Lattner /// particular value is assigned and the type information about the value. 95864635ad7b3046d3042311423071152c613961deChris Lattner /// This is needed because values can be promoted into larger registers and 96864635ad7b3046d3042311423071152c613961deChris Lattner /// expanded into multiple smaller registers than the value. 979525528a7dc5462b6374d38c81ba5c07b11741feChris Lattner struct VISIBILITY_HIDDEN RegsForValue { 98b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman /// Regs - This list holds the register (for legal and promoted values) 99864635ad7b3046d3042311423071152c613961deChris Lattner /// or register set (for expanded values) that the value should be assigned 100864635ad7b3046d3042311423071152c613961deChris Lattner /// to. 101864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 102864635ad7b3046d3042311423071152c613961deChris Lattner 103864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT - The value type of each register. 104864635ad7b3046d3042311423071152c613961deChris Lattner /// 105864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 106864635ad7b3046d3042311423071152c613961deChris Lattner 107864635ad7b3046d3042311423071152c613961deChris Lattner /// ValueVT - The value type of the LLVM value, which may be promoted from 108864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT or made from merging the two expanded parts. 109864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT; 110864635ad7b3046d3042311423071152c613961deChris Lattner 111864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue() : RegVT(MVT::Other), ValueVT(MVT::Other) {} 112864635ad7b3046d3042311423071152c613961deChris Lattner 113864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(unsigned Reg, MVT::ValueType regvt, MVT::ValueType valuevt) 114864635ad7b3046d3042311423071152c613961deChris Lattner : RegVT(regvt), ValueVT(valuevt) { 115864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 116864635ad7b3046d3042311423071152c613961deChris Lattner } 117864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(const std::vector<unsigned> ®s, 118864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType regvt, MVT::ValueType valuevt) 119864635ad7b3046d3042311423071152c613961deChris Lattner : Regs(regs), RegVT(regvt), ValueVT(valuevt) { 120864635ad7b3046d3042311423071152c613961deChris Lattner } 121864635ad7b3046d3042311423071152c613961deChris Lattner 122864635ad7b3046d3042311423071152c613961deChris Lattner /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from 123864635ad7b3046d3042311423071152c613961deChris Lattner /// this value and returns the result as a ValueVT value. This uses 124864635ad7b3046d3042311423071152c613961deChris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 125b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman /// If the Flag pointer is NULL, no flag is used. 126864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand getCopyFromRegs(SelectionDAG &DAG, 127b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand &Chain, SDOperand *Flag) const; 128c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 129c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 130c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// specified value into the registers specified by this object. This uses 131c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 132b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman /// If the Flag pointer is NULL, no flag is used. 133c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 134b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand &Chain, SDOperand *Flag) const; 135c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 136c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// AddInlineAsmOperands - Add this value to the specified inlineasm node 137c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// operand list. This adds the code marker and includes the number of 138c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// values added into it. 139c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 1409f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const; 141864635ad7b3046d3042311423071152c613961deChris Lattner }; 142864635ad7b3046d3042311423071152c613961deChris Lattner} 1434ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 1441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 1451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 1469373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// createDefaultScheduler - This creates an instruction scheduler appropriate 1479373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey /// for the target. 1489373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey ScheduleDAG* createDefaultScheduler(SelectionDAGISel *IS, 1499373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey SelectionDAG *DAG, 1509373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey MachineBasicBlock *BB) { 1519373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering &TLI = IS->getTargetLowering(); 1529373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1539373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) { 1549373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createTDListDAGScheduler(IS, DAG, BB); 1559373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } else { 1569373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey assert(TLI.getSchedulingPreference() == 1579373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey TargetLowering::SchedulingForRegPressure && "Unknown sched type!"); 1589373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey return createBURRListDAGScheduler(IS, DAG, BB); 1599373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1609373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey } 1619373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1629373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey 1639373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey //===--------------------------------------------------------------------===// 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 1651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 166f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 167f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 1681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 1691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 1701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 17184bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner MachineRegisterInfo &RegInfo; 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 1741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 1761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 1819f24ad79ce32200b06499ef638b502fc1c36ed04Chris Lattner DenseMap<const Value*, unsigned> ValueMap; 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 1861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 1871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 188f40708223e409a152834b1553c6883ff2035b957Duncan Sands#ifndef NDEBUG 189f40708223e409a152834b1553c6883ff2035b957Duncan Sands SmallSet<Instruction*, 8> CatchInfoLost; 190f40708223e409a152834b1553c6883ff2035b957Duncan Sands SmallSet<Instruction*, 8> CatchInfoFound; 191f40708223e409a152834b1553c6883ff2035b957Duncan Sands#endif 192f40708223e409a152834b1553c6883ff2035b957Duncan Sands 1931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 19484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner return RegInfo.createVirtualRegister(TLI.getRegClassFor(VT)); 1951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 196571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 197571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner /// isExportedInst - Return true if the specified value is an instruction 198571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner /// exported from its block. 199571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner bool isExportedInst(const Value *V) { 200571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return ValueMap.count(V); 201571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 202edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2033c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned CreateRegForValue(const Value *V); 2043c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 2051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 2061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 2071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 2081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 213cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands/// isSelector - Return true if this instruction is a call to the 214cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands/// eh.selector intrinsic. 215cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sandsstatic bool isSelector(Instruction *I) { 216f40708223e409a152834b1553c6883ff2035b957Duncan Sands if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) 2178806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov return (II->getIntrinsicID() == Intrinsic::eh_selector_i32 || 2188806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov II->getIntrinsicID() == Intrinsic::eh_selector_i64); 219f40708223e409a152834b1553c6883ff2035b957Duncan Sands return false; 220f40708223e409a152834b1553c6883ff2035b957Duncan Sands} 221f40708223e409a152834b1553c6883ff2035b957Duncan Sands 2221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 223f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// PHI nodes or outside of the basic block that defines it, or used by a 224f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// switch instruction, which may expand to multiple basic blocks. 2251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 2261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 2271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 2281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 229f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI) || 230571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // FIXME: Remove switchinst special case. 231f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman isa<SwitchInst>(*UI)) 2321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 2331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 2341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 236bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 237f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// entry block, return true. This includes arguments used by switches, since 238f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the switch may expand into multiple basic blocks. 239bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 240bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 241bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 242f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != Entry || isa<SwitchInst>(*UI)) 243bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 244bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 245bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 246bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 248edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 24984bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegInfo(MF.getRegInfo()) { 2501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 251bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 252bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 25316ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 25416ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 255bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 256bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 2571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 258bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 259bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 260bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 2612aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 264b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (ConstantInt *CUI = dyn_cast<ConstantInt>(AI->getArraySize())) { 2651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 266514ab348fddcdffa8367685dc608b2f8d5de986dDuncan Sands uint64_t TySize = TLI.getTargetData()->getABITypeSize(Ty); 267ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 268d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner std::max((unsigned)TLI.getTargetData()->getPrefTypeAlignment(Ty), 269ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 270a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 271b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer TySize *= CUI->getZExtValue(); // Get total allocated size. 272d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 2731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 2746266c18ea12b42bd9b262a1f4f8c3d7a85130118Chris Lattner MF.getFrameInfo()->CreateStackObject(TySize, Align); 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2772aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 2782aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 2801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 2811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 2821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 2831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 2851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 2861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 2872aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 2881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 2891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 2901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 2911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 2931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 2941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 2958c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner for (BasicBlock::iterator I = BB->begin();(PN = dyn_cast<PHINode>(I)); ++I){ 2968c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (PN->use_empty()) continue; 2978c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 2988c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 2997f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman unsigned NumRegisters = TLI.getNumRegisters(VT); 3008c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned PHIReg = ValueMap[PN]; 3018c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner assert(PHIReg && "PHI node does not have an assigned virtual register!"); 302c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng const TargetInstrInfo *TII = TLI.getTargetMachine().getInstrInfo(); 303b9f10196961ebe5b5573a5705048a5a8a6b56bb3Dan Gohman for (unsigned i = 0; i != NumRegisters; ++i) 304c0f64ffab93d11fb27a3b8a0707b77400918a20eEvan Cheng BuildMI(MBB, TII->get(TargetInstrInfo::PHI), PHIReg+i); 3058c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 3061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 3081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3093c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// CreateRegForValue - Allocate the appropriate number of virtual registers of 3103c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// the correctly promoted or expanded types. Assign these registers 3113c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// consecutive vreg numbers and return the first assigned number. 3123c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattnerunsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) { 3133c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 3143c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 315b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned NumRegisters = TLI.getNumRegisters(VT); 316b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman MVT::ValueType RegisterVT = TLI.getRegisterType(VT); 31795b39550344bad0d15d1ffa7afc300eb1533ed19Bill Wendling 3188c8c5fcbd757b5c44fa7ad9af038a2f2d950b624Dan Gohman unsigned R = MakeReg(RegisterVT); 3198c8c5fcbd757b5c44fa7ad9af038a2f2d950b624Dan Gohman for (unsigned i = 1; i != NumRegisters; ++i) 3208c8c5fcbd757b5c44fa7ad9af038a2f2d950b624Dan Gohman MakeReg(RegisterVT); 3218c8c5fcbd757b5c44fa7ad9af038a2f2d950b624Dan Gohman 3223c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return R; 3233c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner} 3241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 3261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 3271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 3281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 3291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 3301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 3311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 3321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 3331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3340da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner DenseMap<const Value*, SDOperand> NodeMap; 3351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 336d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 337d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 338d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 339d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 340d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 341d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 3425502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov /// Case - A struct to record the Value for a switch case, and the 3435502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov /// case's target basic block. 3445502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov struct Case { 3455502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Constant* Low; 3465502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Constant* High; 3475502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov MachineBasicBlock* BB; 3485502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 3495502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Case() : Low(0), High(0), BB(0) { } 3505502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Case(Constant* low, Constant* high, MachineBasicBlock* bb) : 3515502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Low(low), High(high), BB(bb) { } 3525502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t size() const { 3535502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t rHigh = cast<ConstantInt>(High)->getSExtValue(); 3545502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t rLow = cast<ConstantInt>(Low)->getSExtValue(); 3555502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov return (rHigh - rLow + 1ULL); 3565502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 3575502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov }; 3585502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 3594198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov struct CaseBits { 3604198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov uint64_t Mask; 3614198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock* BB; 3624198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov unsigned Bits; 3634198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 3644198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CaseBits(uint64_t mask, MachineBasicBlock* bb, unsigned bits): 3654198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Mask(mask), BB(bb), Bits(bits) { } 3664198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov }; 3674198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 3685502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov typedef std::vector<Case> CaseVector; 3694198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov typedef std::vector<CaseBits> CaseBitsVector; 3705502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov typedef CaseVector::iterator CaseItr; 3715502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov typedef std::pair<CaseItr, CaseItr> CaseRange; 372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseRec - A struct with ctor used in lowering switches to a binary tree 374f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// of conditional branches. 375f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseRec { 376f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec(MachineBasicBlock *bb, Constant *lt, Constant *ge, CaseRange r) : 377f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseBB(bb), LT(lt), GE(ge), Range(r) {} 378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 379f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseBB - The MBB in which to emit the compare and branch 380f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *CaseBB; 381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// LT, GE - If nonzero, we know the current case value must be less-than or 382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// greater-than-or-equal-to these Constants. 383f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *LT; 384f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *GE; 385f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Range - A pair of iterators representing the range of case values to be 386f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// processed at this point in the binary search tree. 387f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange Range; 388f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 389b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 390b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov typedef std::vector<CaseRec> CaseRecVector; 3915502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 3925502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov /// The comparison function for sorting the switch case values in the vector. 3935502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov /// WARNING: Case ranges should be disjoint! 394f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 3954198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov bool operator () (const Case& C1, const Case& C2) { 3965502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov assert(isa<ConstantInt>(C1.Low) && isa<ConstantInt>(C2.High)); 3975502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov const ConstantInt* CI1 = cast<const ConstantInt>(C1.Low); 3985502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov const ConstantInt* CI2 = cast<const ConstantInt>(C2.High); 3995502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov return CI1->getValue().slt(CI2->getValue()); 400f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 401f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 4025502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 4034198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov struct CaseBitsCmp { 4044198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov bool operator () (const CaseBits& C1, const CaseBits& C2) { 4054198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return C1.Bits > C2.Bits; 4064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 4074198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov }; 4084198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 4095502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov unsigned Clusterify(CaseVector& Cases, const SwitchInst &SI); 410f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 4141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 4151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 4161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 417a69571c7991813c93cba64e88eced6899ce93d81Owen Anderson const TargetData *TD; 4185f43f92c69aae9837064cf08291db1b36a82789fDan Gohman AliasAnalysis &AA; 4191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 420f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 421f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 422f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 4233a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov /// JTCases - Vector of JumpTable structures used to communicate 4243a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov /// SwitchInst code generation information. 4253a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov std::vector<SelectionDAGISel::JumpTableBlock> JTCases; 4264198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov std::vector<SelectionDAGISel::BitTestBlock> BitTestCases; 427f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 4291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 4301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 431ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 432ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen /// GCI - Garbage collection metadata for the function. 433ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen CollectorMetadata *GCI; 4341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 4365f43f92c69aae9837064cf08291db1b36a82789fDan Gohman AliasAnalysis &aa, 437ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen FunctionLoweringInfo &funcinfo, 438ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen CollectorMetadata *gci) 4395f43f92c69aae9837064cf08291db1b36a82789fDan Gohman : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), AA(aa), 440ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen FuncInfo(funcinfo), GCI(gci) { 4411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 443a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 444a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 445a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 446d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 447d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 448edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 449d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 450d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 451d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 452d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 453d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 454d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 455d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 456d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 457bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, 458bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &PendingLoads[0], PendingLoads.size()); 459d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 460d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 461d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 462a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 463a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 464571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand CopyValueToVirtualRegister(Value *V, unsigned Reg); 465571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4691e7aa5c209109d07af30c8a2e9bfd82cf3824246Chris Lattner // Note: this doesn't use InstVisitor, because it has to work with 4701e7aa5c209109d07af30c8a2e9bfd82cf3824246Chris Lattner // ConstantExpr's in addition to instructions. 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 48328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 484466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 48595c218a83ecf77590b9dc40c636720772d2b5cd7Christopher Lamb bool isVolatile, unsigned Alignment); 4861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 487199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4890da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner void setValue(const Value *V, SDOperand NewN) { 4901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4920da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner N = NewN; 4931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4944e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 495e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner void GetRegistersForValue(AsmOperandInfo &OpInfo, bool HasEarlyClobber, 496e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner std::set<unsigned> &OutputRegs, 497e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner std::set<unsigned> &InputRegs); 498f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 499571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void FindMergedConditions(Value *Cond, MachineBasicBlock *TBB, 500571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, MachineBasicBlock *CurBB, 501571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc); 5028c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner bool isExportableFromCurrentBlock(Value *V, const BasicBlock *FromBB); 503571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner void ExportFromCurrentBlock(Value *V); 5046f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands void LowerCallTo(CallSite CS, SDOperand Callee, bool IsTailCall, 505070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov MachineBasicBlock *LandingPad = NULL); 506dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands 5071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 5081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 5091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 510f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 5111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 5121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 513b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Helpers for visitSwitch 514dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov bool handleSmallSwitchRange(CaseRec& CR, 515b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 516b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 517b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default); 518dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov bool handleJTSwitchCase(CaseRec& CR, 519b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 520b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 521b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default); 522dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov bool handleBTSplitSwitchCase(CaseRec& CR, 523b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 524b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 525b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default); 5264198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov bool handleBitTestsSwitchCase(CaseRec& CR, 5274198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CaseRecVector& WorkList, 5284198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Value* SV, 5294198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock* Default); 530f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 5314198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov void visitBitTestHeader(SelectionDAGISel::BitTestBlock &B); 5324198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov void visitBitTestCase(MachineBasicBlock* NextMBB, 5334198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov unsigned Reg, 5344198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SelectionDAGISel::BitTestCase &B); 53537efe6764568a3829fee26aba532283131d1a104Nate Begeman void visitJumpTable(SelectionDAGISel::JumpTable &JT); 5363a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov void visitJumpTableHeader(SelectionDAGISel::JumpTable &JT, 5373a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAGISel::JumpTableHeader &JTH); 538f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 5391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 540b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey void visitInvoke(InvokeInst &I); 541b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey void visitUnwind(UnwindInst &I); 5421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5437f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitBinary(User &I, unsigned OpCode); 544e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 5455fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 5467f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (I.getType()->isFPOrFPVector()) 5477f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman visitBinary(I, ISD::FADD); 5481628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 5497f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman visitBinary(I, ISD::ADD); 55001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 551b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 5521628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer void visitMul(User &I) { 5537f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (I.getType()->isFPOrFPVector()) 5547f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman visitBinary(I, ISD::FMUL); 5551628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer else 5567f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman visitBinary(I, ISD::MUL); 5571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5587f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitURem(User &I) { visitBinary(I, ISD::UREM); } 5597f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitSRem(User &I) { visitBinary(I, ISD::SREM); } 5607f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitFRem(User &I) { visitBinary(I, ISD::FREM); } 5617f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitUDiv(User &I) { visitBinary(I, ISD::UDIV); } 5627f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitSDiv(User &I) { visitBinary(I, ISD::SDIV); } 5637f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitFDiv(User &I) { visitBinary(I, ISD::FDIV); } 5647f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitAnd (User &I) { visitBinary(I, ISD::AND); } 5657f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitOr (User &I) { visitBinary(I, ISD::OR); } 5667f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman void visitXor (User &I) { visitBinary(I, ISD::XOR); } 56724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer void visitShl (User &I) { visitShift(I, ISD::SHL); } 5683822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer void visitLShr(User &I) { visitShift(I, ISD::SRL); } 5693822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer void visitAShr(User &I) { visitShift(I, ISD::SRA); } 57045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer void visitICmp(User &I); 57145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer void visitFCmp(User &I); 5723da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Visit the conversion instructions 5733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitTrunc(User &I); 5743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitZExt(User &I); 5753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitSExt(User &I); 5763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPTrunc(User &I); 5773da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPExt(User &I); 5783da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPToUI(User &I); 5793da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitFPToSI(User &I); 5803da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitUIToFP(User &I); 5813da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitSIToFP(User &I); 5823da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitPtrToInt(User &I); 5833da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitIntToPtr(User &I); 5843da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer void visitBitCast(User &I); 5851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5862bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5872bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 5883e104b11168da4692b69cc6b236c1da22adff959Chris Lattner void visitShuffleVector(User &I); 589c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 600fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands void visitInlineAsm(CallSite CS); 601c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 6020eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 6031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 6051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 6061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 6071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 6081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6097041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 6101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 6121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 6131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 6141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 6161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 6171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 6181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 6191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 6201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 6211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6226183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 623b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// getCopyFromParts - Create a value that contains the specified legal parts 624b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// combined into the value they represent. If the parts combine to a type 625b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// larger then ValueVT then AssertOp can be used to specify whether the extra 626b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// bits are known to be zero (ISD::AssertZext) or sign extended from ValueVT 627b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// (ISD::AssertSext). Likewise TruncExact is used for floating point types to 628b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// indicate that the extra bits can be discarded without losing precision. 6296183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohmanstatic SDOperand getCopyFromParts(SelectionDAG &DAG, 6306183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman const SDOperand *Parts, 6316183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman unsigned NumParts, 6326183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman MVT::ValueType PartVT, 6336183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman MVT::ValueType ValueVT, 634b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ISD::NodeType AssertOp = ISD::DELETED_NODE, 635b988baccc229ef3e175905c999245d5544a0d384Duncan Sands bool TruncExact = false) { 636014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumParts > 0 && "No parts to assemble!"); 637014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands TargetLowering &TLI = DAG.getTargetLoweringInfo(); 638014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands SDOperand Val = Parts[0]; 639014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 640014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (NumParts > 1) { 641014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Assemble the value from multiple parts. 642014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (!MVT::isVector(ValueVT)) { 643014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned PartBits = MVT::getSizeInBits(PartVT); 644014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned ValueBits = MVT::getSizeInBits(ValueVT); 645014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 646014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Assemble the power of 2 part. 647014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned RoundParts = NumParts & (NumParts - 1) ? 648014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 1 << Log2_32(NumParts) : NumParts; 649014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned RoundBits = PartBits * RoundParts; 650014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::ValueType RoundVT = RoundBits == ValueBits ? 651014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ValueVT : MVT::getIntegerType(RoundBits); 652014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands SDOperand Lo, Hi; 653014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 654014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (RoundParts > 2) { 655014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::ValueType HalfVT = MVT::getIntegerType(RoundBits/2); 656014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Lo = getCopyFromParts(DAG, Parts, RoundParts/2, PartVT, HalfVT); 657014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Hi = getCopyFromParts(DAG, Parts+RoundParts/2, RoundParts/2, 658014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands PartVT, HalfVT); 6596183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } else { 660014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Lo = Parts[0]; 661014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Hi = Parts[1]; 6626183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 663014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (TLI.isBigEndian()) 664014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands std::swap(Lo, Hi); 665014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ISD::BUILD_PAIR, RoundVT, Lo, Hi); 666014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 667014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (RoundParts < NumParts) { 668014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Assemble the trailing non-power-of-2 part. 669014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned OddParts = NumParts - RoundParts; 670014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::ValueType OddVT = MVT::getIntegerType(OddParts * PartBits); 671014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Hi = getCopyFromParts(DAG, Parts+RoundParts, OddParts, PartVT, OddVT); 672014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 673014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Combine the round and odd parts. 674014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Lo = Val; 675014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (TLI.isBigEndian()) 676014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands std::swap(Lo, Hi); 677014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::ValueType TotalVT = MVT::getIntegerType(NumParts * PartBits); 678014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Hi = DAG.getNode(ISD::ANY_EXTEND, TotalVT, Hi); 679014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Hi = DAG.getNode(ISD::SHL, TotalVT, Hi, 680014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getConstant(MVT::getSizeInBits(Lo.getValueType()), 681014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands TLI.getShiftAmountTy())); 682014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Lo = DAG.getNode(ISD::ZERO_EXTEND, TotalVT, Lo); 683014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ISD::OR, TotalVT, Lo, Hi); 684014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 685014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else { 686014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Handle a multi-element vector. 687014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::ValueType IntermediateVT, RegisterVT; 688014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned NumIntermediates; 689014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned NumRegs = 690014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands TLI.getVectorTypeBreakdown(ValueVT, IntermediateVT, NumIntermediates, 691014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands RegisterVT); 692014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 693014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!"); 694014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!"); 695014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(RegisterVT == Parts[0].getValueType() && 696014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands "Part type doesn't match part!"); 697014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 698014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Assemble the parts into intermediate operands. 699014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands SmallVector<SDOperand, 8> Ops(NumIntermediates); 700014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (NumIntermediates == NumParts) { 701014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // If the register was not expanded, truncate or copy the value, 702014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // as appropriate. 703014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands for (unsigned i = 0; i != NumParts; ++i) 704014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Ops[i] = getCopyFromParts(DAG, &Parts[i], 1, 705014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands PartVT, IntermediateVT); 706014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else if (NumParts > 0) { 707014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // If the intermediate type was expanded, build the intermediate operands 708014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // from the parts. 709014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumParts % NumIntermediates == 0 && 710014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands "Must expand into a divisible number of parts!"); 711014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned Factor = NumParts / NumIntermediates; 712014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands for (unsigned i = 0; i != NumIntermediates; ++i) 713014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Ops[i] = getCopyFromParts(DAG, &Parts[i * Factor], Factor, 714014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands PartVT, IntermediateVT); 715014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 716014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 717014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Build a vector with BUILD_VECTOR or CONCAT_VECTORS from the intermediate 718014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // operands. 719014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(MVT::isVector(IntermediateVT) ? 720014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ISD::CONCAT_VECTORS : ISD::BUILD_VECTOR, 721014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ValueVT, &Ops[0], NumIntermediates); 7226183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 723014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 7246183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 725014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // There is now one part, held in Val. Correct it to match ValueVT. 726014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands PartVT = Val.getValueType(); 7276183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 728014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (PartVT == ValueVT) 729014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return Val; 730014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 731014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::isVector(PartVT)) { 732014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(MVT::isVector(ValueVT) && "Unknown vector conversion!"); 733014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return DAG.getNode(ISD::BIT_CONVERT, ValueVT, Val); 7346183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 7356183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 736014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::isVector(ValueVT)) { 737014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(MVT::getVectorElementType(ValueVT) == PartVT && 738014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::getVectorNumElements(ValueVT) == 1 && 739014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands "Only trivial scalar-to-vector conversions should get here!"); 740014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return DAG.getNode(ISD::BUILD_VECTOR, ValueVT, Val); 741014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 7426183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 743014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::isInteger(PartVT) && 744014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::isInteger(ValueVT)) { 745014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::getSizeInBits(ValueVT) < MVT::getSizeInBits(PartVT)) { 746014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // For a truncate, see if we have any information to 747014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // indicate whether the truncated bits will always be 748014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // zero or sign-extension. 749014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (AssertOp != ISD::DELETED_NODE) 750014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(AssertOp, PartVT, Val, 751014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getValueType(ValueVT)); 752014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 753014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else { 754014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return DAG.getNode(ISD::ANY_EXTEND, ValueVT, Val); 755014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 7566183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 757014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 758014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::isFloatingPoint(PartVT) && MVT::isFloatingPoint(ValueVT)) 759014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return DAG.getNode(ISD::FP_ROUND, ValueVT, Val, 760014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getIntPtrConstant(TruncExact)); 761014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 762014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::getSizeInBits(PartVT) == MVT::getSizeInBits(ValueVT)) 763014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return DAG.getNode(ISD::BIT_CONVERT, ValueVT, Val); 764014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 765014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(0 && "Unknown mismatch!"); 7666183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman} 7676183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 768b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// getCopyToParts - Create a series of nodes that contain the specified value 769b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// split into legal parts. If the parts contain more bits than Val, then, for 770b988baccc229ef3e175905c999245d5544a0d384Duncan Sands/// integers, ExtendKind can be used to specify how to generate the extra bits. 7716183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohmanstatic void getCopyToParts(SelectionDAG &DAG, 7726183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman SDOperand Val, 7736183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman SDOperand *Parts, 7746183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman unsigned NumParts, 775b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType PartVT, 776b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ISD::NodeType ExtendKind = ISD::ANY_EXTEND) { 77725ac7e8364f475597e2a6f3628fce839583e1f45Dan Gohman TargetLowering &TLI = DAG.getTargetLoweringInfo(); 77825ac7e8364f475597e2a6f3628fce839583e1f45Dan Gohman MVT::ValueType PtrVT = TLI.getPointerTy(); 7796183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman MVT::ValueType ValueVT = Val.getValueType(); 780014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned PartBits = MVT::getSizeInBits(PartVT); 781014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(TLI.isTypeLegal(PartVT) && "Copying to an illegal type!"); 782014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 783014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (!NumParts) 784014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return; 785014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 786014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (!MVT::isVector(ValueVT)) { 787014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (PartVT == ValueVT) { 788014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumParts == 1 && "No-op copy with multiple parts!"); 789014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Parts[0] = Val; 790014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return; 791014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 792014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 793014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (NumParts * PartBits > MVT::getSizeInBits(ValueVT)) { 794014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // If the parts cover more bits than the value has, promote the value. 795014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::isFloatingPoint(PartVT) && MVT::isFloatingPoint(ValueVT)) { 796014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumParts == 1 && "Do not know what to promote to!"); 797014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ISD::FP_EXTEND, PartVT, Val); 798014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else if (MVT::isInteger(PartVT) && MVT::isInteger(ValueVT)) { 799014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ValueVT = MVT::getIntegerType(NumParts * PartBits); 800014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ExtendKind, ValueVT, Val); 801014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else { 802014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(0 && "Unknown mismatch!"); 803014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 804014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else if (PartBits == MVT::getSizeInBits(ValueVT)) { 805014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Different types of the same size. 806014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumParts == 1 && PartVT != ValueVT); 807014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ISD::BIT_CONVERT, PartVT, Val); 808014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else if (NumParts * PartBits < MVT::getSizeInBits(ValueVT)) { 809014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // If the parts cover less bits than value has, truncate the value. 810014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (MVT::isInteger(PartVT) && MVT::isInteger(ValueVT)) { 811014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ValueVT = MVT::getIntegerType(NumParts * PartBits); 812014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 813014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else { 814014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(0 && "Unknown mismatch!"); 815014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 816014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 8176183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 818014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // The value may have changed - recompute ValueVT. 819014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ValueVT = Val.getValueType(); 820014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(NumParts * PartBits == MVT::getSizeInBits(ValueVT) && 821014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands "Failed to tile the value with PartVT!"); 822014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 823014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (NumParts == 1) { 824014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(PartVT == ValueVT && "Type conversion failed!"); 825014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Parts[0] = Val; 8266183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman return; 8276183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 8286183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 829014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Expand the value into multiple parts. 830014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (NumParts & (NumParts - 1)) { 831014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // The number of parts is not a power of 2. Split off and copy the tail. 832014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(MVT::isInteger(PartVT) && MVT::isInteger(ValueVT) && 833014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands "Do not know what to expand to!"); 834014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned RoundParts = 1 << Log2_32(NumParts); 835014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned RoundBits = RoundParts * PartBits; 836014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned OddParts = NumParts - RoundParts; 837014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands SDOperand OddVal = DAG.getNode(ISD::SRL, ValueVT, Val, 838014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getConstant(RoundBits, 839014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands TLI.getShiftAmountTy())); 840014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands getCopyToParts(DAG, OddVal, Parts + RoundParts, OddParts, PartVT); 841014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (TLI.isBigEndian()) 842014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // The odd parts were reversed by getCopyToParts - unreverse them. 843014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands std::reverse(Parts + RoundParts, Parts + NumParts); 844014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands NumParts = RoundParts; 845014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ValueVT = MVT::getIntegerType(NumParts * PartBits); 846014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Val = DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 847014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 848014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 849014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // The number of parts is a power of 2. Repeatedly bisect the value using 850014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // EXTRACT_ELEMENT. 851014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Parts[0] = Val; 852014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands for (unsigned StepSize = NumParts; StepSize > 1; StepSize /= 2) { 853014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands for (unsigned i = 0; i < NumParts; i += StepSize) { 854014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands unsigned ThisBits = StepSize * PartBits / 2; 855014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands MVT::ValueType ThisVT = 856014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands ThisBits == PartBits ? PartVT : MVT::getIntegerType (ThisBits); 857014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 858014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Parts[i+StepSize/2] = 859014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getNode(ISD::EXTRACT_ELEMENT, ThisVT, Parts[i], 860014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getConstant(1, PtrVT)); 861014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands Parts[i] = 862014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getNode(ISD::EXTRACT_ELEMENT, ThisVT, Parts[i], 863014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands DAG.getConstant(0, PtrVT)); 864014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 865014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 866014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 867014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (TLI.isBigEndian()) 868014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands std::reverse(Parts, Parts + NumParts); 869014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 870014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands return; 871014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } 872014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 873014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands // Vector ValueVT. 874014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands if (NumParts == 1) { 8756183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman if (PartVT != ValueVT) { 8766183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman if (MVT::isVector(PartVT)) { 8776183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman Val = DAG.getNode(ISD::BIT_CONVERT, PartVT, Val); 878014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands } else { 879014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands assert(MVT::getVectorElementType(ValueVT) == PartVT && 880a9b511187b5450ec2e241f45b640358bfdc9c42cDan Gohman MVT::getVectorNumElements(ValueVT) == 1 && 881a9b511187b5450ec2e241f45b640358bfdc9c42cDan Gohman "Only trivial vector-to-scalar conversions should get here!"); 882a9b511187b5450ec2e241f45b640358bfdc9c42cDan Gohman Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, PartVT, Val, 883a9b511187b5450ec2e241f45b640358bfdc9c42cDan Gohman DAG.getConstant(0, PtrVT)); 8846183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 8856183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 886014e04a5daeb312b1f0ebc1dd906ffc97c4abc5fDuncan Sands 8876183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman Parts[0] = Val; 8886183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman return; 8896183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 8906183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 8916183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // Handle a multi-element vector. 8926183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman MVT::ValueType IntermediateVT, RegisterVT; 8936183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman unsigned NumIntermediates; 8946183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman unsigned NumRegs = 8956183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman DAG.getTargetLoweringInfo() 8966183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman .getVectorTypeBreakdown(ValueVT, IntermediateVT, NumIntermediates, 8976183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman RegisterVT); 8986183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman unsigned NumElements = MVT::getVectorNumElements(ValueVT); 8996183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 9006183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!"); 9016183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!"); 9026183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 9036183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // Split the vector into intermediate operands. 9046183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman SmallVector<SDOperand, 8> Ops(NumIntermediates); 9056183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman for (unsigned i = 0; i != NumIntermediates; ++i) 9066183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman if (MVT::isVector(IntermediateVT)) 9076183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman Ops[i] = DAG.getNode(ISD::EXTRACT_SUBVECTOR, 9086183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman IntermediateVT, Val, 9096183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman DAG.getConstant(i * (NumElements / NumIntermediates), 91025ac7e8364f475597e2a6f3628fce839583e1f45Dan Gohman PtrVT)); 9116183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman else 9126183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman Ops[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, 9136183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman IntermediateVT, Val, 91425ac7e8364f475597e2a6f3628fce839583e1f45Dan Gohman DAG.getConstant(i, PtrVT)); 9156183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 9166183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // Split the intermediate operands into legal parts. 9176183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman if (NumParts == NumIntermediates) { 9186183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // If the register was not expanded, promote or copy the value, 9196183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // as appropriate. 9206183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman for (unsigned i = 0; i != NumParts; ++i) 921532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman getCopyToParts(DAG, Ops[i], &Parts[i], 1, PartVT); 9226183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } else if (NumParts > 0) { 9236183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // If the intermediate type was expanded, split each the value into 9246183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman // legal parts. 9256183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman assert(NumParts % NumIntermediates == 0 && 9266183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman "Must expand into a divisible number of parts!"); 9276183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman unsigned Factor = NumParts / NumIntermediates; 9286183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman for (unsigned i = 0; i != NumIntermediates; ++i) 929532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman getCopyToParts(DAG, Ops[i], &Parts[i * Factor], Factor, PartVT); 9306183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman } 9316183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman} 9326183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 9336183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman 934199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 935199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 936199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 937199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 938199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 939199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 940199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 941199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 942199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 9430da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner SDOperand N1 = NodeMap[V]; 9440da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner assert(N1.Val && "visit didn't populate the ValueMap!"); 9450da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner return N1; 946199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 947199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 948199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 949199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 950199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 9519d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (!isa<VectorType>(VTy)) 95223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 95323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 9547f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman // Create a BUILD_VECTOR of undef nodes. 9559d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(VTy); 95623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 95723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 95823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 959bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 96023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 96123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 96223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 9637f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman MVT::ValueType VT = MVT::getVectorType(PVT, NumElements); 9647f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman return N = DAG.getNode(ISD::BUILD_VECTOR, VT, 965bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()); 966199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 96743421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen return N = DAG.getConstantFP(CFP->getValueAPF(), VT); 9689d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer } else if (const VectorType *PTy = dyn_cast<VectorType>(VTy)) { 969199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 970199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 971199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 972199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 973199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 97407a96765daedf180a7102d39fe56c499878312b7Dan Gohman // the vector constant. 975bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 9769d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) { 9772bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 9782bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 979199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 98007a96765daedf180a7102d39fe56c499878312b7Dan Gohman assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!"); 981199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 982199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 983199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 984199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 985199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 986199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 987199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 988199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 9897f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman // Create a BUILD_VECTOR node. 9907f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman MVT::ValueType VT = MVT::getVectorType(PVT, NumElements); 9917f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, VT, &Ops[0], 9920da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner Ops.size()); 993199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 994199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 9956b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng return N = DAG.getConstant(cast<ConstantInt>(C)->getZExtValue(),VT); 996199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 997199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 998199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 999199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 1000199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 1001199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 1002199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 1003199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 1004199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 1005199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 1006251db1890c1fe03d02ee878ada8129537844d031Chris Lattner unsigned InReg = FuncInfo.ValueMap[V]; 1007251db1890c1fe03d02ee878ada8129537844d031Chris Lattner assert(InReg && "Value not in map!"); 1008199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 1009b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman MVT::ValueType RegisterVT = TLI.getRegisterType(VT); 1010b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned NumRegs = TLI.getNumRegisters(VT); 1011b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 1012b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman std::vector<unsigned> Regs(NumRegs); 1013b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman for (unsigned i = 0; i != NumRegs; ++i) 1014b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman Regs[i] = InReg + i; 1015b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 1016b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman RegsForValue RFV(Regs, RegisterVT, VT); 1017b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand Chain = DAG.getEntryNode(); 1018b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 1019b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman return RFV.getCopyFromRegs(DAG, Chain, NULL); 1020199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 1021199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 1022199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 10231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 10241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 1025a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 10261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 10271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1028bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> NewValues; 1029ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 1030ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 1031ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 1032b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType VT = RetOp.getValueType(); 1033b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 10348e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // FIXME: C calling convention requires the return type to be promoted to 10358e7d056bc5c0688501f6721994c8f4074d699c69Evan Cheng // at least 32-bit. But this is not necessary for non-C calling conventions. 1036b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (MVT::isInteger(VT)) { 1037b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType MinVT = TLI.getRegisterType(MVT::i32); 1038b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (MVT::getSizeInBits(VT) < MVT::getSizeInBits(MinVT)) 1039b988baccc229ef3e175905c999245d5544a0d384Duncan Sands VT = MinVT; 1040b988baccc229ef3e175905c999245d5544a0d384Duncan Sands } 1041b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 1042b988baccc229ef3e175905c999245d5544a0d384Duncan Sands unsigned NumParts = TLI.getNumRegisters(VT); 1043b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType PartVT = TLI.getRegisterType(VT); 1044b988baccc229ef3e175905c999245d5544a0d384Duncan Sands SmallVector<SDOperand, 4> Parts(NumParts); 1045b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ISD::NodeType ExtendKind = ISD::ANY_EXTEND; 1046b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 1047b988baccc229ef3e175905c999245d5544a0d384Duncan Sands const Function *F = I.getParent()->getParent(); 1048b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (F->paramHasAttr(0, ParamAttr::SExt)) 1049b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ExtendKind = ISD::SIGN_EXTEND; 1050b988baccc229ef3e175905c999245d5544a0d384Duncan Sands else if (F->paramHasAttr(0, ParamAttr::ZExt)) 1051b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ExtendKind = ISD::ZERO_EXTEND; 1052b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 1053b988baccc229ef3e175905c999245d5544a0d384Duncan Sands getCopyToParts(DAG, RetOp, &Parts[0], NumParts, PartVT, ExtendKind); 1054b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 1055b988baccc229ef3e175905c999245d5544a0d384Duncan Sands for (unsigned i = 0; i < NumParts; ++i) { 1056b988baccc229ef3e175905c999245d5544a0d384Duncan Sands NewValues.push_back(Parts[i]); 10576183f78cf8c6f56cc436f19120acf2a7856cb9dbDan Gohman NewValues.push_back(DAG.getConstant(false, MVT::i32)); 1058ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 10591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1060bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, 1061bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &NewValues[0], NewValues.size())); 10621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1064571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// ExportFromCurrentBlock - If this condition isn't known to be exported from 1065571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// the current basic block, add it to ValueMap now so that we'll get a 1066571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// CopyTo/FromReg. 1067571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::ExportFromCurrentBlock(Value *V) { 1068571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // No need to export constants. 1069571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (!isa<Instruction>(V) && !isa<Argument>(V)) return; 1070571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1071571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Already exported? 1072571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (FuncInfo.isExportedInst(V)) return; 1073571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1074571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg = FuncInfo.InitializeRegForValue(V); 1075571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner PendingLoads.push_back(CopyValueToVirtualRegister(V, Reg)); 1076571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 1077571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 10788c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattnerbool SelectionDAGLowering::isExportableFromCurrentBlock(Value *V, 10798c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner const BasicBlock *FromBB) { 10808c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // The operands of the setcc have to be in this block. We don't know 10818c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // how to export them from some other block. 10828c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Instruction *VI = dyn_cast<Instruction>(V)) { 10838c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Can export from current BB. 10848c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (VI->getParent() == FromBB) 10858c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 10868c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 10878c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Is already exported, noop. 10888c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return FuncInfo.isExportedInst(V); 10898c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 10908c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 10918c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // If this is an argument, we can export it if the BB is the entry block or 10928c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // if it is already exported. 10938c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (isa<Argument>(V)) { 10948c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (FromBB == &FromBB->getParent()->getEntryBlock()) 10958c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 10968c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 10978c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Otherwise, can only export this if it is already exported. 10988c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return FuncInfo.isExportedInst(V); 10998c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 11008c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 11018c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Otherwise, constants can always be exported. 11028c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner return true; 11038c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner} 11048c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 11056a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattnerstatic bool InBlock(const Value *V, const BasicBlock *BB) { 11066a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner if (const Instruction *I = dyn_cast<Instruction>(V)) 11076a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner return I->getParent() == BB; 11086a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner return true; 11096a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner} 11106a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner 1111571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner/// FindMergedConditions - If Cond is an expression like 1112571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattnervoid SelectionDAGLowering::FindMergedConditions(Value *Cond, 1113571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TBB, 1114571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *FBB, 1115571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *CurBB, 1116571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Opc) { 1117571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this node is not part of the or/and tree, emit it as a branch. 1118e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Instruction *BOp = dyn_cast<Instruction>(Cond); 1119571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1120e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) || 1121e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() || 11226a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner BOp->getParent() != CurBB->getBasicBlock() || 11236a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) || 11246a586c8d9a7ba032adf0619d06473310c41cae14Chris Lattner !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) { 1125571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner const BasicBlock *BB = CurBB->getBasicBlock(); 1126571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1127e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // If the leaf of the tree is a comparison, merge the condition into 1128e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // the caseblock. 1129e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if ((isa<ICmpInst>(Cond) || isa<FCmpInst>(Cond)) && 1130e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // The operands of the cmp have to be in this block. We don't know 11315a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner // how to export them from some other block. If this is the first block 11325a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner // of the sequence, no exporting is needed. 11335a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner (CurBB == CurMBB || 11345a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner (isExportableFromCurrentBlock(BOp->getOperand(0), BB) && 11355a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner isExportableFromCurrentBlock(BOp->getOperand(1), BB)))) { 1136e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer BOp = cast<Instruction>(Cond); 1137e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode Condition; 1138e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *IC = dyn_cast<ICmpInst>(Cond)) { 1139e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (IC->getPredicate()) { 1140e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: assert(0 && "Unknown icmp predicate opcode!"); 1141e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_EQ: Condition = ISD::SETEQ; break; 1142e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_NE: Condition = ISD::SETNE; break; 1143e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLE: Condition = ISD::SETLE; break; 1144e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULE: Condition = ISD::SETULE; break; 1145e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGE: Condition = ISD::SETGE; break; 1146e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGE: Condition = ISD::SETUGE; break; 1147e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLT: Condition = ISD::SETLT; break; 1148e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULT: Condition = ISD::SETULT; break; 1149e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGT: Condition = ISD::SETGT; break; 1150e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGT: Condition = ISD::SETUGT; break; 1151e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 1152e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else if (FCmpInst *FC = dyn_cast<FCmpInst>(Cond)) { 1153e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode FPC, FOC; 1154e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (FC->getPredicate()) { 1155e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: assert(0 && "Unknown fcmp predicate opcode!"); 1156e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: FOC = FPC = ISD::SETFALSE; break; 1157e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OEQ: FOC = ISD::SETEQ; FPC = ISD::SETOEQ; break; 1158e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGT: FOC = ISD::SETGT; FPC = ISD::SETOGT; break; 1159e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGE: FOC = ISD::SETGE; FPC = ISD::SETOGE; break; 1160e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLT: FOC = ISD::SETLT; FPC = ISD::SETOLT; break; 1161e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLE: FOC = ISD::SETLE; FPC = ISD::SETOLE; break; 1162e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ONE: FOC = ISD::SETNE; FPC = ISD::SETONE; break; 1163e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ORD: FOC = ISD::SETEQ; FPC = ISD::SETO; break; 1164e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNO: FOC = ISD::SETNE; FPC = ISD::SETUO; break; 1165e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UEQ: FOC = ISD::SETEQ; FPC = ISD::SETUEQ; break; 1166e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGT: FOC = ISD::SETGT; FPC = ISD::SETUGT; break; 1167e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGE: FOC = ISD::SETGE; FPC = ISD::SETUGE; break; 1168e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULT: FOC = ISD::SETLT; FPC = ISD::SETULT; break; 1169e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULE: FOC = ISD::SETLE; FPC = ISD::SETULE; break; 1170e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNE: FOC = ISD::SETNE; FPC = ISD::SETUNE; break; 1171e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: FOC = FPC = ISD::SETTRUE; break; 1172e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 1173e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FiniteOnlyFPMath()) 1174e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FOC; 1175e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else 1176e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FPC; 1177e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else { 11780da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner Condition = ISD::SETEQ; // silence warning. 1179e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer assert(0 && "Unknown compare instruction"); 1180571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 1181571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1182571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SelectionDAGISel::CaseBlock CB(Condition, BOp->getOperand(0), 11835502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov BOp->getOperand(1), NULL, TBB, FBB, CurBB); 1184571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 1185571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 1186571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 1187571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1188571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Create a CaseBlock record representing this branch. 11896b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng SelectionDAGISel::CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(), 11905502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov NULL, TBB, FBB, CurBB); 1191571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SwitchCases.push_back(CB); 1192571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner return; 1193571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 1194571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1195d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 1196d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Create TmpBB after CurBB. 1197571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineFunction::iterator BBI = CurBB; 1198571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner MachineBasicBlock *TmpBB = new MachineBasicBlock(CurBB->getBasicBlock()); 1199571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner CurBB->getParent()->getBasicBlockList().insert(++BBI, TmpBB); 1200571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1201d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner if (Opc == Instruction::Or) { 1202d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X | Y as: 1203d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TBB 1204d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp TmpBB 1205d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 1206d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 1207d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 1208d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 1209571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1210d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 1211d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, Opc); 1212d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 1213d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 1214d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 1215d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } else { 1216d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner assert(Opc == Instruction::And && "Unknown merge op!"); 1217d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Codegen X & Y as: 1218d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_X TmpBB 1219d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 1220d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // TmpBB: 1221d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp_if_Y TBB 1222d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // jmp FBB 1223d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // 1224d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // This requires creation of TmpBB after CurBB. 1225d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 1226d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the LHS condition. 1227d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, Opc); 1228d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner 1229d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner // Emit the RHS condition into TmpBB. 1230d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, Opc); 1231d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner } 1232571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner} 1233571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1234df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// If the set of cases should be emitted as a series of branches, return true. 1235df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// If we should emit this as a bunch of and/or'd together conditions, return 1236df19f27d039fd791c73e39f4134319debc75db4fChris Lattner/// false. 1237df19f27d039fd791c73e39f4134319debc75db4fChris Lattnerstatic bool 1238df19f27d039fd791c73e39f4134319debc75db4fChris LattnerShouldEmitAsBranches(const std::vector<SelectionDAGISel::CaseBlock> &Cases) { 1239df19f27d039fd791c73e39f4134319debc75db4fChris Lattner if (Cases.size() != 2) return true; 1240df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 12410ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // If this is two comparisons of the same values or'd or and'd together, they 12420ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // will get folded into a single comparison, so don't emit two blocks. 12430ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner if ((Cases[0].CmpLHS == Cases[1].CmpLHS && 12440ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner Cases[0].CmpRHS == Cases[1].CmpRHS) || 12450ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner (Cases[0].CmpRHS == Cases[1].CmpLHS && 12460ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner Cases[0].CmpLHS == Cases[1].CmpRHS)) { 12470ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner return false; 12480ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner } 12490ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1250df19f27d039fd791c73e39f4134319debc75db4fChris Lattner return true; 1251df19f27d039fd791c73e39f4134319debc75db4fChris Lattner} 1252df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 12531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 12541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 12551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 12561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 12581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 12591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 12601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 12611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 12621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 12641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 12651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 1266a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1267dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 126857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 126957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // Update machine-CFG edges. 127057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(Succ0MBB); 127157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner return; 127257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner } 127357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 127457ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // If this condition is one of the special cases we handle, do special stuff 127557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner // now. 127657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner Value *CondVal = I.getCondition(); 127757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 1278571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner 1279571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // If this is a series of conditions that are or'd or and'd together, emit 1280571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // this as a sequence of branches instead of setcc's with and/or operations. 1281571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // For example, instead of something like: 1282571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 1283571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // C = seteq 1284571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 1285571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // F = setle 1286571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // or C, F 1287571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jnz foo 1288571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // Emit: 1289571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp A, B 1290571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // je foo 1291571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // cmp D, E 1292571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // jle foo 1293571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner // 1294571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) { 1295571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner if (BOp->hasOneUse() && 1296d2f9ee9ea7b08c23a8742b6a53dd78a20233adc0Chris Lattner (BOp->getOpcode() == Instruction::And || 1297571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner BOp->getOpcode() == Instruction::Or)) { 1298571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner FindMergedConditions(BOp, Succ0MBB, Succ1MBB, CurMBB, BOp->getOpcode()); 12990ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // If the compares in later blocks need to use values not currently 13000ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // exported from this block, export them now. This block should always 13010ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // be the first entry. 13020ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner assert(SwitchCases[0].ThisBB == CurMBB && "Unexpected lowering!"); 13030ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1304df19f27d039fd791c73e39f4134319debc75db4fChris Lattner // Allow some cases to be rejected. 1305df19f27d039fd791c73e39f4134319debc75db4fChris Lattner if (ShouldEmitAsBranches(SwitchCases)) { 1306df19f27d039fd791c73e39f4134319debc75db4fChris Lattner for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) { 1307df19f27d039fd791c73e39f4134319debc75db4fChris Lattner ExportFromCurrentBlock(SwitchCases[i].CmpLHS); 1308df19f27d039fd791c73e39f4134319debc75db4fChris Lattner ExportFromCurrentBlock(SwitchCases[i].CmpRHS); 1309df19f27d039fd791c73e39f4134319debc75db4fChris Lattner } 1310df19f27d039fd791c73e39f4134319debc75db4fChris Lattner 1311df19f27d039fd791c73e39f4134319debc75db4fChris Lattner // Emit the branch for this block. 1312df19f27d039fd791c73e39f4134319debc75db4fChris Lattner visitSwitchCase(SwitchCases[0]); 1313df19f27d039fd791c73e39f4134319debc75db4fChris Lattner SwitchCases.erase(SwitchCases.begin()); 1314df19f27d039fd791c73e39f4134319debc75db4fChris Lattner return; 13155a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner } 13165a145f0094d7e15ca3c0326b1af2ea0ad19f9726Chris Lattner 13170ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // Okay, we decided not to do this, remove any inserted MBB's and clear 13180ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner // SwitchCases. 13190ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) 13200ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner CurMBB->getParent()->getBasicBlockList().erase(SwitchCases[i].ThisBB); 13210ccb500fa7a28baeb66754ff4a6950fa0e82617dChris Lattner 1322df19f27d039fd791c73e39f4134319debc75db4fChris Lattner SwitchCases.clear(); 1323571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 1324571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner } 13252452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner 13262452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Create a CaseBlock record representing this branch. 13276b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng SelectionDAGISel::CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(), 13285502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov NULL, Succ0MBB, Succ1MBB, CurMBB); 13292452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // Use visitSwitchCase to actually insert the fast branch sequence for this 13302452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner // cond branch. 13312452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner visitSwitchCase(CB); 13321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1334f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 1335f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 1336f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 133757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand Cond; 133857ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SDOperand CondLHS = getValue(CB.CmpLHS); 133957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner 13405502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // Build the setcc now. 13415502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (CB.CmpMHS == NULL) { 13425502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // Fold "(X == true)" to X and "(X == false)" to !X to 13435502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // handle common cases produced by branch lowering. 13445502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (CB.CmpRHS == ConstantInt::getTrue() && CB.CC == ISD::SETEQ) 13455502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Cond = CondLHS; 13465502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov else if (CB.CmpRHS == ConstantInt::getFalse() && CB.CC == ISD::SETEQ) { 13475502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SDOperand True = DAG.getConstant(1, CondLHS.getValueType()); 13485502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Cond = DAG.getNode(ISD::XOR, CondLHS.getValueType(), CondLHS, True); 13495502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } else 13505502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Cond = DAG.getSetCC(MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC); 13515502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } else { 13525502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov assert(CB.CC == ISD::SETLE && "Can handle only LE ranges now"); 13535502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 13545502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t Low = cast<ConstantInt>(CB.CmpLHS)->getSExtValue(); 13555502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t High = cast<ConstantInt>(CB.CmpRHS)->getSExtValue(); 13565502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 13575502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SDOperand CmpOp = getValue(CB.CmpMHS); 13585502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov MVT::ValueType VT = CmpOp.getValueType(); 13593a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 13605502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) { 13615502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Cond = DAG.getSetCC(MVT::i1, CmpOp, DAG.getConstant(High, VT), ISD::SETLE); 13625502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } else { 13635502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SDOperand SUB = DAG.getNode(ISD::SUB, VT, CmpOp, DAG.getConstant(Low, VT)); 13645502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Cond = DAG.getSetCC(MVT::i1, SUB, 13655502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov DAG.getConstant(High-Low, VT), ISD::SETULE); 13665502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 13675502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 13685502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 13695502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 1370f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 1371f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 1372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 1373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 1374f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 1375f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 1376f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1377f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 1378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 137957ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.TrueBB == NextBlock) { 138057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner std::swap(CB.TrueBB, CB.FalseBB); 1381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 1382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 1383f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1384f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 138557ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.TrueBB)); 138657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (CB.FalseBB == NextBlock) 1387f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 1388f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 1389f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 139057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner DAG.getBasicBlock(CB.FalseBB))); 1391f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 139257ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.TrueBB); 139357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner CurMBB->addSuccessor(CB.FalseBB); 1394f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1395f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 13963a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov/// visitJumpTable - Emit JumpTable node in the current MBB 139737efe6764568a3829fee26aba532283131d1a104Nate Begemanvoid SelectionDAGLowering::visitJumpTable(SelectionDAGISel::JumpTable &JT) { 139837efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code for the jump table 1399f147a8d56e0811525916f4d8cd5dd1777f834a85Scott Michel assert(JT.Reg != -1U && "Should lower JT Header first!"); 140037efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType PTy = TLI.getPointerTy(); 14013d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng SDOperand Index = DAG.getCopyFromReg(getRoot(), JT.Reg, PTy); 14023d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng SDOperand Table = DAG.getJumpTable(JT.JTI, PTy); 14033d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng DAG.setRoot(DAG.getNode(ISD::BR_JT, MVT::Other, Index.getValue(1), 14043d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng Table, Index)); 14053d4ce1108520a4dcf31cb01523e145d286ee64c1Evan Cheng return; 140637efe6764568a3829fee26aba532283131d1a104Nate Begeman} 140737efe6764568a3829fee26aba532283131d1a104Nate Begeman 14083a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov/// visitJumpTableHeader - This function emits necessary code to produce index 14093a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov/// in the JumpTable from switch case. 14103a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikovvoid SelectionDAGLowering::visitJumpTableHeader(SelectionDAGISel::JumpTable &JT, 14113a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAGISel::JumpTableHeader &JTH) { 14123a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Subtract the lowest switch case value from the value being switched on 14133a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // and conditional branch to default mbb if the result is greater than the 14143a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // difference between smallest and largest cases. 14153a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand SwitchOp = getValue(JTH.SValue); 14163a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov MVT::ValueType VT = SwitchOp.getValueType(); 14173a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 14183a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getConstant(JTH.First, VT)); 14193a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14203a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // The SDNode we just created, which holds the value being switched on 14213a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // minus the the smallest case value, needs to be copied to a virtual 14223a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // register so it can be used as an index into the jump table in a 14233a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // subsequent basic block. This value may be smaller or larger than the 14243a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // target's pointer type, and therefore require extension or truncating. 14257f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (MVT::getSizeInBits(VT) > MVT::getSizeInBits(TLI.getPointerTy())) 14263a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SwitchOp = DAG.getNode(ISD::TRUNCATE, TLI.getPointerTy(), SUB); 14273a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov else 14283a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SwitchOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), SUB); 14293a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14303a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov unsigned JumpTableReg = FuncInfo.MakeReg(TLI.getPointerTy()); 14313a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand CopyTo = DAG.getCopyToReg(getRoot(), JumpTableReg, SwitchOp); 14323a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JT.Reg = JumpTableReg; 14333a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14343a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Emit the range check for the jump table, and branch to the default 14353a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // block for the switch statement if the value being switched on exceeds 14363a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // the largest case in the switch. 14373a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand CMP = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 14383a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getConstant(JTH.Last-JTH.First,VT), 14393a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov ISD::SETUGT); 14403a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14413a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Set NextBlock to be the MBB immediately after the current one, if any. 14423a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // This is used to avoid emitting unnecessary branches to the next block. 14433a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 14443a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov MachineFunction::iterator BBI = CurMBB; 14453a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 14463a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov NextBlock = BBI; 14473a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14483a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, CMP, 14493a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.getBasicBlock(JT.Default)); 14503a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14513a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (JT.MBB == NextBlock) 14523a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.setRoot(BrCond); 14533a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov else 14543a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 14554198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getBasicBlock(JT.MBB))); 14564198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14574198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return; 14583a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov} 14593a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 14604198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov/// visitBitTestHeader - This function emits necessary code to produce value 14614198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov/// suitable for "bit tests" 14624198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikovvoid SelectionDAGLowering::visitBitTestHeader(SelectionDAGISel::BitTestBlock &B) { 14634198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Subtract the minimum value 14644198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand SwitchOp = getValue(B.SValue); 14654198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MVT::ValueType VT = SwitchOp.getValueType(); 14664198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 14674198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getConstant(B.First, VT)); 14684198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14694198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Check range 14704198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand RangeCmp = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 14714198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getConstant(B.Range, VT), 14724198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov ISD::SETUGT); 14734198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14744198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand ShiftOp; 14757f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (MVT::getSizeInBits(VT) > MVT::getSizeInBits(TLI.getShiftAmountTy())) 14764198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov ShiftOp = DAG.getNode(ISD::TRUNCATE, TLI.getShiftAmountTy(), SUB); 14774198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov else 14784198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov ShiftOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getShiftAmountTy(), SUB); 14794198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14804198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Make desired shift 14814198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand SwitchVal = DAG.getNode(ISD::SHL, TLI.getPointerTy(), 14824198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getConstant(1, TLI.getPointerTy()), 14834198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov ShiftOp); 14844198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14854198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov unsigned SwitchReg = FuncInfo.MakeReg(TLI.getPointerTy()); 14864198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand CopyTo = DAG.getCopyToReg(getRoot(), SwitchReg, SwitchVal); 14874198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov B.Reg = SwitchReg; 14884198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14894198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand BrRange = DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, RangeCmp, 14904198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getBasicBlock(B.Default)); 14914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14924198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Set NextBlock to be the MBB immediately after the current one, if any. 14934198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // This is used to avoid emitting unnecessary branches to the next block. 14944198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 14954198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineFunction::iterator BBI = CurMBB; 14964198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 14974198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov NextBlock = BBI; 14984198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 14994198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock* MBB = B.Cases[0].ThisBB; 15004198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (MBB == NextBlock) 15014198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.setRoot(BrRange); 15024198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov else 15034198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, CopyTo, 15044198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getBasicBlock(MBB))); 15054198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurMBB->addSuccessor(B.Default); 15074198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurMBB->addSuccessor(MBB); 15084198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15094198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return; 15104198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov} 15114198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15124198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov/// visitBitTestCase - this function produces one "bit test" 15134198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikovvoid SelectionDAGLowering::visitBitTestCase(MachineBasicBlock* NextMBB, 15144198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov unsigned Reg, 15154198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SelectionDAGISel::BitTestCase &B) { 15164198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Emit bit tests and jumps 15174198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand SwitchVal = DAG.getCopyFromReg(getRoot(), Reg, TLI.getPointerTy()); 15184198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15194198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand AndOp = DAG.getNode(ISD::AND, TLI.getPointerTy(), 15204198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SwitchVal, 15214198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getConstant(B.Mask, 15224198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov TLI.getPointerTy())); 15234198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand AndCmp = DAG.getSetCC(TLI.getSetCCResultTy(), AndOp, 15244198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getConstant(0, TLI.getPointerTy()), 15254198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov ISD::SETNE); 15264198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SDOperand BrAnd = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 15274198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov AndCmp, DAG.getBasicBlock(B.TargetBB)); 15284198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15294198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Set NextBlock to be the MBB immediately after the current one, if any. 15304198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // This is used to avoid emitting unnecessary branches to the next block. 15314198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 15324198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineFunction::iterator BBI = CurMBB; 15334198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 15344198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov NextBlock = BBI; 15354198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15364198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (NextMBB == NextBlock) 15374198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.setRoot(BrAnd); 15384198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov else 15394198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrAnd, 15404198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DAG.getBasicBlock(NextMBB))); 15414198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15424198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurMBB->addSuccessor(B.TargetBB); 15434198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurMBB->addSuccessor(NextMBB); 15444198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 15454198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return; 15464198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov} 15473a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 1548b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskeyvoid SelectionDAGLowering::visitInvoke(InvokeInst &I) { 1549b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey // Retrieve successors. 1550b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)]; 1551f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands MachineBasicBlock *LandingPad = FuncInfo.MBBMap[I.getSuccessor(1)]; 15529fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands 1553fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands if (isa<InlineAsm>(I.getCalledValue())) 1554fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands visitInlineAsm(&I); 1555fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands else 15566f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands LowerCallTo(&I, getValue(I.getOperand(0)), false, LandingPad); 1557f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands 1558f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands // If the value of the invoke is used outside of its defining block, make it 1559f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands // available as a virtual register. 1560f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands if (!I.use_empty()) { 1561f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands DenseMap<const Value*, unsigned>::iterator VMI = FuncInfo.ValueMap.find(&I); 1562f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands if (VMI != FuncInfo.ValueMap.end()) 1563f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands DAG.setRoot(CopyValueToVirtualRegister(&I, VMI->second)); 1564f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands } 15659fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands 1566f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands // Drop into normal successor. 1567f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 1568f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands DAG.getBasicBlock(Return))); 1569070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov 1570f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands // Update successor info 1571f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands CurMBB->addSuccessor(Return); 1572f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands CurMBB->addSuccessor(LandingPad); 1573b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey} 1574b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 1575b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskeyvoid SelectionDAGLowering::visitUnwind(UnwindInst &I) { 1576b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey} 1577b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 15785502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov/// handleSmallSwitchCaseRange - Emit a series of specific tests (suitable for 1579b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// small case ranges). 1580dd433210797bc13513989a033e488d4e19442723Anton Korobeynikovbool SelectionDAGLowering::handleSmallSwitchRange(CaseRec& CR, 1581b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 1582b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 1583b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default) { 1584dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Case& BackCase = *(CR.Range.second-1); 1585dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1586dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // Size is the number of Cases represented by this range. 1587dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov unsigned Size = CR.Range.second - CR.Range.first; 15884198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (Size > 3) 1589dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return false; 15905502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 1591b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 1592b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 1593b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 1594b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1595b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Figure out which block is immediately after the current one. 1596b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 1597b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 1598b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1599b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 1600b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov NextBlock = BBI; 1601b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1602b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // TODO: If any two of the cases has the same destination, and if one value 1603b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // is the same as the other, but has one bit unset that the other has set, 1604b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // use bit manipulation to do two compares at once. For example: 1605b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // "if (X == 6 || X == 4)" -> "if ((X|2) == 6)" 1606b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1607b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Rearrange the case blocks so that the last one falls through if possible. 16085502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (NextBlock && Default != NextBlock && BackCase.BB != NextBlock) { 1609b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // The last case block won't fall through into 'NextBlock' if we emit the 1610b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // branches in this order. See if rearranging a case value would help. 1611b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second-1; I != E; ++I) { 16125502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (I->BB == NextBlock) { 1613b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov std::swap(*I, BackCase); 1614b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov break; 1615b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1616b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1617b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1618b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1619b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a CaseBlock record representing a conditional branch to 1620b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the Case's target mbb if the value being switched on SV is equal 1621b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // to C. 1622b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *CurBlock = CR.CaseBB; 1623b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++I) { 1624b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *FallThrough; 1625b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (I != E-1) { 1626b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FallThrough = new MachineBasicBlock(CurBlock->getBasicBlock()); 1627b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, FallThrough); 1628b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1629b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // If the last case doesn't match, go to the default block. 1630b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FallThrough = Default; 1631b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 16325502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 16335502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Value *RHS, *LHS, *MHS; 16345502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov ISD::CondCode CC; 16355502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (I->High == I->Low) { 16365502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // This is just small small case range :) containing exactly 1 case 16375502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov CC = ISD::SETEQ; 16385502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov LHS = SV; RHS = I->High; MHS = NULL; 16395502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } else { 16405502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov CC = ISD::SETLE; 16415502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov LHS = I->Low; MHS = SV; RHS = I->High; 16425502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 16435502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SelectionDAGISel::CaseBlock CB(CC, LHS, RHS, MHS, 16445502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov I->BB, FallThrough, CurBlock); 1645b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1646b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // If emitting the first comparison, just call visitSwitchCase to emit the 1647b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // code into the current block. Otherwise, push the CaseBlock onto the 1648b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // vector to be later processed by SDISel, and insert the node's MBB 1649b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // before the next MBB. 1650b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (CurBlock == CurMBB) 1651b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov visitSwitchCase(CB); 1652b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov else 1653b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SwitchCases.push_back(CB); 1654b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1655b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurBlock = FallThrough; 1656b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1657dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1658dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return true; 1659b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov} 1660b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 16617294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikovstatic inline bool areJTsAllowed(const TargetLowering &TLI) { 16627294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov return (TLI.isOperationLegal(ISD::BR_JT, MVT::Other) || 16637294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov TLI.isOperationLegal(ISD::BRIND, MVT::Other)); 16647294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov} 16657294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov 1666b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// handleJTSwitchCase - Emit jumptable for current switch case range 1667dd433210797bc13513989a033e488d4e19442723Anton Korobeynikovbool SelectionDAGLowering::handleJTSwitchCase(CaseRec& CR, 1668b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 1669b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 1670b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default) { 1671dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Case& FrontCase = *CR.Range.first; 1672dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov Case& BackCase = *(CR.Range.second-1); 1673dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 16745502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t First = cast<ConstantInt>(FrontCase.Low)->getSExtValue(); 16755502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t Last = cast<ConstantInt>(BackCase.High)->getSExtValue(); 16765502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 16775502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t TSize = 0; 16785502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; 16795502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov I!=E; ++I) 16805502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov TSize += I->size(); 1681dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 16827294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov if (!areJTsAllowed(TLI) || TSize <= 3) 1683dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return false; 1684dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 16855502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov double Density = (double)TSize / (double)((Last - First) + 1ULL); 16865502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (Density < 0.4) 1687dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return false; 1688dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 16895502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov DOUT << "Lowering jump table\n" 16905502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov << "First entry: " << First << ". Last entry: " << Last << "\n" 16914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "Size: " << TSize << ". Density: " << Density << "\n\n"; 16925502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 1693b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 1694b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 1695dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 1696b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1697b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Figure out which block is immediately after the current one. 1698b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 1699b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 1700b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1701b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 1702b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov NextBlock = BBI; 1703b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1704b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock(); 1705b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1706b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a new basic block to hold the code for loading the address 1707b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // of the jump table, and jumping to it. Update successor information; 1708b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // we will either branch to the default case for the switch, or the jump 1709b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // table. 1710b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *JumpTableBB = new MachineBasicBlock(LLVMBB); 1711b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, JumpTableBB); 1712b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CR.CaseBB->addSuccessor(Default); 1713b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CR.CaseBB->addSuccessor(JumpTableBB); 1714b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1715b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Build a vector of destination BBs, corresponding to each target 17164198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // of the jump table. If the value of the jump table slot corresponds to 1717b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // a case statement, push the case's BB onto the vector, otherwise, push 1718b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the default BB. 1719b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov std::vector<MachineBasicBlock*> DestBBs; 1720b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov int64_t TEI = First; 17215502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++TEI) { 17225502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t Low = cast<ConstantInt>(I->Low)->getSExtValue(); 17235502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t High = cast<ConstantInt>(I->High)->getSExtValue(); 17245502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 17255502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if ((Low <= TEI) && (TEI <= High)) { 17265502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov DestBBs.push_back(I->BB); 17275502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (TEI==High) 17285502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov ++I; 1729b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1730b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov DestBBs.push_back(Default); 1731b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 17325502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 1733b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1734b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Update successor info. Add one edge to each unique successor. 17355502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov BitVector SuccsHandled(CR.CaseBB->getParent()->getNumBlockIDs()); 1736b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(), 1737b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov E = DestBBs.end(); I != E; ++I) { 1738b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (!SuccsHandled[(*I)->getNumber()]) { 1739b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SuccsHandled[(*I)->getNumber()] = true; 1740b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov JumpTableBB->addSuccessor(*I); 1741b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1742b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1743b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1744b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a jump table index for this jump table, or return an existing 1745b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // one. 1746b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov unsigned JTI = CurMF->getJumpTableInfo()->getJumpTableIndex(DestBBs); 1747b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1748b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Set the jump table information so that we can codegen it as a second 1749b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // MachineBasicBlock 1750f147a8d56e0811525916f4d8cd5dd1777f834a85Scott Michel SelectionDAGISel::JumpTable JT(-1U, JTI, JumpTableBB, Default); 1751b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SelectionDAGISel::JumpTableHeader JTH(First, Last, SV, CR.CaseBB, 1752b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov (CR.CaseBB == CurMBB)); 1753b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (CR.CaseBB == CurMBB) 1754b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov visitJumpTableHeader(JT, JTH); 1755b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1756b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov JTCases.push_back(SelectionDAGISel::JumpTableBlock(JTH, JT)); 1757b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1758dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return true; 1759b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov} 1760b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1761b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// handleBTSplitSwitchCase - emit comparison and split binary search tree into 1762b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov/// 2 subtrees. 1763dd433210797bc13513989a033e488d4e19442723Anton Korobeynikovbool SelectionDAGLowering::handleBTSplitSwitchCase(CaseRec& CR, 1764b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector& WorkList, 1765b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Value* SV, 1766b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock* Default) { 1767b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 1768b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 1769b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 1770b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1771b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Figure out which block is immediately after the current one. 1772b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *NextBlock = 0; 1773b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 1774b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1775b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (++BBI != CurMBB->getParent()->end()) 1776b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov NextBlock = BBI; 1777b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1778b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Case& FrontCase = *CR.Range.first; 1779b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Case& BackCase = *(CR.Range.second-1); 1780b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock(); 1781b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1782b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Size is the number of Cases represented by this range. 1783b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov unsigned Size = CR.Range.second - CR.Range.first; 1784b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 17855502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t First = cast<ConstantInt>(FrontCase.Low)->getSExtValue(); 17865502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t Last = cast<ConstantInt>(BackCase.High)->getSExtValue(); 17874198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov double FMetric = 0; 17885502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov CaseItr Pivot = CR.Range.first + Size/2; 1789b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1790b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Select optimal pivot, maximizing sum density of LHS and RHS. This will 1791b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // (heuristically) allow us to emit JumpTable's later. 17925502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t TSize = 0; 17935502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; 17945502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov I!=E; ++I) 17955502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov TSize += I->size(); 17965502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 17975502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t LSize = FrontCase.size(); 17985502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov uint64_t RSize = TSize-LSize; 17994198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Selecting best pivot: \n" 18004198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "First: " << First << ", Last: " << Last <<"\n" 18014198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "LSize: " << LSize << ", RSize: " << RSize << "\n"; 1802b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov for (CaseItr I = CR.Range.first, J=I+1, E = CR.Range.second; 18035502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov J!=E; ++I, ++J) { 18045502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t LEnd = cast<ConstantInt>(I->High)->getSExtValue(); 18055502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t RBegin = cast<ConstantInt>(J->Low)->getSExtValue(); 18064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov assert((RBegin-LEnd>=1) && "Invalid case distance"); 1807b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov double LDensity = (double)LSize / (double)((LEnd - First) + 1ULL); 1808b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov double RDensity = (double)RSize / (double)((Last - RBegin) + 1ULL); 180954e2b142be6ac759e87dde8a643a7beaff0365dfAnton Korobeynikov double Metric = Log2_64(RBegin-LEnd)*(LDensity+RDensity); 18104198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Should always split in some non-trivial place 18114198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT <<"=>Step\n" 18124198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "LEnd: " << LEnd << ", RBegin: " << RBegin << "\n" 18134198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "LDensity: " << LDensity << ", RDensity: " << RDensity << "\n" 18144198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "Metric: " << Metric << "\n"; 18154198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (FMetric < Metric) { 1816b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov Pivot = J; 18174198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov FMetric = Metric; 18184198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Current metric set to: " << FMetric << "\n"; 1819b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 18205502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 18215502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov LSize += J->size(); 18225502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov RSize -= J->size(); 1823b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 18247294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov if (areJTsAllowed(TLI)) { 18257294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov // If our case is dense we *really* should handle it earlier! 18267294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov assert((FMetric > 0) && "Should handle dense range earlier!"); 18277294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov } else { 18287294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov Pivot = CR.Range.first + Size/2; 18297294b58ecdb430d1473d0a9220a234e62a710d54Anton Korobeynikov } 1830b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1831b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRange LHSR(CR.Range.first, Pivot); 1832b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRange RHSR(Pivot, CR.Range.second); 18335502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Constant *C = Pivot->Low; 1834b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov MachineBasicBlock *FalseBB = 0, *TrueBB = 0; 1835b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1836b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // We know that we branch to the LHS if the Value being switched on is 1837b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // less than the Pivot value, C. We use this to optimize our binary 1838b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // tree a bit, by recognizing that if SV is greater than or equal to the 1839b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // LHS's Case Value, and that Case Value is exactly one less than the 1840b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Pivot's Value, then we can branch directly to the LHS's Target, 1841b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // rather than creating a leaf node for it. 1842b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if ((LHSR.second - LHSR.first) == 1 && 18435502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov LHSR.first->High == CR.GE && 18445502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov cast<ConstantInt>(C)->getSExtValue() == 18455502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov (cast<ConstantInt>(CR.GE)->getSExtValue() + 1LL)) { 18465502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov TrueBB = LHSR.first->BB; 1847b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1848b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov TrueBB = new MachineBasicBlock(LLVMBB); 1849b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, TrueBB); 1850b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov WorkList.push_back(CaseRec(TrueBB, C, CR.GE, LHSR)); 1851b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1852b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1853b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Similar to the optimization above, if the Value being switched on is 1854b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // known to be less than the Constant CR.LT, and the current Case Value 1855b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // is CR.LT - 1, then we can branch directly to the target block for 1856b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the current Case Value, rather than emitting a RHS leaf node for it. 1857b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if ((RHSR.second - RHSR.first) == 1 && CR.LT && 18585502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov cast<ConstantInt>(RHSR.first->Low)->getSExtValue() == 18595502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov (cast<ConstantInt>(CR.LT)->getSExtValue() - 1LL)) { 18605502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov FalseBB = RHSR.first->BB; 1861b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } else { 1862b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov FalseBB = new MachineBasicBlock(LLVMBB); 1863b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, FalseBB); 1864b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov WorkList.push_back(CaseRec(FalseBB,CR.LT,C,RHSR)); 1865b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov } 1866b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1867b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Create a CaseBlock record representing a conditional branch to 1868b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // the LHS node if the value being switched on SV is less than C. 1869b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov // Otherwise, branch to LHS. 18705502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SelectionDAGISel::CaseBlock CB(ISD::SETLT, SV, C, NULL, 18715502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov TrueBB, FalseBB, CR.CaseBB); 1872b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 1873b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov if (CR.CaseBB == CurMBB) 1874b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov visitSwitchCase(CB); 1875b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov else 1876b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov SwitchCases.push_back(CB); 1877dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 1878dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov return true; 1879b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov} 1880b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov 18814198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov/// handleBitTestsSwitchCase - if current case range has few destination and 18824198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov/// range span less, than machine word bitwidth, encode case range into series 18834198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov/// of masks and emit bit tests with these masks. 18844198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikovbool SelectionDAGLowering::handleBitTestsSwitchCase(CaseRec& CR, 18854198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CaseRecVector& WorkList, 18864198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Value* SV, 18873ff981749bed4347dfe7196ac066be1d4f51ea1fChris Lattner MachineBasicBlock* Default){ 1888b55757ec5f6f0218342a8910e1bbd9f018adc7d7Dan Gohman unsigned IntPtrBits = MVT::getSizeInBits(TLI.getPointerTy()); 18894198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 18904198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Case& FrontCase = *CR.Range.first; 18914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Case& BackCase = *(CR.Range.second-1); 18924198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 18934198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Get the MachineFunction which holds the current MBB. This is used when 18944198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // inserting any additional MBBs necessary to represent the switch. 18954198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineFunction *CurMF = CurMBB->getParent(); 18964198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 18974198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov unsigned numCmps = 0; 18984198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; 18994198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov I!=E; ++I) { 19004198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Single case counts one, case range - two. 19014198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (I->Low == I->High) 19024198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov numCmps +=1; 19034198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov else 19044198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov numCmps +=2; 19054198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19074198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Count unique destinations 19084198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SmallSet<MachineBasicBlock*, 4> Dests; 19094198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; I!=E; ++I) { 19104198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Dests.insert(I->BB); 19114198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (Dests.size() > 3) 19124198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Don't bother the code below, if there are too much unique destinations 19134198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return false; 19144198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19154198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Total number of unique destinations: " << Dests.size() << "\n" 19164198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "Total number of comparisons: " << numCmps << "\n"; 19174198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19184198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Compute span of values. 19194198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Constant* minValue = FrontCase.Low; 19204198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov Constant* maxValue = BackCase.High; 19214198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov uint64_t range = cast<ConstantInt>(maxValue)->getSExtValue() - 19224198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov cast<ConstantInt>(minValue)->getSExtValue(); 19234198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Compare range: " << range << "\n" 19244198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "Low bound: " << cast<ConstantInt>(minValue)->getSExtValue() << "\n" 19254198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << "High bound: " << cast<ConstantInt>(maxValue)->getSExtValue() << "\n"; 19264198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 1927ab8fd404034439ba23230df512a8a2779e5d48a3Anton Korobeynikov if (range>=IntPtrBits || 19284198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov (!(Dests.size() == 1 && numCmps >= 3) && 19294198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov !(Dests.size() == 2 && numCmps >= 5) && 19304198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov !(Dests.size() >= 3 && numCmps >= 6))) 19314198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return false; 19324198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19334198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Emitting bit tests\n"; 19344198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov int64_t lowBound = 0; 19354198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19364198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Optimize the case where all the case values fit in a 19374198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // word without having to subtract minValue. In this case, 19384198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // we can optimize away the subtraction. 19394198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (cast<ConstantInt>(minValue)->getSExtValue() >= 0 && 1940e01017bba4f44ab65eba11fd065c9cd16b5edb33Anton Korobeynikov cast<ConstantInt>(maxValue)->getSExtValue() < IntPtrBits) { 19414198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov range = cast<ConstantInt>(maxValue)->getSExtValue(); 19424198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } else { 19434198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov lowBound = cast<ConstantInt>(minValue)->getSExtValue(); 19444198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19454198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19464198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CaseBitsVector CasesBits; 19474198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov unsigned i, count = 0; 19484198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19494198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (CaseItr I = CR.Range.first, E = CR.Range.second; I!=E; ++I) { 19504198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock* Dest = I->BB; 19514198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (i = 0; i < count; ++i) 19524198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (Dest == CasesBits[i].BB) 19534198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov break; 19544198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19554198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (i == count) { 19564198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov assert((count < 3) && "Too much destinations to test!"); 19574198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CasesBits.push_back(CaseBits(0, Dest, 0)); 19584198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov count++; 19594198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19604198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19614198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov uint64_t lo = cast<ConstantInt>(I->Low)->getSExtValue() - lowBound; 19624198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov uint64_t hi = cast<ConstantInt>(I->High)->getSExtValue() - lowBound; 19634198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19644198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (uint64_t j = lo; j <= hi; j++) { 1965e01017bba4f44ab65eba11fd065c9cd16b5edb33Anton Korobeynikov CasesBits[i].Mask |= 1ULL << j; 19664198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CasesBits[i].Bits++; 19674198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19684198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19694198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19704198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov std::sort(CasesBits.begin(), CasesBits.end(), CaseBitsCmp()); 19714198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19724198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SelectionDAGISel::BitTestInfo BTC; 19734198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19744198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Figure out which block is immediately after the current one. 19754198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineFunction::iterator BBI = CR.CaseBB; 19764198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov ++BBI; 19774198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19784198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock(); 19794198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19804198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Cases:\n"; 19814198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (unsigned i = 0, e = CasesBits.size(); i!=e; ++i) { 19824198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Mask: " << CasesBits[i].Mask << ", Bits: " << CasesBits[i].Bits 19834198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << ", BB: " << CasesBits[i].BB << "\n"; 19844198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19854198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock *CaseBB = new MachineBasicBlock(LLVMBB); 19864198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurMF->getBasicBlockList().insert(BBI, CaseBB); 19874198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BTC.push_back(SelectionDAGISel::BitTestCase(CasesBits[i].Mask, 19884198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CaseBB, 19894198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CasesBits[i].BB)); 19904198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 19914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19924198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SelectionDAGISel::BitTestBlock BTB(lowBound, range, SV, 1993efc366263659db05ddc5e14532946cb9213bcdd6Jeff Cohen -1U, (CR.CaseBB == CurMBB), 19944198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CR.CaseBB, Default, BTC); 19954198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19964198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (CR.CaseBB == CurMBB) 19974198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov visitBitTestHeader(BTB); 19984198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 19994198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases.push_back(BTB); 20004198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 20014198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov return true; 20024198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov} 20034198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 20044198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 20055502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov// Clusterify - Transform simple list of Cases into list of CaseRange's 20065502bf67cd49221583c15472150905ce13184d36Anton Korobeynikovunsigned SelectionDAGLowering::Clusterify(CaseVector& Cases, 20075502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov const SwitchInst& SI) { 20085502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov unsigned numCmps = 0; 20095502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 20105502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // Start with "simple" cases 20115502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov for (unsigned i = 1; i < SI.getNumSuccessors(); ++i) { 20125502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov MachineBasicBlock *SMBB = FuncInfo.MBBMap[SI.getSuccessor(i)]; 20135502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Cases.push_back(Case(SI.getSuccessorValue(i), 20145502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SI.getSuccessorValue(i), 20155502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov SMBB)); 20165502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 2017b3d9cdb6776355ffba1c43809094f29e4d57a45fChris Lattner std::sort(Cases.begin(), Cases.end(), CaseCmp()); 20185502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 20195502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // Merge case into clusters 20205502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (Cases.size()>=2) 2021a2a488594df335efa17bc253436465c2ae984f91David Greene // Must recompute end() each iteration because it may be 2022a2a488594df335efa17bc253436465c2ae984f91David Greene // invalidated by erase if we hold on to it 202327a6c7380fa4dfc8e1837a8dd67967d063b26544Chris Lattner for (CaseItr I=Cases.begin(), J=++(Cases.begin()); J!=Cases.end(); ) { 20245502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t nextValue = cast<ConstantInt>(J->Low)->getSExtValue(); 20255502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov int64_t currentValue = cast<ConstantInt>(I->High)->getSExtValue(); 20265502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov MachineBasicBlock* nextBB = J->BB; 20275502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov MachineBasicBlock* currentBB = I->BB; 20285502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 20295502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // If the two neighboring cases go to the same destination, merge them 20305502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // into a single case. 20315502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if ((nextValue-currentValue==1) && (currentBB == nextBB)) { 20325502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov I->High = J->High; 20335502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov J = Cases.erase(J); 20345502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } else { 20355502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov I = J++; 20365502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 20375502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 20385502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 20395502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov for (CaseItr I=Cases.begin(), E=Cases.end(); I!=E; ++I, ++numCmps) { 20405502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (I->Low != I->High) 20415502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov // A range counts double, since it requires two compares. 20425502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov ++numCmps; 20435502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov } 20445502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 20455502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov return numCmps; 20465502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov} 20475502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov 20485502bf67cd49221583c15472150905ce13184d36Anton Korobeynikovvoid SelectionDAGLowering::visitSwitch(SwitchInst &SI) { 2049f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 2050f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 2051f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 2052c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 20535502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov MachineBasicBlock *Default = FuncInfo.MBBMap[SI.getDefaultDest()]; 2054d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner 2055f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 2056f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 20575502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov if (SI.getNumOperands() == 2) { 2058f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 2059c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 2060f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 2061d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner if (Default != NextBlock) 2062f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 2063d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner DAG.getBasicBlock(Default))); 2064c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 2065d2c1d2200b4d1012c61c4bcddfbc6fefcf3a05e1Chris Lattner CurMBB->addSuccessor(Default); 2066f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 2067f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 2068f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2069f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 2070f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 2071f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 20725502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov CaseVector Cases; 20735502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov unsigned numCmps = Clusterify(Cases, SI); 20745502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov DOUT << "Clusterify finished. Total clusters: " << Cases.size() 20755502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov << ". Total compares: " << numCmps << "\n"; 2076c70ddad2b7d7abffeaaace913939fb3c5c55a38bBill Wendling 2077f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 2078f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 2079f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 20805502bf67cd49221583c15472150905ce13184d36Anton Korobeynikov Value *SV = SI.getOperand(0); 208137efe6764568a3829fee26aba532283131d1a104Nate Begeman 20823a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Push the initial CaseRec onto the worklist 2083b17b08d1f2cdbc3aba28e31755d7a5c3c55e4c3aAnton Korobeynikov CaseRecVector WorkList; 20843a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov WorkList.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 20853a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 20863a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov while (!WorkList.empty()) { 20873a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Grab a record representing a case range to process off the worklist 20883a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CaseRec CR = WorkList.back(); 20893a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov WorkList.pop_back(); 20903a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 20914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (handleBitTestsSwitchCase(CR, WorkList, SV, Default)) 20924198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov continue; 20934198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 20943a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // If the range has few cases (two or less) emit a series of specific 20953a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // tests. 2096dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if (handleSmallSwitchRange(CR, WorkList, SV, Default)) 2097dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov continue; 2098dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 20994198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // If the switch has more than 5 blocks, and at least 40% dense, and the 21003a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // target supports indirect branches, then emit a jump table rather than 21013a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // lowering the switch to a binary tree of conditional branches. 2102dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov if (handleJTSwitchCase(CR, WorkList, SV, Default)) 2103dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov continue; 2104dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov 2105dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // Emit binary tree. We need to pick a pivot, and push left and right ranges 2106dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov // onto the worklist. Leafs are handled via handleSmallSwitchRange() call. 2107dd433210797bc13513989a033e488d4e19442723Anton Korobeynikov handleBTSplitSwitchCase(CR, WorkList, SV, Default); 2108f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 2109f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 2110f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 21113a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 2112b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 2113b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 211424d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer const Type *Ty = I.getType(); 21159d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (isa<VectorType>(Ty)) { 21167f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (ConstantVector *CV = dyn_cast<ConstantVector>(I.getOperand(0))) { 21177f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman const VectorType *DestTy = cast<VectorType>(I.getType()); 21187f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman const Type *ElTy = DestTy->getElementType(); 2119c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng if (ElTy->isFloatingPoint()) { 2120c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng unsigned VL = DestTy->getNumElements(); 21219e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen std::vector<Constant*> NZ(VL, ConstantFP::getNegativeZero(ElTy)); 2122c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng Constant *CNZ = ConstantVector::get(&NZ[0], NZ.size()); 2123c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng if (CV == CNZ) { 2124c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng SDOperand Op2 = getValue(I.getOperand(1)); 2125c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 2126c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng return; 2127c45453fa1db7a5c520208fb6ffbc9fdb823b0526Evan Cheng } 21287f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 21297f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 21307f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 21317f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (Ty->isFloatingPoint()) { 213201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 21339e3d3abd937c9bb79d56d25ec0e0724c7cbba67cDale Johannesen if (CFP->isExactlyValue(ConstantFP::getNegativeZero(Ty)->getValueAPF())) { 213401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 213501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 213601b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 213701b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 21387f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman } 21397f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman 21407f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman visitBinary(I, Ty->isFPOrFPVector() ? ISD::FSUB : ISD::SUB); 2141b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 2142b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 21437f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohmanvoid SelectionDAGLowering::visitBinary(User &I, unsigned OpCode) { 21441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 21451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 214624d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer 214724d6da5fedcf39891f7d8c5b031c01324b3db545Reid Spencer setValue(&I, DAG.getNode(OpCode, Op1.getValueType(), Op1, Op2)); 21481628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer} 21491628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer 2150e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 2151e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 2152e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 2153e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 21547f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (MVT::getSizeInBits(TLI.getShiftAmountTy()) < 21557f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman MVT::getSizeInBits(Op2.getValueType())) 2156832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer Op2 = DAG.getNode(ISD::TRUNCATE, TLI.getShiftAmountTy(), Op2); 2157832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer else if (TLI.getShiftAmountTy() > Op2.getValueType()) 2158832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 2159e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 21601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 21611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 21621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 216345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencervoid SelectionDAGLowering::visitICmp(User &I) { 2164e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE; 2165e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (ICmpInst *IC = dyn_cast<ICmpInst>(&I)) 2166e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = IC->getPredicate(); 2167e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else if (ConstantExpr *IC = dyn_cast<ConstantExpr>(&I)) 2168e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = ICmpInst::Predicate(IC->getPredicate()); 2169e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 2170e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 217145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer ISD::CondCode Opcode; 2172e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 217345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_EQ : Opcode = ISD::SETEQ; break; 217445fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_NE : Opcode = ISD::SETNE; break; 217545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_UGT : Opcode = ISD::SETUGT; break; 217645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_UGE : Opcode = ISD::SETUGE; break; 217745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_ULT : Opcode = ISD::SETULT; break; 217845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_ULE : Opcode = ISD::SETULE; break; 217945fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SGT : Opcode = ISD::SETGT; break; 218045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SGE : Opcode = ISD::SETGE; break; 218145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SLT : Opcode = ISD::SETLT; break; 218245fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer case ICmpInst::ICMP_SLE : Opcode = ISD::SETLE; break; 218345fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer default: 218445fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer assert(!"Invalid ICmp predicate value"); 218545fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer Opcode = ISD::SETEQ; 218645fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer break; 218745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer } 218845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 218945fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer} 219045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer 219145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencervoid SelectionDAGLowering::visitFCmp(User &I) { 2192e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE; 2193e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FCmpInst *FC = dyn_cast<FCmpInst>(&I)) 2194e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = FC->getPredicate(); 2195e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else if (ConstantExpr *FC = dyn_cast<ConstantExpr>(&I)) 2196e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer predicate = FCmpInst::Predicate(FC->getPredicate()); 2197e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op1 = getValue(I.getOperand(0)); 2198e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SDOperand Op2 = getValue(I.getOperand(1)); 2199e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ISD::CondCode Condition, FOC, FPC; 2200e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 2201e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: FOC = FPC = ISD::SETFALSE; break; 2202e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OEQ: FOC = ISD::SETEQ; FPC = ISD::SETOEQ; break; 2203e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGT: FOC = ISD::SETGT; FPC = ISD::SETOGT; break; 2204e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OGE: FOC = ISD::SETGE; FPC = ISD::SETOGE; break; 2205e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLT: FOC = ISD::SETLT; FPC = ISD::SETOLT; break; 2206e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_OLE: FOC = ISD::SETLE; FPC = ISD::SETOLE; break; 2207e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ONE: FOC = ISD::SETNE; FPC = ISD::SETONE; break; 2208e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ORD: FOC = ISD::SETEQ; FPC = ISD::SETO; break; 2209e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNO: FOC = ISD::SETNE; FPC = ISD::SETUO; break; 2210e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UEQ: FOC = ISD::SETEQ; FPC = ISD::SETUEQ; break; 2211e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGT: FOC = ISD::SETGT; FPC = ISD::SETUGT; break; 2212e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UGE: FOC = ISD::SETGE; FPC = ISD::SETUGE; break; 2213e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULT: FOC = ISD::SETLT; FPC = ISD::SETULT; break; 2214e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_ULE: FOC = ISD::SETLE; FPC = ISD::SETULE; break; 2215e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_UNE: FOC = ISD::SETNE; FPC = ISD::SETUNE; break; 2216e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: FOC = FPC = ISD::SETTRUE; break; 221745fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer default: 221845fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer assert(!"Invalid FCmp predicate value"); 2219e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer FOC = FPC = ISD::SETFALSE; 222045fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer break; 222145fb3f3cb2b8efc01d9bbe42a64194f35b92c759Reid Spencer } 2222e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (FiniteOnlyFPMath()) 2223e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FOC; 2224e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer else 2225e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer Condition = FPC; 2226e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Condition)); 22271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 22281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 22301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 22311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 22321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 22337f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 22347f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman TrueVal, FalseVal)); 22351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 22361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitTrunc(User &I) { 22393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // TruncInst cannot be a no-op cast because sizeof(src) > sizeof(dest). 22403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22413da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22423da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 22433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitZExt(User &I) { 22463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // ZExt cannot be a no-op cast because sizeof(src) < sizeof(dest). 22473da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // ZExt also can't be a cast to bool for same reason. So, nothing much to do 22483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22503da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 22513da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22523da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22533da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitSExt(User &I) { 22543da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // SExt cannot be a no-op cast because sizeof(src) < sizeof(dest). 22553da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // SExt also can't be a cast to bool for same reason. So, nothing much to do 22563da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22573da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22583da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 22593da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22603da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPTrunc(User &I) { 22623da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPTrunc is never a no-op cast, no need to check 22633da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22643da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22650bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N, DAG.getIntPtrConstant(0))); 22663da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22673da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22683da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPExt(User &I){ 22693da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPTrunc is never a no-op cast, no need to check 22703da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22723da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 22733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPToUI(User &I) { 22763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPToUI is never a no-op cast, no need to check 22773da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22783da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22793da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 22803da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22813da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22823da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitFPToSI(User &I) { 22833da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // FPToSI is never a no-op cast, no need to check 22843da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22853da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22863da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 22873da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22883da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22893da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitUIToFP(User &I) { 22903da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // UIToFP is never a no-op cast, no need to check 22913da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22923da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 22933da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 22943da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 22953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 22963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitSIToFP(User &I){ 22973da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // UIToFP is never a no-op cast, no need to check 22983da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 22993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 23003da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 23013da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 23023da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 23033da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitPtrToInt(User &I) { 23043da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // What to do depends on the size of the integer and the size of the pointer. 23053da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // We can either truncate, zero extend, or no-op, accordingly. 23061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 2307e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 230828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 23093da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand Result; 23103da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (MVT::getSizeInBits(DestVT) < MVT::getSizeInBits(SrcVT)) 23113da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Result = DAG.getNode(ISD::TRUNCATE, DestVT, N); 23123da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 23133da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Note: ZERO_EXTEND can handle cases where the sizes are equal too 23143da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Result = DAG.getNode(ISD::ZERO_EXTEND, DestVT, N); 23153da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, Result); 23163da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 23171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23183da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitIntToPtr(User &I) { 23193da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // What to do depends on the size of the integer and the size of the pointer. 23203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // We can either truncate, zero extend, or no-op, accordingly. 23213da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 23223da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType SrcVT = N.getValueType(); 23233da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 23243da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (MVT::getSizeInBits(DestVT) < MVT::getSizeInBits(SrcVT)) 23253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 23263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 23273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Note: ZERO_EXTEND can handle cases where the sizes are equal too 23283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 23293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 23303da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 23313da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencervoid SelectionDAGLowering::visitBitCast(User &I) { 23323da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer SDOperand N = getValue(I.getOperand(0)); 23333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer MVT::ValueType DestVT = TLI.getValueType(I.getType()); 23343da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 23353da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // BitCast assures us that source and destination are the same size so this 23363da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // is either a BIT_CONVERT or a no-op. 23373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (DestVT != N.getValueType()) 23383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, DAG.getNode(ISD::BIT_CONVERT, DestVT, N)); // convert types 23393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer else 23403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer setValue(&I, N); // noop cast. 23411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23432bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 2344c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 2345c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 2346c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 2347c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 2348c7029805ef35ce9805931067b841e6af11db382eChris Lattner 23497f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman setValue(&I, DAG.getNode(ISD::INSERT_VECTOR_ELT, 23507f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman TLI.getValueType(I.getType()), 23517f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman InVec, InVal, InIdx)); 2352c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 2353c7029805ef35ce9805931067b841e6af11db382eChris Lattner 23542bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 2355384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 2356384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 2357384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 23587f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman setValue(&I, DAG.getNode(ISD::EXTRACT_VECTOR_ELT, 2359384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 2360384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 2361c7029805ef35ce9805931067b841e6af11db382eChris Lattner 23623e104b11168da4692b69cc6b236c1da22adff959Chris Lattnervoid SelectionDAGLowering::visitShuffleVector(User &I) { 23633e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V1 = getValue(I.getOperand(0)); 23643e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V2 = getValue(I.getOperand(1)); 23653e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Mask = getValue(I.getOperand(2)); 23663e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 23677f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman setValue(&I, DAG.getNode(ISD::VECTOR_SHUFFLE, 23687f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman TLI.getValueType(I.getType()), 23697f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman V1, V2, Mask)); 23703e104b11168da4692b69cc6b236c1da22adff959Chris Lattner} 23713e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 23723e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 23731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 23741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 23751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 23761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 23781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 23791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 2380c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 2381b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Field = cast<ConstantInt>(Idx)->getZExtValue(); 23821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 23831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 2384b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner uint64_t Offset = TD->getStructLayout(StTy)->getElementOffset(Field); 23851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 23860bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(Offset)); 23871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 23881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 23891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 23901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 23917c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 23927c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 23937c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 2394b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getZExtValue() == 0) continue; 239547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer uint64_t Offs = 2396a7ac2bd4076096bb3a9986dd5a44f20c7f715518Dale Johannesen TD->getABITypeSize(Ty)*cast<ConstantInt>(CI)->getSExtValue(); 23970bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 23980bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(Offs)); 23997c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 24007c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 24017c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 24027c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 2403a7ac2bd4076096bb3a9986dd5a44f20c7f715518Dale Johannesen uint64_t ElementSize = TD->getABITypeSize(Ty); 24047c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 24057c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 24067c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 24077c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 24087c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 240947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 24107c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 24117c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 24127c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 24137c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 24147c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 24157c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 24167c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 24177c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 24186b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 24191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 24207c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 24211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 24227c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 24230bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner SDOperand Scale = DAG.getIntPtrConstant(ElementSize); 24247c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 24257c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 24261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 24271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 24281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 24291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 24301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 24321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 24331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 24341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 24351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 24361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 2438514ab348fddcdffa8367685dc608b2f8d5de986dDuncan Sands uint64_t TySize = TLI.getTargetData()->getABITypeSize(Ty); 243958092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner unsigned Align = 2440d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner std::max((unsigned)TLI.getTargetData()->getPrefTypeAlignment(Ty), 244158092e35a3368e130438cbc793c8f9dce2e4fe0fChris Lattner I.getAlignment()); 24421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 244468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 244568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 244668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 244768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 244868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 24491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 245068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 24510bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(TySize)); 24521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24534515779fa39481649780bdd24fc966e89ec76edfEvan Cheng // Handle alignment. If the requested alignment is less than or equal to 24544515779fa39481649780bdd24fc966e89ec76edfEvan Cheng // the stack alignment, ignore it. If the size is greater than or equal to 24554515779fa39481649780bdd24fc966e89ec76edfEvan Cheng // the stack alignment, we note this in the DYNAMIC_STACKALLOC node. 24561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 24571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 24584515779fa39481649780bdd24fc966e89ec76edfEvan Cheng if (Align <= StackAlign) 24591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 24604515779fa39481649780bdd24fc966e89ec76edfEvan Cheng 24614515779fa39481649780bdd24fc966e89ec76edfEvan Cheng // Round the size of the allocation up to the stack alignment size 24624515779fa39481649780bdd24fc966e89ec76edfEvan Cheng // by add SA-1 to the size. 24634515779fa39481649780bdd24fc966e89ec76edfEvan Cheng AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 24640bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(StackAlign-1)); 24654515779fa39481649780bdd24fc966e89ec76edfEvan Cheng // Mask out the low bits for alignment purposes. 24664515779fa39481649780bdd24fc966e89ec76edfEvan Cheng AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 24670bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner DAG.getIntPtrConstant(~(uint64_t)(StackAlign-1))); 24681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24690bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner SDOperand Ops[] = { getRoot(), AllocSize, DAG.getIntPtrConstant(Align) }; 2470f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTs = DAG.getNodeValueTypes(AllocSize.getValueType(), 2471f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner MVT::Other); 2472f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, 2, Ops, 3); 24730da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner setValue(&I, DSA); 24740da331fe0bff24e6c90c706ef8f1f1c3a8d90c2aChris Lattner DAG.setRoot(DSA.getValue(1)); 24751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 24771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 24781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 24791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 24801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 24811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 24821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 2483edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2484d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 2485d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 2486d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 2487d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 2488d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 2489d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 2490d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 249128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 2492466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng setValue(&I, getLoadFrom(I.getType(), Ptr, I.getOperand(0), 249395c218a83ecf77590b9dc40c636720772d2b5cd7Christopher Lamb Root, I.isVolatile(), I.getAlignment())); 249428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 249528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 249628b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 2497466685d41a9ea4905b9486fea38e83802e46f196Evan Cheng const Value *SV, SDOperand Root, 249895c218a83ecf77590b9dc40c636720772d2b5cd7Christopher Lamb bool isVolatile, 249995c218a83ecf77590b9dc40c636720772d2b5cd7Christopher Lamb unsigned Alignment) { 25007f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman SDOperand L = 25017f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SV, 0, 25027f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman isVolatile, Alignment); 2503d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 250428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 2505d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 2506d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 2507d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 250828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 250928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 25101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 25111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 25141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 25151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 25161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 25170b4f80ee898c1e85242482e4cb363e6bfe0a133bEvan Cheng DAG.setRoot(DAG.getStore(getRoot(), Src, Ptr, I.getOperand(1), 0, 251895c218a83ecf77590b9dc40c636720772d2b5cd7Christopher Lamb I.isVolatile(), I.getAlignment())); 25191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 25201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25210eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 25220eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 25230eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 25240eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 2525a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands bool HasChain = !I.doesNotAccessMemory(); 2526a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands bool OnlyLoad = HasChain && I.onlyReadsMemory(); 2527a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands 25280eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 2529bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> Ops; 2530e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { // If this intrinsic has side-effects, chainify it. 2531e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) { 2532e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner // We don't need to serialize loads against other loads. 2533e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(DAG.getRoot()); 2534e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } else { 2535e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(getRoot()); 2536e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 2537e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 25380eade319cdb72e24c11d068728a98083737c6435Chris Lattner 25390eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 25400eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 25410eade319cdb72e24c11d068728a98083737c6435Chris Lattner 25420eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 25430eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 25440eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 25450eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 25460eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 25470eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 25480eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 25490eade319cdb72e24c11d068728a98083737c6435Chris Lattner 25500eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 25510eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 25520eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 25537f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (MVT::isVector(VT)) { 25549d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *DestTy = cast<VectorType>(I.getType()); 25550eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 25560eade319cdb72e24c11d068728a98083737c6435Chris Lattner 25570eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 25580eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 25590eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 25600eade319cdb72e24c11d068728a98083737c6435Chris Lattner 25610eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 25620eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 25630eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 25640eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 25650eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 25660eade319cdb72e24c11d068728a98083737c6435Chris Lattner 2567f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner const MVT::ValueType *VTList = DAG.getNodeValueTypes(VTs); 2568f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner 25690eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 257048b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 257148b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 2572f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTList, VTs.size(), 2573f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 257448b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 2575f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTList, VTs.size(), 2576f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 257748b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 2578f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTList, VTs.size(), 2579f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Ops[0], Ops.size()); 258048b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 2581e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { 2582e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner SDOperand Chain = Result.getValue(Result.Val->getNumValues()-1); 2583e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) 2584e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner PendingLoads.push_back(Chain); 2585e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner else 2586e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner DAG.setRoot(Chain); 2587e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 25880eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 25899d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (const VectorType *PTy = dyn_cast<VectorType>(I.getType())) { 25907f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman MVT::ValueType VT = TLI.getValueType(PTy); 25917f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Result = DAG.getNode(ISD::BIT_CONVERT, VT, Result); 25920eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 25930eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 25940eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 25950eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 25960eade319cdb72e24c11d068728a98083737c6435Chris Lattner 2597b4fd45e2fc4973214227fbaa96975d9fcc19ba42Duncan Sands/// ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V. 2598cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sandsstatic GlobalVariable *ExtractTypeInfo (Value *V) { 2599b4fd45e2fc4973214227fbaa96975d9fcc19ba42Duncan Sands V = IntrinsicInst::StripPointerCasts(V); 2600b4fd45e2fc4973214227fbaa96975d9fcc19ba42Duncan Sands GlobalVariable *GV = dyn_cast<GlobalVariable>(V); 2601cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands assert (GV || isa<ConstantPointerNull>(V) && 2602cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands "TypeInfo must be a global variable or NULL"); 2603cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands return GV; 2604cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands} 2605cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands 2606f40708223e409a152834b1553c6883ff2035b957Duncan Sands/// addCatchInfo - Extract the personality and type infos from an eh.selector 2607cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands/// call, and add them to the specified machine basic block. 2608f40708223e409a152834b1553c6883ff2035b957Duncan Sandsstatic void addCatchInfo(CallInst &I, MachineModuleInfo *MMI, 2609f40708223e409a152834b1553c6883ff2035b957Duncan Sands MachineBasicBlock *MBB) { 2610f40708223e409a152834b1553c6883ff2035b957Duncan Sands // Inform the MachineModuleInfo of the personality for this landing pad. 2611f40708223e409a152834b1553c6883ff2035b957Duncan Sands ConstantExpr *CE = cast<ConstantExpr>(I.getOperand(2)); 2612f40708223e409a152834b1553c6883ff2035b957Duncan Sands assert(CE->getOpcode() == Instruction::BitCast && 2613f40708223e409a152834b1553c6883ff2035b957Duncan Sands isa<Function>(CE->getOperand(0)) && 2614f40708223e409a152834b1553c6883ff2035b957Duncan Sands "Personality should be a function"); 2615f40708223e409a152834b1553c6883ff2035b957Duncan Sands MMI->addPersonality(MBB, cast<Function>(CE->getOperand(0))); 2616f40708223e409a152834b1553c6883ff2035b957Duncan Sands 2617f40708223e409a152834b1553c6883ff2035b957Duncan Sands // Gather all the type infos for this landing pad and pass them along to 2618f40708223e409a152834b1553c6883ff2035b957Duncan Sands // MachineModuleInfo. 2619f40708223e409a152834b1553c6883ff2035b957Duncan Sands std::vector<GlobalVariable *> TyInfo; 2620cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands unsigned N = I.getNumOperands(); 2621cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands 2622cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands for (unsigned i = N - 1; i > 2; --i) { 2623cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand(i))) { 2624cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands unsigned FilterLength = CI->getZExtValue(); 26256590b0457c5e28a7336ae31de194953d8127217aDuncan Sands unsigned FirstCatch = i + FilterLength + !FilterLength; 2626cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands assert (FirstCatch <= N && "Invalid filter length"); 2627cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands 2628cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands if (FirstCatch < N) { 2629cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands TyInfo.reserve(N - FirstCatch); 2630cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands for (unsigned j = FirstCatch; j < N; ++j) 2631cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands TyInfo.push_back(ExtractTypeInfo(I.getOperand(j))); 2632cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands MMI->addCatchTypeInfo(MBB, TyInfo); 2633cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands TyInfo.clear(); 2634cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands } 2635cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands 26366590b0457c5e28a7336ae31de194953d8127217aDuncan Sands if (!FilterLength) { 26376590b0457c5e28a7336ae31de194953d8127217aDuncan Sands // Cleanup. 26386590b0457c5e28a7336ae31de194953d8127217aDuncan Sands MMI->addCleanup(MBB); 26396590b0457c5e28a7336ae31de194953d8127217aDuncan Sands } else { 26406590b0457c5e28a7336ae31de194953d8127217aDuncan Sands // Filter. 26416590b0457c5e28a7336ae31de194953d8127217aDuncan Sands TyInfo.reserve(FilterLength - 1); 26426590b0457c5e28a7336ae31de194953d8127217aDuncan Sands for (unsigned j = i + 1; j < FirstCatch; ++j) 26436590b0457c5e28a7336ae31de194953d8127217aDuncan Sands TyInfo.push_back(ExtractTypeInfo(I.getOperand(j))); 26446590b0457c5e28a7336ae31de194953d8127217aDuncan Sands MMI->addFilterTypeInfo(MBB, TyInfo); 26456590b0457c5e28a7336ae31de194953d8127217aDuncan Sands TyInfo.clear(); 26466590b0457c5e28a7336ae31de194953d8127217aDuncan Sands } 2647cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands 2648cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands N = i; 2649cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands } 2650f40708223e409a152834b1553c6883ff2035b957Duncan Sands } 2651cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands 2652cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands if (N > 3) { 2653cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands TyInfo.reserve(N - 3); 2654cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands for (unsigned j = 3; j < N; ++j) 2655cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands TyInfo.push_back(ExtractTypeInfo(I.getOperand(j))); 2656f40708223e409a152834b1553c6883ff2035b957Duncan Sands MMI->addCatchTypeInfo(MBB, TyInfo); 2657cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands } 2658f40708223e409a152834b1553c6883ff2035b957Duncan Sands} 2659f40708223e409a152834b1553c6883ff2035b957Duncan Sands 2660c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 2661c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 2662c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 2663c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 2664c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 2665c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 26660eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 26670eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 26680eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 26690eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 2670c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 2671c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 2672c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 2673bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case Intrinsic::returnaddress: 2674bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman setValue(&I, DAG.getNode(ISD::RETURNADDR, TLI.getPointerTy(), 2675bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman getValue(I.getOperand(1)))); 2676bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman return 0; 2677bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman case Intrinsic::frameaddress: 2678bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman setValue(&I, DAG.getNode(ISD::FRAMEADDR, TLI.getPointerTy(), 2679bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman getValue(I.getOperand(1)))); 2680bcc5f36765e8111c13873a0c0dc874c92385d808Nate Begeman return 0; 2681c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 2682d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov return "_setjmp"+!TLI.usesUnderscoreSetJmp(); 2683c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 2684c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 2685d27a258d2d7691db3731135a448b7654d260cc07Anton Korobeynikov return "_longjmp"+!TLI.usesUnderscoreLongJmp(); 2686c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 268703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 268803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 268903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 269003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 269103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 269203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 269303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 269403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 269503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 269603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 269703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 269803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 2699c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 270086cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 270144c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 270243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 270344c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && SPI.getContext() && MMI->Verify(SPI.getContext())) { 2704bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Ops[5]; 270536ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 2706bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[0] = getRoot(); 2707bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[1] = getValue(SPI.getLineValue()); 2708bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[2] = getValue(SPI.getColumnValue()); 2709ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 271044c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey DebugInfoDesc *DD = MMI->getDescFor(SPI.getContext()); 2711ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 271243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 271343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2714bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[3] = DAG.getString(CompileUnit->getFileName()); 2715bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Ops[4] = DAG.getString(CompileUnit->getDirectory()); 2716ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 2717bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops, 5)); 271886cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 271943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2720b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 272136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 272243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 272344c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 272443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 272544c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && RSI.getContext() && MMI->Verify(RSI.getContext())) { 272644c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionStart(RSI.getContext()); 27271ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 2728bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(LabelID, MVT::i32), 2729bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(0, MVT::i32))); 273043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 273143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2732b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 273343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 273443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 273544c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 273643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 273744c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey if (MMI && REI.getContext() && MMI->Verify(REI.getContext())) { 273844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey unsigned LabelID = MMI->RecordRegionEnd(REI.getContext()); 2739bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 2740bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(LabelID, MVT::i32), 2741bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(0, MVT::i32))); 274243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 274343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2744b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 274543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 274643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 274744c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 27481b08bbca5592351a940bcd164bdec724ee954326Evan Cheng if (!MMI) return 0; 274943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 27501b08bbca5592351a940bcd164bdec724ee954326Evan Cheng Value *SP = FSI.getSubprogram(); 27511b08bbca5592351a940bcd164bdec724ee954326Evan Cheng if (SP && MMI->Verify(SP)) { 27521b08bbca5592351a940bcd164bdec724ee954326Evan Cheng // llvm.dbg.func.start implicitly defines a dbg_stoppoint which is 27531b08bbca5592351a940bcd164bdec724ee954326Evan Cheng // what (most?) gdb expects. 27541b08bbca5592351a940bcd164bdec724ee954326Evan Cheng DebugInfoDesc *DD = MMI->getDescFor(SP); 27551b08bbca5592351a940bcd164bdec724ee954326Evan Cheng assert(DD && "Not a debug information descriptor"); 27561b08bbca5592351a940bcd164bdec724ee954326Evan Cheng SubprogramDesc *Subprogram = cast<SubprogramDesc>(DD); 27571b08bbca5592351a940bcd164bdec724ee954326Evan Cheng const CompileUnitDesc *CompileUnit = Subprogram->getFile(); 27581b08bbca5592351a940bcd164bdec724ee954326Evan Cheng unsigned SrcFile = MMI->RecordSource(CompileUnit->getDirectory(), 27591b08bbca5592351a940bcd164bdec724ee954326Evan Cheng CompileUnit->getFileName()); 27601b08bbca5592351a940bcd164bdec724ee954326Evan Cheng // Record the source line but does create a label. It will be emitted 27611b08bbca5592351a940bcd164bdec724ee954326Evan Cheng // at asm emission time. 27621b08bbca5592351a940bcd164bdec724ee954326Evan Cheng MMI->RecordSourceLine(Subprogram->getLine(), 0, SrcFile); 276343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 276443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 2765b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 276643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 276743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 276844c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 276943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 2770a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng Value *Variable = DI.getVariable(); 2771a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng if (MMI && Variable && MMI->Verify(Variable)) 2772a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng DAG.setRoot(DAG.getNode(ISD::DECLARE, MVT::Other, getRoot(), 2773a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng getValue(DI.getAddress()), getValue(Variable))); 277443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 277543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 2776c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 2777b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey case Intrinsic::eh_exception: { 2778e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng if (ExceptionHandling) { 2779902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands if (!CurMBB->isLandingPad()) { 2780902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands // FIXME: Mark exception register as live in. Hack for PR1508. 2781902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands unsigned Reg = TLI.getExceptionAddressRegister(); 2782902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands if (Reg) CurMBB->addLiveIn(Reg); 2783902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands } 2784735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Insert the EXCEPTIONADDR instruction. 2785735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDVTList VTs = DAG.getVTList(TLI.getPointerTy(), MVT::Other); 2786735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Ops[1]; 2787735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Ops[0] = DAG.getRoot(); 2788735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Op = DAG.getNode(ISD::EXCEPTIONADDR, VTs, Ops, 1); 2789735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey setValue(&I, Op); 2790735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(Op.getValue(1)); 27917a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey } else { 279264ce0ca90d358da4984a089404dc2dabe45d05f1Jim Laskey setValue(&I, DAG.getConstant(0, TLI.getPointerTy())); 2793735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey } 2794b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey return 0; 2795b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2796b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 27978806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov case Intrinsic::eh_selector_i32: 27988806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov case Intrinsic::eh_selector_i64: { 2799b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 28008806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov MVT::ValueType VT = (Intrinsic == Intrinsic::eh_selector_i32 ? 28018806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov MVT::i32 : MVT::i64); 28028806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov 2803ea632439d4259254670dc4a27b13d6f9370216a8Duncan Sands if (ExceptionHandling && MMI) { 2804f40708223e409a152834b1553c6883ff2035b957Duncan Sands if (CurMBB->isLandingPad()) 2805f40708223e409a152834b1553c6883ff2035b957Duncan Sands addCatchInfo(I, MMI, CurMBB); 2806e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng else { 2807f40708223e409a152834b1553c6883ff2035b957Duncan Sands#ifndef NDEBUG 2808f40708223e409a152834b1553c6883ff2035b957Duncan Sands FuncInfo.CatchInfoLost.insert(&I); 2809f40708223e409a152834b1553c6883ff2035b957Duncan Sands#endif 2810902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands // FIXME: Mark exception selector register as live in. Hack for PR1508. 2811902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands unsigned Reg = TLI.getExceptionSelectorRegister(); 2812902919541fc2eb0e914390d9696088cfec3733dfDuncan Sands if (Reg) CurMBB->addLiveIn(Reg); 2813e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng } 2814735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2815735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Insert the EHSELECTION instruction. 28168806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov SDVTList VTs = DAG.getVTList(VT, MVT::Other); 2817735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Ops[2]; 2818735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Ops[0] = getValue(I.getOperand(1)); 2819735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Ops[1] = getRoot(); 2820735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey SDOperand Op = DAG.getNode(ISD::EHSELECTION, VTs, Ops, 2); 2821735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey setValue(&I, Op); 2822735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(Op.getValue(1)); 28237a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey } else { 28248806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov setValue(&I, DAG.getConstant(0, VT)); 2825b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2826b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2827b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey return 0; 2828b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 28298806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov 28308806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov case Intrinsic::eh_typeid_for_i32: 28318806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov case Intrinsic::eh_typeid_for_i64: { 2832b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 28338806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov MVT::ValueType VT = (Intrinsic == Intrinsic::eh_typeid_for_i32 ? 28348806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov MVT::i32 : MVT::i64); 2835735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 2836735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey if (MMI) { 2837735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey // Find the type id for the given typeinfo. 2838cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands GlobalVariable *GV = ExtractTypeInfo(I.getOperand(1)); 28393b346368deddbe3cb853b29472de46bc9b58d6b8Duncan Sands 2840735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey unsigned TypeID = MMI->getTypeIDFor(GV); 28418806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov setValue(&I, DAG.getConstant(TypeID, VT)); 28427a1de987a69a059ba67779ee8fca3b391e8aa253Jim Laskey } else { 2843f664e41b201bad27ed3661bf50cd71f54242c114Duncan Sands // Return something different to eh_selector. 28448806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov setValue(&I, DAG.getConstant(1, VT)); 2845b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2846b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 2847b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey return 0; 2848b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey } 2849b180aa17539e14a5430d020bbc7de83c79b7fc4bJim Laskey 28502365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov case Intrinsic::eh_return: { 28512365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 28522365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 28532365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov if (MMI && ExceptionHandling) { 28542365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov MMI->setCallsEHReturn(true); 28552365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov DAG.setRoot(DAG.getNode(ISD::EH_RETURN, 28562365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov MVT::Other, 28572365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov getRoot(), 28582365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov getValue(I.getOperand(1)), 28592365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov getValue(I.getOperand(2)))); 28602365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } else { 28612365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov setValue(&I, DAG.getConstant(0, TLI.getPointerTy())); 28622365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 28632365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 28642365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov return 0; 28652365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 28662365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 28672365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov case Intrinsic::eh_unwind_init: { 28682365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov if (MachineModuleInfo *MMI = DAG.getMachineModuleInfo()) { 28692365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov MMI->setCallsUnwindInit(true); 28702365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 28712365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 28722365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov return 0; 28732365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 28742365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 28752365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov case Intrinsic::eh_dwarf_cfa: { 28762365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov if (ExceptionHandling) { 28772365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov MVT::ValueType VT = getValue(I.getOperand(1)).getValueType(); 28782f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov SDOperand CfaArg; 28792f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov if (MVT::getSizeInBits(VT) > MVT::getSizeInBits(TLI.getPointerTy())) 28802f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov CfaArg = DAG.getNode(ISD::TRUNCATE, 28812f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov TLI.getPointerTy(), getValue(I.getOperand(1))); 28822f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov else 28832f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov CfaArg = DAG.getNode(ISD::SIGN_EXTEND, 28842f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov TLI.getPointerTy(), getValue(I.getOperand(1))); 28852f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov 28862365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov SDOperand Offset = DAG.getNode(ISD::ADD, 28872365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov TLI.getPointerTy(), 28882365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov DAG.getNode(ISD::FRAME_TO_ARGS_OFFSET, 28892f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov TLI.getPointerTy()), 28902f597bd09ec0a55689c9fd6d8999bde4fdf8688eAnton Korobeynikov CfaArg); 28912365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov setValue(&I, DAG.getNode(ISD::ADD, 28922365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov TLI.getPointerTy(), 28932365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov DAG.getNode(ISD::FRAMEADDR, 28942365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov TLI.getPointerTy(), 28952365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov DAG.getConstant(0, 28962365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov TLI.getPointerTy())), 28972365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov Offset)); 28982365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } else { 28992365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov setValue(&I, DAG.getConstant(0, TLI.getPointerTy())); 29002365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 29012365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 29022365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov return 0; 29032365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov } 29042365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov 29059ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen case Intrinsic::sqrt: 2906c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 2907c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 2908c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 2909c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 29109ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen case Intrinsic::powi: 29116ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner setValue(&I, DAG.getNode(ISD::FPOWI, 29126ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)).getValueType(), 29136ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(1)), 29146ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner getValue(I.getOperand(2)))); 29156ddf8ed6fe2d0aa5e15f7b9ad7e5049e2223bbd1Chris Lattner return 0; 2916ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman case Intrinsic::sin: 2917ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman setValue(&I, DAG.getNode(ISD::FSIN, 2918ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(1)).getValueType(), 2919ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(1)))); 2920ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman return 0; 2921ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman case Intrinsic::cos: 2922ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman setValue(&I, DAG.getNode(ISD::FCOS, 2923ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(1)).getValueType(), 2924ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(1)))); 2925ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman return 0; 2926ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman case Intrinsic::pow: 2927ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman setValue(&I, DAG.getNode(ISD::FPOW, 2928ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(1)).getValueType(), 2929ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(1)), 2930ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman getValue(I.getOperand(2)))); 2931ac9385a5557ee2f34a509d39c58a8557a0ff686dDan Gohman return 0; 2932c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 2933c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 2934c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 2935c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2936c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 29378b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 2938bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 2939f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, 2940f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::i64, MVT::Other), 2, 2941f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner &Op, 1); 29428b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 29438b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 294451b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 29458b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 2946c6eb6d72550aa3f7241141e3e28520dfef738c81Chris Lattner case Intrinsic::part_select: { 29473f108cb5558a80a63711114d819358f19773c057Reid Spencer // Currently not implemented: just abort 2948f75b874957aa61e81804e266daf671aa9dcc75b9Reid Spencer assert(0 && "part_select intrinsic not implemented"); 2949f75b874957aa61e81804e266daf671aa9dcc75b9Reid Spencer abort(); 2950f75b874957aa61e81804e266daf671aa9dcc75b9Reid Spencer } 2951f75b874957aa61e81804e266daf671aa9dcc75b9Reid Spencer case Intrinsic::part_set: { 2952f75b874957aa61e81804e266daf671aa9dcc75b9Reid Spencer // Currently not implemented: just abort 2953f75b874957aa61e81804e266daf671aa9dcc75b9Reid Spencer assert(0 && "part_set intrinsic not implemented"); 29543f108cb5558a80a63711114d819358f19773c057Reid Spencer abort(); 2955addd11d98ee3a3013c66d3fd25ee2cfb09b3c7bdReid Spencer } 2956a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer case Intrinsic::bswap: 2957d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 2958d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 2959d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 2960d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 2961a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer case Intrinsic::cttz: { 2962a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer SDOperand Arg = getValue(I.getOperand(1)); 2963a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer MVT::ValueType Ty = Arg.getValueType(); 2964a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer SDOperand result = DAG.getNode(ISD::CTTZ, Ty, Arg); 2965a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer setValue(&I, result); 2966c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2967a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer } 2968a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer case Intrinsic::ctlz: { 2969a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer SDOperand Arg = getValue(I.getOperand(1)); 2970a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer MVT::ValueType Ty = Arg.getValueType(); 2971a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer SDOperand result = DAG.getNode(ISD::CTLZ, Ty, Arg); 2972a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer setValue(&I, result); 2973c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2974a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer } 2975a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer case Intrinsic::ctpop: { 2976a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer SDOperand Arg = getValue(I.getOperand(1)); 2977a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer MVT::ValueType Ty = Arg.getValueType(); 2978a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer SDOperand result = DAG.getNode(ISD::CTPOP, Ty, Arg); 2979a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer setValue(&I, result); 2980c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 2981a4f9c4d29affaae0b4a3315ffff20e9130ecd17fReid Spencer } 2982140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 2983bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SDOperand Op = getRoot(); 2984f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, 2985f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(TLI.getPointerTy(), MVT::Other), 2, &Op, 1); 2986140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 2987140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 2988140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 2989140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 299039a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 299139a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 299239a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 2993140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 299439a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 2995ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 2996ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 2997ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 299824e5aada7d112447c41c12008f7daf1fc15a24bcTanya Lattner 299924e5aada7d112447c41c12008f7daf1fc15a24bcTanya Lattner case Intrinsic::var_annotation: 300024e5aada7d112447c41c12008f7daf1fc15a24bcTanya Lattner // Discard annotate attributes 300124e5aada7d112447c41c12008f7daf1fc15a24bcTanya Lattner return 0; 300236397f50343639ce9a25996f2d790c656791ab92Duncan Sands 300336397f50343639ce9a25996f2d790c656791ab92Duncan Sands case Intrinsic::init_trampoline: { 300436397f50343639ce9a25996f2d790c656791ab92Duncan Sands const Function *F = 300536397f50343639ce9a25996f2d790c656791ab92Duncan Sands cast<Function>(IntrinsicInst::StripPointerCasts(I.getOperand(2))); 300636397f50343639ce9a25996f2d790c656791ab92Duncan Sands 300736397f50343639ce9a25996f2d790c656791ab92Duncan Sands SDOperand Ops[6]; 300836397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[0] = getRoot(); 300936397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[1] = getValue(I.getOperand(1)); 301036397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[2] = getValue(I.getOperand(2)); 301136397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[3] = getValue(I.getOperand(3)); 301236397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[4] = DAG.getSrcValue(I.getOperand(1)); 301336397f50343639ce9a25996f2d790c656791ab92Duncan Sands Ops[5] = DAG.getSrcValue(F); 301436397f50343639ce9a25996f2d790c656791ab92Duncan Sands 3015f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands SDOperand Tmp = DAG.getNode(ISD::TRAMPOLINE, 3016f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands DAG.getNodeValueTypes(TLI.getPointerTy(), 3017f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands MVT::Other), 2, 3018f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands Ops, 6); 3019f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands 3020f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands setValue(&I, Tmp); 3021f7331b3dd72409e644833ecaf62a0f6db03c97eeDuncan Sands DAG.setRoot(Tmp.getValue(1)); 302236397f50343639ce9a25996f2d790c656791ab92Duncan Sands return 0; 302336397f50343639ce9a25996f2d790c656791ab92Duncan Sands } 3024ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 3025ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen case Intrinsic::gcroot: 3026ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen if (GCI) { 3027ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen Value *Alloca = I.getOperand(1); 3028ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen Constant *TypeMap = cast<Constant>(I.getOperand(2)); 3029ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 3030ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen FrameIndexSDNode *FI = cast<FrameIndexSDNode>(getValue(Alloca).Val); 3031ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen GCI->addStackRoot(FI->getIndex(), TypeMap); 3032ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen } 3033ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen return 0; 3034ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 3035ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen case Intrinsic::gcread: 3036ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen case Intrinsic::gcwrite: 3037ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen assert(0 && "Collector failed to lower gcread/gcwrite intrinsics!"); 3038ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen return 0; 3039ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 3040917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov case Intrinsic::flt_rounds: { 30411a0248690aaa9f7baaf1247e5f65a1c0c9e3783cDan Gohman setValue(&I, DAG.getNode(ISD::FLT_ROUNDS_, MVT::i32)); 3042917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov return 0; 3043917c2a6ff2cfcd1263a5dd80c54336754c553aceAnton Korobeynikov } 304466fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov 304566fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov case Intrinsic::trap: { 304666fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov DAG.setRoot(DAG.getNode(ISD::TRAP, MVT::Other, getRoot())); 304766fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov return 0; 304866fac79b899904ddd82e5ee354a6d370d80230f6Anton Korobeynikov } 3049c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 3050c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 3051c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 3052c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 30536f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sandsvoid SelectionDAGLowering::LowerCallTo(CallSite CS, SDOperand Callee, 30541da20a71d1bbabc472f281208be77475550be751Jim Laskey bool IsTailCall, 3055070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov MachineBasicBlock *LandingPad) { 30566f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands const PointerType *PT = cast<PointerType>(CS.getCalledValue()->getType()); 3057735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 3058070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 3059070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov unsigned BeginLabel = 0, EndLabel = 0; 30606f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands 3061735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey TargetLowering::ArgListTy Args; 3062735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey TargetLowering::ArgListEntry Entry; 30636f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Args.reserve(CS.arg_size()); 30646f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands for (CallSite::arg_iterator i = CS.arg_begin(), e = CS.arg_end(); 30656f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands i != e; ++i) { 30666f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands SDOperand ArgNode = getValue(*i); 30676f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.Node = ArgNode; Entry.Ty = (*i)->getType(); 30686f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands 30696f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands unsigned attrInd = i - CS.arg_begin() + 1; 30706f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.isSExt = CS.paramHasAttr(attrInd, ParamAttr::SExt); 30716f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.isZExt = CS.paramHasAttr(attrInd, ParamAttr::ZExt); 30726f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.isInReg = CS.paramHasAttr(attrInd, ParamAttr::InReg); 30736f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.isSRet = CS.paramHasAttr(attrInd, ParamAttr::StructRet); 30746f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.isNest = CS.paramHasAttr(attrInd, ParamAttr::Nest); 30756f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands Entry.isByVal = CS.paramHasAttr(attrInd, ParamAttr::ByVal); 3076735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Args.push_back(Entry); 3077735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey } 3078735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 3079481dc721c37a3da0b3cc88191d01fe5b523625eeDuncan Sands bool MarkTryRange = LandingPad || 3080481dc721c37a3da0b3cc88191d01fe5b523625eeDuncan Sands // C++ requires special handling of 'nounwind' calls. 30816f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands (CS.doesNotThrow()); 3082481dc721c37a3da0b3cc88191d01fe5b523625eeDuncan Sands 3083481dc721c37a3da0b3cc88191d01fe5b523625eeDuncan Sands if (MarkTryRange && ExceptionHandling && MMI) { 3084070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov // Insert a label before the invoke call to mark the try range. This can be 3085070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov // used to detect deletion of the invoke via the MachineModuleInfo. 3086070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov BeginLabel = MMI->NextLabelID(); 3087070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 3088bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(BeginLabel, MVT::i32), 3089bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(1, MVT::i32))); 3090070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov } 30916f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands 3092735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey std::pair<SDOperand,SDOperand> Result = 30936f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands TLI.LowerCallTo(getRoot(), CS.getType(), 30946f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands CS.paramHasAttr(0, ParamAttr::SExt), 30956f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands FTy->isVarArg(), CS.getCallingConv(), IsTailCall, 3096735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey Callee, Args, DAG); 30976f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands if (CS.getType() != Type::VoidTy) 30986f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands setValue(CS.getInstruction(), Result.first); 3099735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey DAG.setRoot(Result.second); 3100070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov 3101481dc721c37a3da0b3cc88191d01fe5b523625eeDuncan Sands if (MarkTryRange && ExceptionHandling && MMI) { 3102070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov // Insert a label at the end of the invoke call to mark the try range. This 3103070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov // can be used to detect deletion of the invoke via the MachineModuleInfo. 3104070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov EndLabel = MMI->NextLabelID(); 3105070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, getRoot(), 3106bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(EndLabel, MVT::i32), 3107bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(1, MVT::i32))); 3108070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov 31096f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands // Inform MachineModuleInfo of range. 3110070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov MMI->addInvoke(LandingPad, BeginLabel, EndLabel); 3111070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov } 3112735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey} 3113735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 3114735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 31151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 311664e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 3117c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 311887b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (F->isDeclaration()) { 3119c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 3120c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 3121c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 3122c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 312387b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } 312487b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } 312587b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner 312687b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner // Check for well-known libc/libm calls. If the function is internal, it 312787b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner // can't be a library call. 312887b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner unsigned NameLen = F->getNameLen(); 312987b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (!F->hasInternalLinkage() && NameLen) { 313087b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner const char *NameStr = F->getNameStart(); 313187b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (NameStr[0] == 'c' && 313287b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner ((NameLen == 8 && !strcmp(NameStr, "copysign")) || 313387b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner (NameLen == 9 && !strcmp(NameStr, "copysignf")))) { 313487b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 313587b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 313687b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getType() == I.getOperand(1)->getType() && 313787b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getType() == I.getOperand(2)->getType()) { 313887b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner SDOperand LHS = getValue(I.getOperand(1)); 313987b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner SDOperand RHS = getValue(I.getOperand(2)); 314087b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 314187b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner LHS, RHS)); 314287b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner return; 314387b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } 314487b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } else if (NameStr[0] == 'f' && 314587b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner ((NameLen == 4 && !strcmp(NameStr, "fabs")) || 31462f42901dff5d0b4a9bb571a2f57157c296584557Dale Johannesen (NameLen == 5 && !strcmp(NameStr, "fabsf")) || 31472f42901dff5d0b4a9bb571a2f57157c296584557Dale Johannesen (NameLen == 5 && !strcmp(NameStr, "fabsl")))) { 314887b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 314987b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 315087b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getType() == I.getOperand(1)->getType()) { 315187b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 315287b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 315387b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner return; 315487b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } 315587b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } else if (NameStr[0] == 's' && 315687b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner ((NameLen == 3 && !strcmp(NameStr, "sin")) || 31572f42901dff5d0b4a9bb571a2f57157c296584557Dale Johannesen (NameLen == 4 && !strcmp(NameStr, "sinf")) || 31582f42901dff5d0b4a9bb571a2f57157c296584557Dale Johannesen (NameLen == 4 && !strcmp(NameStr, "sinl")))) { 315987b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 316087b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 316187b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getType() == I.getOperand(1)->getType()) { 316287b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 316387b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 316487b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner return; 316587b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } 316687b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } else if (NameStr[0] == 'c' && 316787b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner ((NameLen == 3 && !strcmp(NameStr, "cos")) || 31682f42901dff5d0b4a9bb571a2f57157c296584557Dale Johannesen (NameLen == 4 && !strcmp(NameStr, "cosf")) || 31692f42901dff5d0b4a9bb571a2f57157c296584557Dale Johannesen (NameLen == 4 && !strcmp(NameStr, "cosl")))) { 317087b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 317187b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 317287b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner I.getType() == I.getOperand(1)->getType()) { 317387b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 317487b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 317587b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner return; 3176f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 3177c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 317887b51bc2b0e9bced27d6fd95573a3f21691a261cChris Lattner } 3179ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 3180fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands visitInlineAsm(&I); 3181ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 3182c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 3183edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 318464e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 318564e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 318664e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 318764e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 318864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 3189070280e97f801ae809ddcc7930c153929f253997Anton Korobeynikov 31906f74b48862948ebb83c7bf7036a76c9e84543fb4Duncan Sands LowerCallTo(&I, Callee, I.isTailCall()); 31911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3193735b6f8cc3abe3d6939d44a39d2e512c32716538Jim Laskey 3194b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from 3195b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// this value and returns the result as a ValueVT value. This uses 3196b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// Chain/Flag as the input and updates them for the output Chain/Flag. 3197b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// If the Flag pointer is NULL, no flag is used. 3198b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan GohmanSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 3199b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand &Chain, SDOperand *Flag)const{ 3200b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Copy the legal parts from the registers. 3201b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned NumParts = Regs.size(); 3202b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SmallVector<SDOperand, 8> Parts(NumParts); 320327a70be55f8b63181598d144d034b396402be66eDan Gohman for (unsigned i = 0; i != NumParts; ++i) { 3204b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand Part = Flag ? 3205b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman DAG.getCopyFromReg(Chain, Regs[i], RegVT, *Flag) : 3206b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman DAG.getCopyFromReg(Chain, Regs[i], RegVT); 3207b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman Chain = Part.getValue(1); 3208b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman if (Flag) 3209b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman *Flag = Part.getValue(2); 3210b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman Parts[i] = Part; 3211b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 3212b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 3213b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Assemble the legal parts into the final value. 3214532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman return getCopyFromParts(DAG, &Parts[0], NumParts, RegVT, ValueVT); 3215b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman} 3216b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 3217b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 3218b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// specified value into the registers specified by this object. This uses 3219b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// Chain/Flag as the input and updates them for the output Chain/Flag. 3220b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman/// If the Flag pointer is NULL, no flag is used. 3221b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohmanvoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 3222b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand &Chain, SDOperand *Flag) const { 3223b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Get the list of the values's legal parts. 3224b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned NumParts = Regs.size(); 3225b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SmallVector<SDOperand, 8> Parts(NumParts); 3226532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman getCopyToParts(DAG, Val, &Parts[0], NumParts, RegVT); 3227b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 3228b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Copy the parts into the registers. 322927a70be55f8b63181598d144d034b396402be66eDan Gohman for (unsigned i = 0; i != NumParts; ++i) { 3230b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand Part = Flag ? 3231532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman DAG.getCopyToReg(Chain, Regs[i], Parts[i], *Flag) : 3232532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman DAG.getCopyToReg(Chain, Regs[i], Parts[i]); 3233b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman Chain = Part.getValue(0); 3234b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman if (Flag) 3235b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman *Flag = Part.getValue(1); 3236c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 3237c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 3238864635ad7b3046d3042311423071152c613961deChris Lattner 3239c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 3240c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 3241c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 3242c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 32439f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 32444b993b19f9837fdf2db55a3e042e8adab3d63c26Chris Lattner MVT::ValueType IntPtrTy = DAG.getTargetLoweringInfo().getPointerTy(); 32454b993b19f9837fdf2db55a3e042e8adab3d63c26Chris Lattner Ops.push_back(DAG.getTargetConstant(Code | (Regs.size() << 3), IntPtrTy)); 3246c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 3247c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 3248c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 3249864635ad7b3046d3042311423071152c613961deChris Lattner 3250864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 3251864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 3252864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 3253864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 32549b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 32556f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetLowering &TLI, 32566f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *TRI) { 3257f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType FoundVT = MVT::Other; 3258f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner const TargetRegisterClass *FoundRC = 0; 32596f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman for (TargetRegisterInfo::regclass_iterator RCI = TRI->regclass_begin(), 32606f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman E = TRI->regclass_end(); RCI != E; ++RCI) { 3261f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType ThisVT = MVT::Other; 3262f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner 32639b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 32649b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 32659b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 32669b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 32679b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 32689b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 3269f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // If we have already found this register in a different register class, 3270f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // choose the one with the largest VT specified. For example, on 3271f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // PowerPC, we favor f64 register classes over f32. 3272f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (FoundVT == MVT::Other || 3273f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::getSizeInBits(FoundVT) < MVT::getSizeInBits(*I)) { 3274f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner ThisVT = *I; 3275f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 3276f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 32779b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 32789b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 32799b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 3280f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (ThisVT == MVT::Other) continue; 32819b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 3282864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 3283864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 3284864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 3285864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 32869b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 32879b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 3288f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (*I == Reg) { 3289f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // We found a matching register class. Keep looking at others in case 3290f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // we find one with larger registers that this physreg is also in. 3291f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundRC = RC; 3292f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundVT = ThisVT; 3293f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 3294f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 3295864635ad7b3046d3042311423071152c613961deChris Lattner } 3296f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner return FoundRC; 3297864635ad7b3046d3042311423071152c613961deChris Lattner} 3298864635ad7b3046d3042311423071152c613961deChris Lattner 3299bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3300bf996f1d5e441c7504ff155d818190f593d54672Chris Lattnernamespace { 3301bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner/// AsmOperandInfo - This contains information for each constraint that we are 3302bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner/// lowering. 3303bf996f1d5e441c7504ff155d818190f593d54672Chris Lattnerstruct AsmOperandInfo : public InlineAsm::ConstraintInfo { 3304bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// ConstraintCode - This contains the actual string for the code, like "m". 3305bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner std::string ConstraintCode; 3306bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3307bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// ConstraintType - Information about the constraint code, e.g. Register, 3308bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// RegisterClass, Memory, Other, Unknown. 3309bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner TargetLowering::ConstraintType ConstraintType; 3310bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3311bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// CallOperand/CallOperandval - If this is the result output operand or a 3312bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// clobber, this is null, otherwise it is the incoming operand to the 3313bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// CallInst. This gets modified as the asm is processed. 3314bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner SDOperand CallOperand; 3315bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner Value *CallOperandVal; 3316bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3317bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner /// ConstraintVT - The ValueType for the operand value. 3318bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner MVT::ValueType ConstraintVT; 3319bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3320e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner /// AssignedRegs - If this is a register or register class operand, this 3321e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner /// contains the set of register corresponding to the operand. 3322e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner RegsForValue AssignedRegs; 3323e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3324bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner AsmOperandInfo(const InlineAsm::ConstraintInfo &info) 3325bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner : InlineAsm::ConstraintInfo(info), 3326bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner ConstraintType(TargetLowering::C_Unknown), 3327bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner CallOperand(0,0), CallOperandVal(0), ConstraintVT(MVT::Other) { 3328bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner } 3329bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3330bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner void ComputeConstraintToUse(const TargetLowering &TLI); 3331e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3332e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner /// MarkAllocatedRegs - Once AssignedRegs is set, mark the assigned registers 3333e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner /// busy in OutputRegs/InputRegs. 3334e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner void MarkAllocatedRegs(bool isOutReg, bool isInReg, 3335e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner std::set<unsigned> &OutputRegs, 3336e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner std::set<unsigned> &InputRegs) const { 3337e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (isOutReg) 3338e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OutputRegs.insert(AssignedRegs.Regs.begin(), AssignedRegs.Regs.end()); 3339e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (isInReg) 3340e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner InputRegs.insert(AssignedRegs.Regs.begin(), AssignedRegs.Regs.end()); 3341e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner } 3342bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner}; 3343bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner} // end anon namespace. 3344bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3345bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner/// getConstraintGenerality - Return an integer indicating how general CT is. 3346bf996f1d5e441c7504ff155d818190f593d54672Chris Lattnerstatic unsigned getConstraintGenerality(TargetLowering::ConstraintType CT) { 3347bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner switch (CT) { 3348bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner default: assert(0 && "Unknown constraint type!"); 3349bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner case TargetLowering::C_Other: 3350bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner case TargetLowering::C_Unknown: 3351bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner return 0; 3352bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner case TargetLowering::C_Register: 3353bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner return 1; 3354bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner case TargetLowering::C_RegisterClass: 3355bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner return 2; 3356bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner case TargetLowering::C_Memory: 3357bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner return 3; 3358bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner } 3359bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner} 3360bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3361bf996f1d5e441c7504ff155d818190f593d54672Chris Lattnervoid AsmOperandInfo::ComputeConstraintToUse(const TargetLowering &TLI) { 3362bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner assert(!Codes.empty() && "Must have at least one constraint"); 3363bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3364bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner std::string *Current = &Codes[0]; 3365bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner TargetLowering::ConstraintType CurType = TLI.getConstraintType(*Current); 3366bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner if (Codes.size() == 1) { // Single-letter constraints ('r') are very common. 3367bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner ConstraintCode = *Current; 3368bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner ConstraintType = CurType; 3369ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen } else { 3370ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen unsigned CurGenerality = getConstraintGenerality(CurType); 3371ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen 3372ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // If we have multiple constraints, try to pick the most general one ahead 3373ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // of time. This isn't a wonderful solution, but handles common cases. 3374ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen for (unsigned j = 1, e = Codes.size(); j != e; ++j) { 3375ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen TargetLowering::ConstraintType ThisType = TLI.getConstraintType(Codes[j]); 3376ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen unsigned ThisGenerality = getConstraintGenerality(ThisType); 3377ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen if (ThisGenerality > CurGenerality) { 3378ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // This constraint letter is more general than the previous one, 3379ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // use it. 3380ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen CurType = ThisType; 3381ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen Current = &Codes[j]; 3382ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen CurGenerality = ThisGenerality; 3383ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen } 3384ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen } 3385ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen 3386ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen ConstraintCode = *Current; 3387ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen ConstraintType = CurType; 3388bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner } 3389ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen 3390ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen if (ConstraintCode == "X") { 3391ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen if (isa<BasicBlock>(CallOperandVal) || isa<ConstantInt>(CallOperandVal)) 3392ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen return; 3393ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // This matches anything. Labels and constants we handle elsewhere 3394ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // ('X' is the only thing that matches labels). Otherwise, try to 3395ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // resolve it to something we know about by looking at the actual 3396ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // operand type. 3397ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen std::string s = ""; 3398ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen TLI.lowerXConstraint(ConstraintVT, s); 3399ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen if (s!="") { 3400ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen ConstraintCode = s; 3401ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen ConstraintType = TLI.getConstraintType(ConstraintCode); 3402bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner } 3403bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner } 3404bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner} 3405bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3406bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 3407e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattnervoid SelectionDAGLowering:: 3408e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris LattnerGetRegistersForValue(AsmOperandInfo &OpInfo, bool HasEarlyClobber, 3409864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 34104e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 3411e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // Compute whether this value requires an input register, an output register, 3412e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // or both. 3413e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner bool isOutReg = false; 3414e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner bool isInReg = false; 3415e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner switch (OpInfo.Type) { 3416e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner case InlineAsm::isOutput: 3417e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner isOutReg = true; 3418e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3419e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // If this is an early-clobber output, or if there is an input 3420e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // constraint that matches this, we need to reserve the input register 3421e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // so no other inputs allocate to it. 3422e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner isInReg = OpInfo.isEarlyClobber || OpInfo.hasMatchingInput; 3423e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner break; 3424e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner case InlineAsm::isInput: 3425e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner isInReg = true; 3426e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner isOutReg = false; 3427e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner break; 3428e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner case InlineAsm::isClobber: 3429e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner isOutReg = true; 3430e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner isInReg = true; 3431e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner break; 3432e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner } 3433e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3434e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3435e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 3436864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 3437e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3438e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // If this is a constraint for a single physreg, or a constraint for a 3439e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // register class, find it. 3440e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 3441e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner TLI.getRegForInlineAsmConstraint(OpInfo.ConstraintCode, 3442e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.ConstraintVT); 3443864635ad7b3046d3042311423071152c613961deChris Lattner 3444bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner unsigned NumRegs = 1; 3445bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner if (OpInfo.ConstraintVT != MVT::Other) 3446b9f10196961ebe5b5573a5705048a5a8a6b56bb3Dan Gohman NumRegs = TLI.getNumRegisters(OpInfo.ConstraintVT); 3447864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 3448bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner MVT::ValueType ValueVT = OpInfo.ConstraintVT; 3449864635ad7b3046d3042311423071152c613961deChris Lattner 3450bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner 34512a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // If this is a constraint for a specific physical register, like {r17}, 34522a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // assign it now. 3453864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 3454bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner if (OpInfo.ConstraintVT == MVT::Other) 3455864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 3456cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner 3457cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // Get the actual register value type. This is important, because the user 3458cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // may have asked for (e.g.) the AX register in i32 type. We need to 3459cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner // remember that AX is actually i16 to get the right extension. 3460cf752aa502a2ce6eaca9db4640171143c49e1733Chris Lattner RegVT = *PhysReg.second->vt_begin(); 3461864635ad7b3046d3042311423071152c613961deChris Lattner 3462864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 3463864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 3464864635ad7b3046d3042311423071152c613961deChris Lattner 3465864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 3466864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 3467864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 3468864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 3469864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 3470864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 3471864635ad7b3046d3042311423071152c613961deChris Lattner 3472864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 3473864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 3474864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 3475864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 3476864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 3477864635ad7b3046d3042311423071152c613961deChris Lattner } 3478864635ad7b3046d3042311423071152c613961deChris Lattner } 3479e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.AssignedRegs = RegsForValue(Regs, RegVT, ValueVT); 3480e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.MarkAllocatedRegs(isOutReg, isInReg, OutputRegs, InputRegs); 3481e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner return; 3482864635ad7b3046d3042311423071152c613961deChris Lattner } 3483864635ad7b3046d3042311423071152c613961deChris Lattner 34842a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Otherwise, if this was a reference to an LLVM register class, create vregs 34852a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // for this reference. 34862a821601f1db665fbb825727aacf1a54d17b91efChris Lattner std::vector<unsigned> RegClassRegs; 3487c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner const TargetRegisterClass *RC = PhysReg.second; 3488c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner if (RC) { 34892a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // If this is an early clobber or tied register, our regalloc doesn't know 34902a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // how to maintain the constraint. If it isn't, go ahead and create vreg 34912a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // and let the regalloc do the right thing. 3492e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (!OpInfo.hasMatchingInput && !OpInfo.isEarlyClobber && 3493e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // If there is some other early clobber and this is an input register, 3494e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // then we are forced to pre-allocate the input reg so it doesn't 3495e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // conflict with the earlyclobber. 3496e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner !(OpInfo.Type == InlineAsm::isInput && HasEarlyClobber)) { 34972a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegVT = *PhysReg.second->vt_begin(); 34983a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner 3499bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner if (OpInfo.ConstraintVT == MVT::Other) 35003a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner ValueVT = RegVT; 35012a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 35022a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Create the appropriate number of virtual registers. 350384bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner MachineRegisterInfo &RegInfo = MF.getRegInfo(); 35042a821601f1db665fbb825727aacf1a54d17b91efChris Lattner for (; NumRegs; --NumRegs) 350584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner Regs.push_back(RegInfo.createVirtualRegister(PhysReg.second)); 35062a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 3507e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.AssignedRegs = RegsForValue(Regs, RegVT, ValueVT); 3508e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.MarkAllocatedRegs(isOutReg, isInReg, OutputRegs, InputRegs); 3509e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner return; 35102a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } 35112a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 35122a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // Otherwise, we can't allocate it. Let the code below figure out how to 35132a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // maintain these constraints. 35142a821601f1db665fbb825727aacf1a54d17b91efChris Lattner RegClassRegs.assign(PhysReg.second->begin(), PhysReg.second->end()); 35152a821601f1db665fbb825727aacf1a54d17b91efChris Lattner 35162a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } else { 35172a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // This is a reference to a register class that doesn't directly correspond 35182a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // to an LLVM register class. Allocate NumRegs consecutive, available, 35192a821601f1db665fbb825727aacf1a54d17b91efChris Lattner // registers from the class. 3520bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner RegClassRegs = TLI.getRegClassForInlineAsmConstraint(OpInfo.ConstraintCode, 3521bf996f1d5e441c7504ff155d818190f593d54672Chris Lattner OpInfo.ConstraintVT); 35222a821601f1db665fbb825727aacf1a54d17b91efChris Lattner } 3523e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 35246f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *TRI = DAG.getTarget().getRegisterInfo(); 3525864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 3526864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 3527864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 35284e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 3529864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 3530864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 3531864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 3532864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 3533864635ad7b3046d3042311423071152c613961deChris Lattner continue; 3534864635ad7b3046d3042311423071152c613961deChris Lattner } 3535864635ad7b3046d3042311423071152c613961deChris Lattner 35364e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 35374e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 3538c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner if (RC == 0) { 35396f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman RC = isAllocatableRegister(Reg, MF, TLI, TRI); 3540c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner if (!RC) { // Couldn't allocate this register. 3541c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner // Reset NumAllocated to make sure we return consecutive registers. 3542c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner NumAllocated = 0; 3543c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner continue; 3544c2c28fc24cc0c7886da93939b0279d3f444b35dcChris Lattner } 35454e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 35464e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 3547864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 3548864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 3549864635ad7b3046d3042311423071152c613961deChris Lattner 3550e303ac9052b9d03eff236469eb560e5b5da7fae2Chris Lattner // If we allocated enough consecutive registers, succeed. 3551864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 3552864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 3553864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 3554864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 3555e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) 3556e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner Regs.push_back(RegClassRegs[i]); 3557864635ad7b3046d3042311423071152c613961deChris Lattner 3558e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.AssignedRegs = RegsForValue(Regs, *RC->vt_begin(), 3559e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.ConstraintVT); 3560e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.MarkAllocatedRegs(isOutReg, isInReg, OutputRegs, InputRegs); 3561e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner return; 3562864635ad7b3046d3042311423071152c613961deChris Lattner } 35634e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 3564864635ad7b3046d3042311423071152c613961deChris Lattner 3565864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 3566e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner return; 35674e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 35684e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 35693ff90dc1c8aaa5d9be94cdca8c4a7e71f45da8fdChris Lattner 3570ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 3571ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 3572fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sandsvoid SelectionDAGLowering::visitInlineAsm(CallSite CS) { 3573fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands InlineAsm *IA = cast<InlineAsm>(CS.getCalledValue()); 3574ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 35750c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner /// ConstraintOperands - Information about all of the constraints. 35760c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner std::vector<AsmOperandInfo> ConstraintOperands; 3577ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3578ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 3579ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 3580ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 35814e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 35820c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 35830c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // Do a prepass over the constraints, canonicalizing them, and building up the 35840c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // ConstraintOperands list. 35850c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner std::vector<InlineAsm::ConstraintInfo> 35860c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner ConstraintInfos = IA->ParseConstraints(); 3587e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3588e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // SawEarlyClobber - Keep track of whether we saw an earlyclobber output 3589e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // constraint. If so, we can't let the register allocator allocate any input 3590e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // registers, because it will not know to avoid the earlyclobbered output reg. 3591e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner bool SawEarlyClobber = false; 3592e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3593fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands unsigned ArgNo = 0; // ArgNo - The argument of the CallInst. 35940c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner for (unsigned i = 0, e = ConstraintInfos.size(); i != e; ++i) { 35950c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner ConstraintOperands.push_back(AsmOperandInfo(ConstraintInfos[i])); 35960c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner AsmOperandInfo &OpInfo = ConstraintOperands.back(); 35970c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 35980c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner MVT::ValueType OpVT = MVT::Other; 35991efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 36000c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // Compute the value type for each operand. 36010c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner switch (OpInfo.Type) { 36021efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 36030c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner if (!OpInfo.isIndirect) { 36040c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // The return value of the call is this value. As such, there is no 36050c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // corresponding argument. 3606fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands assert(CS.getType() != Type::VoidTy && "Bad inline asm!"); 3607fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands OpVT = TLI.getValueType(CS.getType()); 36081efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 3609fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands OpInfo.CallOperandVal = CS.getArgument(ArgNo++); 36101efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 36111efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 36121efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 3613fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands OpInfo.CallOperandVal = CS.getArgument(ArgNo++); 36141efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 36151efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 36160c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // Nothing to do. 36171efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 36181efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 36190c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 36200c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // If this is an input or an indirect output, process the call argument. 3621eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen // BasicBlocks are labels, currently appearing only in asm's. 36220c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner if (OpInfo.CallOperandVal) { 3623eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen if (isa<BasicBlock>(OpInfo.CallOperandVal)) 3624eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen OpInfo.CallOperand = 3625ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen DAG.getBasicBlock(FuncInfo.MBBMap[cast<BasicBlock>( 3626ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen OpInfo.CallOperandVal)]); 3627eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen else { 3628eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen OpInfo.CallOperand = getValue(OpInfo.CallOperandVal); 3629eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen const Type *OpTy = OpInfo.CallOperandVal->getType(); 3630eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen // If this is an indirect operand, the operand is a pointer to the 3631eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen // accessed type. 3632eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen if (OpInfo.isIndirect) 3633eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen OpTy = cast<PointerType>(OpTy)->getElementType(); 3634eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen 3635eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen // If OpTy is not a first-class value, it may be a struct/union that we 3636eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen // can tile with integers. 3637eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen if (!OpTy->isFirstClassType() && OpTy->isSized()) { 3638eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen unsigned BitSize = TD->getTypeSizeInBits(OpTy); 3639eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen switch (BitSize) { 3640eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen default: break; 3641eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 1: 3642eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 8: 3643eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 16: 3644eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 32: 3645eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen case 64: 3646eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen OpTy = IntegerType::get(BitSize); 3647eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen break; 3648eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } 36496995cf6015580eeab07a1c671fca180084a1325eChris Lattner } 3650eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen 3651eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen OpVT = TLI.getValueType(OpTy, true); 36520c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner } 36530c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner } 36541efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 36550c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner OpInfo.ConstraintVT = OpVT; 36562a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner 36573ff90dc1c8aaa5d9be94cdca8c4a7e71f45da8fdChris Lattner // Compute the constraint code and ConstraintType to use. 36583ff90dc1c8aaa5d9be94cdca8c4a7e71f45da8fdChris Lattner OpInfo.ComputeConstraintToUse(TLI); 36591efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 3660e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // Keep track of whether we see an earlyclobber. 3661e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner SawEarlyClobber |= OpInfo.isEarlyClobber; 366209e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner 366309e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // If this is a memory input, and if the operand is not indirect, do what we 366409e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // need to to provide an address for the memory input. 366509e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner if (OpInfo.ConstraintType == TargetLowering::C_Memory && 366609e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner !OpInfo.isIndirect) { 366709e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner assert(OpInfo.Type == InlineAsm::isInput && 366809e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner "Can only indirectify direct input operands!"); 366909e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner 367009e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // Memory operands really want the address of the value. If we don't have 367109e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // an indirect input, put it in the constpool if we can, otherwise spill 367209e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // it to a stack slot. 367309e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner 367409e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // If the operand is a float, integer, or vector constant, spill to a 367509e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // constant pool entry to get its address. 367609e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner Value *OpVal = OpInfo.CallOperandVal; 367709e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner if (isa<ConstantFP>(OpVal) || isa<ConstantInt>(OpVal) || 367809e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner isa<ConstantVector>(OpVal)) { 367909e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner OpInfo.CallOperand = DAG.getConstantPool(cast<Constant>(OpVal), 368009e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner TLI.getPointerTy()); 368109e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner } else { 368209e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // Otherwise, create a stack slot and emit a store to it before the 368309e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // asm. 368409e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner const Type *Ty = OpVal->getType(); 3685514ab348fddcdffa8367685dc608b2f8d5de986dDuncan Sands uint64_t TySize = TLI.getTargetData()->getABITypeSize(Ty); 368609e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner unsigned Align = TLI.getTargetData()->getPrefTypeAlignment(Ty); 368709e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner MachineFunction &MF = DAG.getMachineFunction(); 368809e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner int SSFI = MF.getFrameInfo()->CreateStackObject(TySize, Align); 368909e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner SDOperand StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy()); 369009e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner Chain = DAG.getStore(Chain, OpInfo.CallOperand, StackSlot, NULL, 0); 369109e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner OpInfo.CallOperand = StackSlot; 369209e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner } 369309e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner 369409e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // There is no longer a Value* corresponding to this operand. 369509e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner OpInfo.CallOperandVal = 0; 369609e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner // It is now an indirect operand. 369709e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner OpInfo.isIndirect = true; 369809e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner } 369909e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner 3700e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // If this constraint is for a specific register, allocate it before 3701e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // anything else. 3702e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (OpInfo.ConstraintType == TargetLowering::C_Register) 3703e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner GetRegistersForValue(OpInfo, SawEarlyClobber, OutputRegs, InputRegs); 37040c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner } 37050c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner ConstraintInfos.clear(); 37060c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 37070c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 3708e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // Second pass - Loop over all of the operands, assigning virtual or physregs 3709e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // to registerclass operands. 3710e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner for (unsigned i = 0, e = ConstraintOperands.size(); i != e; ++i) { 3711e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner AsmOperandInfo &OpInfo = ConstraintOperands[i]; 3712e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 3713e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // C_Register operands have already been allocated, Other/Memory don't need 3714e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner // to be. 3715e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (OpInfo.ConstraintType == TargetLowering::C_RegisterClass) 3716e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner GetRegistersForValue(OpInfo, SawEarlyClobber, OutputRegs, InputRegs); 3717e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner } 3718e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner 37190c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // AsmNodeOperands - The operands for the ISD::INLINEASM node. 37200c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner std::vector<SDOperand> AsmNodeOperands; 37210c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 37220c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner AsmNodeOperands.push_back( 37230c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), MVT::Other)); 37240c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 37252cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 37260f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 37270f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 3728864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 37290c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner 37300c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // IndirectStoresToEmit - The set of stores to emit after the inline asm node. 3731864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 37320f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 37330c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner for (unsigned i = 0, e = ConstraintOperands.size(); i != e; ++i) { 37340c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner AsmOperandInfo &OpInfo = ConstraintOperands[i]; 37351efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 37360c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner switch (OpInfo.Type) { 37372cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 3738c83994e5d4c75b4dc3d0e2ac52972a4fff816eb6Chris Lattner if (OpInfo.ConstraintType != TargetLowering::C_RegisterClass && 3739c83994e5d4c75b4dc3d0e2ac52972a4fff816eb6Chris Lattner OpInfo.ConstraintType != TargetLowering::C_Register) { 3740f2f3cd5129a1eef6034ce09314b10f3a1e1abaf6Chris Lattner // Memory output, or 'other' output (e.g. 'X' constraint). 374109e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner assert(OpInfo.isIndirect && "Memory output must be indirect operand"); 374222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 374322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 374422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 3745c90233b836c5d00045bbe7ca3d5d92df4825f5a1Chris Lattner AsmNodeOperands.push_back(DAG.getTargetConstant(ResOpType, 3746c90233b836c5d00045bbe7ca3d5d92df4825f5a1Chris Lattner TLI.getPointerTy())); 374709e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner AsmNodeOperands.push_back(OpInfo.CallOperand); 374822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 374922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 375022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 37512a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner // Otherwise, this is a register or register class output. 375222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 3753864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 3754864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 3755e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (OpInfo.AssignedRegs.Regs.empty()) { 3756832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Couldn't allocate output reg for contraint '" 37570c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner << OpInfo.ConstraintCode << "'!\n"; 3758d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner exit(1); 3759d03f1581c8a854fdbe4f5a738e9322341c2bc77fChris Lattner } 37602cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 37610c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner if (!OpInfo.isIndirect) { 37620c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner // This is the result value of the call. 3763864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 37642cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 3765fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands assert(CS.getType() != Type::VoidTy && "Bad inline asm!"); 3766e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner RetValRegs = OpInfo.AssignedRegs; 37672cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 3768e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner IndirectStoresToEmit.push_back(std::make_pair(OpInfo.AssignedRegs, 37690c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner OpInfo.CallOperandVal)); 37702cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 37716656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 37726656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 37736656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 3774e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.AssignedRegs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, 3775e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner AsmNodeOperands); 37766656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 37776656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 37786656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 37790c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner SDOperand InOperandVal = OpInfo.CallOperand; 37803d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 37810c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner if (isdigit(OpInfo.ConstraintCode[0])) { // Matching constraint? 37822223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 37832223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 37840c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner unsigned OperandNo = atoi(OpInfo.ConstraintCode.c_str()); 37853d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 3786c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 3787c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 3788c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 3789c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 3790c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 3791c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 3792c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 3793a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner assert(((NumOps & 7) == 2 /*REGDEF*/ || 3794a15cf7045efc688b813f4bc7cbc9f17c27114c04Chris Lattner (NumOps & 7) == 4 /*MEM*/) && 3795c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 3796c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 3797c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 3798c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 3799c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 3800c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 3801527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner if ((NumOps & 7) == 2 /*REGDEF*/) { 3802527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 3803527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner RegsForValue MatchedRegs; 3804527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 3805527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 3806527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 3807527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner unsigned Reg = 3808527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 3809527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.Regs.push_back(Reg); 3810527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner } 3811c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 3812527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner // Use the produced MatchedRegs object to 3813b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, &Flag); 3814527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 3815527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner break; 3816527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner } else { 3817527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner assert((NumOps & 7) == 4/*MEM*/ && "Unknown matching constraint!"); 3818527fae12c3b58d6151aa1c534c10b55d603b8da1Chris Lattner assert(0 && "matching constraints for memory operands unimp"); 3819c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 382087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 382187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 38222a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner if (OpInfo.ConstraintType == TargetLowering::C_Other) { 38230c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner assert(!OpInfo.isIndirect && 382444b2c5098f5cf766b4eff43d9eb0d8a9a143e7d8Chris Lattner "Don't know how to handle indirect other inputs yet!"); 382544b2c5098f5cf766b4eff43d9eb0d8a9a143e7d8Chris Lattner 382648884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner std::vector<SDOperand> Ops; 382748884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner TLI.LowerAsmOperandForConstraint(InOperandVal, OpInfo.ConstraintCode[0], 382848884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner Ops, DAG); 382948884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner if (Ops.empty()) { 3830832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Invalid operand for inline asm constraint '" 38310c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner << OpInfo.ConstraintCode << "'!\n"; 383253069fbbae2558a3138df24776448791fea3aceeChris Lattner exit(1); 383353069fbbae2558a3138df24776448791fea3aceeChris Lattner } 3834c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 383587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 383648884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner unsigned ResOpType = 3 /*IMM*/ | (Ops.size() << 3); 3837c90233b836c5d00045bbe7ca3d5d92df4825f5a1Chris Lattner AsmNodeOperands.push_back(DAG.getTargetConstant(ResOpType, 3838c90233b836c5d00045bbe7ca3d5d92df4825f5a1Chris Lattner TLI.getPointerTy())); 383948884cd80b52be1528618f2e9b3425ac24e7b5caChris Lattner AsmNodeOperands.insert(AsmNodeOperands.end(), Ops.begin(), Ops.end()); 384087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 38412a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner } else if (OpInfo.ConstraintType == TargetLowering::C_Memory) { 384209e4b7e1b7d624a3010ace2c23783e77b366fa7eChris Lattner assert(OpInfo.isIndirect && "Operand must be indirect to be a mem!"); 384344b2c5098f5cf766b4eff43d9eb0d8a9a143e7d8Chris Lattner assert(InOperandVal.getValueType() == TLI.getPointerTy() && 384444b2c5098f5cf766b4eff43d9eb0d8a9a143e7d8Chris Lattner "Memory operands expect pointer values"); 384544b2c5098f5cf766b4eff43d9eb0d8a9a143e7d8Chris Lattner 384687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 384787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 3848c90233b836c5d00045bbe7ca3d5d92df4825f5a1Chris Lattner AsmNodeOperands.push_back(DAG.getTargetConstant(ResOpType, 3849c90233b836c5d00045bbe7ca3d5d92df4825f5a1Chris Lattner TLI.getPointerTy())); 385087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 3851c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 38522223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 385387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 38542a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner assert((OpInfo.ConstraintType == TargetLowering::C_RegisterClass || 38552a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner OpInfo.ConstraintType == TargetLowering::C_Register) && 38562a600be22618b09165f3fe2a88bbe2fb71bc478dChris Lattner "Unknown constraint type!"); 38570c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner assert(!OpInfo.isIndirect && 385844b2c5098f5cf766b4eff43d9eb0d8a9a143e7d8Chris Lattner "Don't know how to handle indirect register inputs yet!"); 385987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 386087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 3861e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner assert(!OpInfo.AssignedRegs.Regs.empty() && 3862e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner "Couldn't allocate input reg!"); 386387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 3864b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman OpInfo.AssignedRegs.getCopyToRegs(InOperandVal, DAG, Chain, &Flag); 386587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 3866e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.AssignedRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, 3867e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner AsmNodeOperands); 38686656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 38696656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3870c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 3871c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 3872c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 3873e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner if (!OpInfo.AssignedRegs.Regs.empty()) 3874e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner OpInfo.AssignedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, 3875e7cf56aeeebed7423402fdf84c5b1aaf6830316eChris Lattner AsmNodeOperands); 38766656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 38776656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3878c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 38796656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3880ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3881ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 3882ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 3883ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 3884ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3885f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, 3886f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner DAG.getNodeValueTypes(MVT::Other, MVT::Flag), 2, 3887bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &AsmNodeOperands[0], AsmNodeOperands.size()); 3888ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 3889ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 38906656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 38916656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 38923a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner if (!RetValRegs.Regs.empty()) { 3893b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand Val = RetValRegs.getCopyFromRegs(DAG, Chain, &Flag); 38943a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner 38953a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner // If the result of the inline asm is a vector, it may have the wrong 38963a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner // width/num elts. Make sure to convert it to the right type with 38977f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman // bit_convert. 38987f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman if (MVT::isVector(Val.getValueType())) { 3899fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands const VectorType *VTy = cast<VectorType>(CS.getType()); 39007f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman MVT::ValueType DesiredVT = TLI.getValueType(VTy); 39013a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner 39027f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman Val = DAG.getNode(ISD::BIT_CONVERT, DesiredVT, Val); 39033a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner } 39043a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner 3905fd7b326bea39c077eea8d378156bcf09051cc4ecDuncan Sands setValue(CS.getInstruction(), Val); 39063a508c94a6c6f124e8b0549358ce76deb92ab662Chris Lattner } 39076656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 39086656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 39096656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 39106656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 39116656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 39126656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 3913864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 39146656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 3915b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, &Flag); 3916864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 39176656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 3918ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 39196656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 3920bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 39216656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 39220c58340aead6880876076ee4e3abf3aca92a2647Chris Lattner OutChains.push_back(DAG.getStore(Chain, StoresToEmit[i].first, 39236656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 39248b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng StoresToEmit[i].second, 0)); 39256656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 3926bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, 3927bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size()); 3928ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 3929ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 3930ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 3931ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 39321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 39331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 39341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 39351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 393668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 393768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 393868cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 393968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 394068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 39411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 39421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 3943514ab348fddcdffa8367685dc608b2f8d5de986dDuncan Sands uint64_t ElementSize = TD->getABITypeSize(I.getType()->getElementType()); 39441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 39450bd4893a0726889b942405262e53d06cf3fe3be8Chris Lattner Src, DAG.getIntPtrConstant(ElementSize)); 39461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 394747857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 394847857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 394947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = Src; 395047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Ty = TLI.getTargetData()->getIntPtrType(); 395147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 3952cf5734dddd66af9388a171b44996505ede47feedChris Lattner 3953cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 395447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), I.getType(), false, false, CallingConv::C, true, 3955cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 3956cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 3957cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 3958cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 39591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 39601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 39611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 396247857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListTy Args; 396347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TargetLowering::ArgListEntry Entry; 396447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Node = getValue(I.getOperand(0)); 396547857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Entry.Ty = TLI.getTargetData()->getIntPtrType(); 396647857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer Args.push_back(Entry); 39671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 3968cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 396947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer TLI.LowerCallTo(getRoot(), Type::VoidTy, false, false, CallingConv::C, true, 3970cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 3971cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 39721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 39731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3974ff9b373e8f5006c629af81e2619778b4c4f5249eEvan Cheng// EmitInstrWithCustomInserter - This method should be implemented by targets 3975ff9b373e8f5006c629af81e2619778b4c4f5249eEvan Cheng// that mark instructions with the 'usesCustomDAGSchedInserter' flag. These 3976025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 3977025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 3978025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 3979ff9b373e8f5006c629af81e2619778b4c4f5249eEvan ChengMachineBasicBlock *TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI, 3980025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 3981832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "If a target marks an instruction with " 3982832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling << "'usesCustomDAGSchedInserter', it must implement " 3983ff9b373e8f5006c629af81e2619778b4c4f5249eEvan Cheng << "TargetLowering::EmitInstrWithCustomInserter!\n"; 3984025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 3985025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 3986025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 3987025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 398839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 3989acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 3990acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 3991acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 399239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 399339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 39941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 3995acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 3996acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 3997acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 3998acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 3999acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 40001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 40011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 4003acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 4004acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 4005acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 40061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 40071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 40081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 4009acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 4010acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 4011acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 4012acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 4013acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 40141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 40151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4016fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// TargetLowering::LowerArguments - This is the default LowerArguments 4017fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// implementation, which just inserts a FORMAL_ARGUMENTS node. FIXME: When all 4018f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// targets are migrated to using FORMAL_ARGUMENTS, this hook should be 4019f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// integrated into SDISel. 4020fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattnerstd::vector<SDOperand> 4021fdfded55888e35b76bb70231a5bb2f60877c2f6aChris LattnerTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { 4022fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. 4023fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<SDOperand> Ops; 40248c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner Ops.push_back(DAG.getRoot()); 4025fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.getCallingConv(), getPointerTy())); 4026fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.isVarArg(), getPointerTy())); 4027fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 4028fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add one result value for each formal argument. 4029fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<MVT::ValueType> RetVals; 40306aa279dc8b5a05499b2cd158f8187d7225adc4f4Anton Korobeynikov unsigned j = 1; 4031ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); 4032ac2b2cf88c9331bf44e802f6d31805c40a56af0fAnton Korobeynikov I != E; ++I, ++j) { 4033fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 4034d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov unsigned Flags = ISD::ParamFlags::NoFlagSet; 40357aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio unsigned OriginalAlignment = 4036d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner getTargetData()->getABITypeAlignment(I->getType()); 40377aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio 4038ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner // FIXME: Distinguish between a formal with no [sz]ext attribute from one 4039ddf53e45b29087c57e0c864c93f86d5e99182d55Chris Lattner // that is zero extended! 4040afa3b6da11bc05281bcf09e45de9e037e0ee5011Duncan Sands if (F.paramHasAttr(j, ParamAttr::ZExt)) 4041d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags &= ~(ISD::ParamFlags::SExt); 4042afa3b6da11bc05281bcf09e45de9e037e0ee5011Duncan Sands if (F.paramHasAttr(j, ParamAttr::SExt)) 4043d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::SExt; 4044afa3b6da11bc05281bcf09e45de9e037e0ee5011Duncan Sands if (F.paramHasAttr(j, ParamAttr::InReg)) 4045d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::InReg; 4046afa3b6da11bc05281bcf09e45de9e037e0ee5011Duncan Sands if (F.paramHasAttr(j, ParamAttr::StructRet)) 4047d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::StructReturn; 4048afa3b6da11bc05281bcf09e45de9e037e0ee5011Duncan Sands if (F.paramHasAttr(j, ParamAttr::ByVal)) { 40491aa7efbd2c98e761f50992197473304b99257ca9Rafael Espindola Flags |= ISD::ParamFlags::ByVal; 4050594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola const PointerType *Ty = cast<PointerType>(I->getType()); 4051a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands const Type *ElementTy = Ty->getElementType(); 40523ae054385cfe9f2fcef2d77f26839615b1d3e48bEvan Cheng unsigned FrameAlign = Log2_32(getByValTypeAlignment(ElementTy)); 4053a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands unsigned FrameSize = getTargetData()->getABITypeSize(ElementTy); 4054a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands Flags |= (FrameAlign << ISD::ParamFlags::ByValAlignOffs); 4055a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands Flags |= (FrameSize << ISD::ParamFlags::ByValSizeOffs); 4056594d37e21aea4ef841d9ee5d9c328c4bf1c6bed7Rafael Espindola } 4057afa3b6da11bc05281bcf09e45de9e037e0ee5011Duncan Sands if (F.paramHasAttr(j, ParamAttr::Nest)) 405836397f50343639ce9a25996f2d790c656791ab92Duncan Sands Flags |= ISD::ParamFlags::Nest; 4059d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= (OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs); 4060b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4061b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType RegisterVT = getRegisterType(VT); 4062b988baccc229ef3e175905c999245d5544a0d384Duncan Sands unsigned NumRegs = getNumRegisters(VT); 4063b988baccc229ef3e175905c999245d5544a0d384Duncan Sands for (unsigned i = 0; i != NumRegs; ++i) { 4064b988baccc229ef3e175905c999245d5544a0d384Duncan Sands RetVals.push_back(RegisterVT); 4065b988baccc229ef3e175905c999245d5544a0d384Duncan Sands // if it isn't first piece, alignment must be 1 4066b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (i > 0) 4067b988baccc229ef3e175905c999245d5544a0d384Duncan Sands Flags = (Flags & (~ISD::ParamFlags::OrigAlignment)) | 4068b988baccc229ef3e175905c999245d5544a0d384Duncan Sands (1 << ISD::ParamFlags::OrigAlignmentOffs); 4069b10308e440c80dd6ffb4b478f741ff7e5f30cb48Anton Korobeynikov Ops.push_back(DAG.getConstant(Flags, MVT::i32)); 4070b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman } 4071fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 40723b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng 40738c0c10c2b9fef21dcbabac81fffa32f4407a0b7fChris Lattner RetVals.push_back(MVT::Other); 4074fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 4075fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Create the node. 4076f9f37fc52c444e34bad7846729ae5481a65e0a53Chris Lattner SDNode *Result = DAG.getNode(ISD::FORMAL_ARGUMENTS, 407786ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner DAG.getVTList(&RetVals[0], RetVals.size()), 4078bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &Ops[0], Ops.size()).Val; 407986ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner 408086ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner // Prelower FORMAL_ARGUMENTS. This isn't required for functionality, but 408186ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner // allows exposing the loads that may be part of the argument access to the 408286ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner // first DAGCombiner pass. 408386ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner SDOperand TmpRes = LowerOperation(SDOperand(Result, 0), DAG); 408486ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner 408586ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner // The number of results should match up, except that the lowered one may have 408686ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner // an extra flag result. 408786ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner assert((Result->getNumValues() == TmpRes.Val->getNumValues() || 408886ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner (Result->getNumValues()+1 == TmpRes.Val->getNumValues() && 408986ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner TmpRes.getValue(Result->getNumValues()).getValueType() == MVT::Flag)) 409086ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner && "Lowering produced unexpected number of results!"); 409186ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner Result = TmpRes.Val; 409286ca3cacc5a56e862c8258ac9c9ee1e37598ebd8Chris Lattner 409327a70be55f8b63181598d144d034b396402be66eDan Gohman unsigned NumArgRegs = Result->getNumValues() - 1; 409427a70be55f8b63181598d144d034b396402be66eDan Gohman DAG.setRoot(SDOperand(Result, NumArgRegs)); 4095fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 4096fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Set up the return result vector. 4097fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.clear(); 4098fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned i = 0; 409947857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer unsigned Idx = 1; 410047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; 410147857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer ++I, ++Idx) { 4102fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 4103b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType PartVT = getRegisterType(VT); 4104b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4105b988baccc229ef3e175905c999245d5544a0d384Duncan Sands unsigned NumParts = getNumRegisters(VT); 4106b988baccc229ef3e175905c999245d5544a0d384Duncan Sands SmallVector<SDOperand, 4> Parts(NumParts); 4107b988baccc229ef3e175905c999245d5544a0d384Duncan Sands for (unsigned j = 0; j != NumParts; ++j) 4108b988baccc229ef3e175905c999245d5544a0d384Duncan Sands Parts[j] = SDOperand(Result, i++); 4109b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4110b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ISD::NodeType AssertOp = ISD::DELETED_NODE; 4111b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (F.paramHasAttr(Idx, ParamAttr::SExt)) 4112b988baccc229ef3e175905c999245d5544a0d384Duncan Sands AssertOp = ISD::AssertSext; 4113b988baccc229ef3e175905c999245d5544a0d384Duncan Sands else if (F.paramHasAttr(Idx, ParamAttr::ZExt)) 4114b988baccc229ef3e175905c999245d5544a0d384Duncan Sands AssertOp = ISD::AssertZext; 4115b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4116b988baccc229ef3e175905c999245d5544a0d384Duncan Sands Ops.push_back(getCopyFromParts(DAG, &Parts[0], NumParts, PartVT, VT, 4117b988baccc229ef3e175905c999245d5544a0d384Duncan Sands AssertOp, true)); 4118fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 411927a70be55f8b63181598d144d034b396402be66eDan Gohman assert(i == NumArgRegs && "Argument register count mismatch!"); 4120fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner return Ops; 4121fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner} 4122fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 4123f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 4124f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// TargetLowering::LowerCallTo - This is the default LowerCallTo 4125f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// implementation, which just inserts an ISD::CALL node, which is later custom 4126f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// lowered by the target to something concrete. FIXME: When all targets are 4127f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner/// migrated to using ISD::CALL, this hook should be integrated into SDISel. 4128f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattnerstd::pair<SDOperand, SDOperand> 412947857812e29324a9d1560796a05b53d3a9217fd9Reid SpencerTargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, 413047857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer bool RetTyIsSigned, bool isVarArg, 4131f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner unsigned CallingConv, bool isTailCall, 4132f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner SDOperand Callee, 4133f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner ArgListTy &Args, SelectionDAG &DAG) { 4134be384162c68641233deba8702666af51bdfd4b83Chris Lattner SmallVector<SDOperand, 32> Ops; 4135f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Chain); // Op#0 - Chain 4136f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(CallingConv, getPointerTy())); // Op#1 - CC 4137f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isVarArg, getPointerTy())); // Op#2 - VarArg 4138f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(DAG.getConstant(isTailCall, getPointerTy())); // Op#3 - Tail 4139f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner Ops.push_back(Callee); 4140f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 4141f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Handle all of the outgoing arguments. 4142f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner for (unsigned i = 0, e = Args.size(); i != e; ++i) { 414347857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer MVT::ValueType VT = getValueType(Args[i].Ty); 414447857812e29324a9d1560796a05b53d3a9217fd9Reid Spencer SDOperand Op = Args[i].Node; 4145d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov unsigned Flags = ISD::ParamFlags::NoFlagSet; 41467aa47b69ca5f4feb6b106a50959e37822bd25b4fLauro Ramos Venancio unsigned OriginalAlignment = 4147d2b7cec527a0efa552628378ebca7a8ca63bb45dChris Lattner getTargetData()->getABITypeAlignment(Args[i].Ty); 41480db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov 4149d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov if (Args[i].isSExt) 4150d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::SExt; 4151d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov if (Args[i].isZExt) 4152d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::ZExt; 41530db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (Args[i].isInReg) 4154d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::InReg; 41550db79d86de74c315813d60f51ed842c0ba0f34ddAnton Korobeynikov if (Args[i].isSRet) 4156d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= ISD::ParamFlags::StructReturn; 415721485be444bd132941faf4e5653ac34b3ec74040Rafael Espindola if (Args[i].isByVal) { 415821485be444bd132941faf4e5653ac34b3ec74040Rafael Espindola Flags |= ISD::ParamFlags::ByVal; 415921485be444bd132941faf4e5653ac34b3ec74040Rafael Espindola const PointerType *Ty = cast<PointerType>(Args[i].Ty); 4160a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands const Type *ElementTy = Ty->getElementType(); 41613ae054385cfe9f2fcef2d77f26839615b1d3e48bEvan Cheng unsigned FrameAlign = Log2_32(getByValTypeAlignment(ElementTy)); 4162a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands unsigned FrameSize = getTargetData()->getABITypeSize(ElementTy); 4163a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands Flags |= (FrameAlign << ISD::ParamFlags::ByValAlignOffs); 4164a41d7198035bdeaa3ba0a5840086d34ebcddac26Duncan Sands Flags |= (FrameSize << ISD::ParamFlags::ByValSizeOffs); 416521485be444bd132941faf4e5653ac34b3ec74040Rafael Espindola } 416636397f50343639ce9a25996f2d790c656791ab92Duncan Sands if (Args[i].isNest) 416736397f50343639ce9a25996f2d790c656791ab92Duncan Sands Flags |= ISD::ParamFlags::Nest; 4168d0b82b301d700217a716526f9329bb031e0d6578Anton Korobeynikov Flags |= OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs; 4169b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4170b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MVT::ValueType PartVT = getRegisterType(VT); 4171b988baccc229ef3e175905c999245d5544a0d384Duncan Sands unsigned NumParts = getNumRegisters(VT); 4172b988baccc229ef3e175905c999245d5544a0d384Duncan Sands SmallVector<SDOperand, 4> Parts(NumParts); 4173b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ISD::NodeType ExtendKind = ISD::ANY_EXTEND; 4174b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4175b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (Args[i].isSExt) 4176b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ExtendKind = ISD::SIGN_EXTEND; 4177b988baccc229ef3e175905c999245d5544a0d384Duncan Sands else if (Args[i].isZExt) 4178b988baccc229ef3e175905c999245d5544a0d384Duncan Sands ExtendKind = ISD::ZERO_EXTEND; 4179b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4180b988baccc229ef3e175905c999245d5544a0d384Duncan Sands getCopyToParts(DAG, Op, &Parts[0], NumParts, PartVT, ExtendKind); 4181b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4182b988baccc229ef3e175905c999245d5544a0d384Duncan Sands for (unsigned i = 0; i != NumParts; ++i) { 4183b988baccc229ef3e175905c999245d5544a0d384Duncan Sands // if it isn't first piece, alignment must be 1 4184b988baccc229ef3e175905c999245d5544a0d384Duncan Sands unsigned MyFlags = Flags; 4185b988baccc229ef3e175905c999245d5544a0d384Duncan Sands if (i != 0) 4186b988baccc229ef3e175905c999245d5544a0d384Duncan Sands MyFlags = (MyFlags & (~ISD::ParamFlags::OrigAlignment)) | 4187b988baccc229ef3e175905c999245d5544a0d384Duncan Sands (1 << ISD::ParamFlags::OrigAlignmentOffs); 4188b988baccc229ef3e175905c999245d5544a0d384Duncan Sands 4189b988baccc229ef3e175905c999245d5544a0d384Duncan Sands Ops.push_back(Parts[i]); 4190b988baccc229ef3e175905c999245d5544a0d384Duncan Sands Ops.push_back(DAG.getConstant(MyFlags, MVT::i32)); 419127a70be55f8b63181598d144d034b396402be66eDan Gohman } 4192f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 4193f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 4194f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner // Figure out the result value types. 4195b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman MVT::ValueType VT = getValueType(RetTy); 4196b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman MVT::ValueType RegisterVT = getRegisterType(VT); 4197b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned NumRegs = getNumRegisters(VT); 4198b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SmallVector<MVT::ValueType, 4> RetTys(NumRegs); 4199b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman for (unsigned i = 0; i != NumRegs; ++i) 4200b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman RetTys[i] = RegisterVT; 4201f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 4202f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner RetTys.push_back(MVT::Other); // Always has a chain. 4203f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 4204b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Create the CALL node. 4205be384162c68641233deba8702666af51bdfd4b83Chris Lattner SDOperand Res = DAG.getNode(ISD::CALL, 4206b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman DAG.getVTList(&RetTys[0], NumRegs + 1), 4207be384162c68641233deba8702666af51bdfd4b83Chris Lattner &Ops[0], Ops.size()); 4208b15e49597f031fdd41fdec2887a3c24c0ea430d8Chris Lattner Chain = Res.getValue(NumRegs); 4209b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 4210b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Gather up the call result into a single value. 4211b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman if (RetTy != Type::VoidTy) { 4212b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman ISD::NodeType AssertOp = ISD::AssertSext; 4213b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman if (!RetTyIsSigned) 4214b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman AssertOp = ISD::AssertZext; 4215b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SmallVector<SDOperand, 4> Results(NumRegs); 4216b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman for (unsigned i = 0; i != NumRegs; ++i) 4217b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman Results[i] = Res.getValue(i); 4218532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman Res = getCopyFromParts(DAG, &Results[0], NumRegs, RegisterVT, VT, AssertOp); 4219f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner } 4220b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 4221b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman return std::make_pair(Res, Chain); 4222f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner} 4223f4ec817299a4187044a6162c2f520772b3ad69a0Chris Lattner 422450381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 4225171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 4226171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 4227d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 4228171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 4229171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 42300aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 42310aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 42320aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 42330aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 42340aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 42350aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 42360aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 423774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 42381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 42391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 4240a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 42411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 42421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 42431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 42441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 42451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 42461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 42471db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 42481db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 42491db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 42501db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 42511db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 42521db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 42531db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 42541db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 42551db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 42561db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 42571db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 42581db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 42591db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 42601db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 42611db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 42621db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 42631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 42641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 42651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 42661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 426774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 426874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 426974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 427074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 427174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 427274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 427374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 4274b55757ec5f6f0218342a8910e1bbd9f018adc7d7Dan Gohman unsigned MSB = MVT::getSizeInBits(VT) / 8; 427574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 427674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 427774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 4278a5a57d66f5717873dbf3c48b174c0b0ce54b6612Evan Cheng Val = (Val << 8) | (unsigned char)Str[Offset]; 427974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 428074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 428174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 428274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 428374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 42841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 42851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 42861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 42871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 42881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 42891db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 42901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 4291c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 429280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 429380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 4294c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 4295c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 4296c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 42971db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 42981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 42991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 43001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 43011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 43021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 43031db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 43041db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 43051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 43061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 43071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 43081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 43091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 43101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 43111db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 43121db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 43131db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 43141db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 43151db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 43161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 43171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 431880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 431980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 432080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 432180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 43221db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 432380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 432480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 432580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 4326dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 43271db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 4328b55757ec5f6f0218342a8910e1bbd9f018adc7d7Dan Gohman unsigned VTSize = MVT::getSizeInBits(VT) / 8; 43291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 43301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 43311db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 43321db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 433380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 433480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 433580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 433680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 43371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 43381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 43391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 434080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 434180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 43421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 43431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 43447041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 43451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 43461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 43471db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 43481db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 43491db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 43501db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 43511db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 43525f43f92c69aae9837064cf08291db1b36a82789fDan Gohman // If the source and destination are known to not be aliases, we can 43535f43f92c69aae9837064cf08291db1b36a82789fDan Gohman // lower memmove as memcpy. 43545f43f92c69aae9837064cf08291db1b36a82789fDan Gohman if (Op == ISD::MEMMOVE) { 43558806c7b1f5317a9679a5779ffc08c552f2091bceAnton Korobeynikov uint64_t Size = -1ULL; 43565f43f92c69aae9837064cf08291db1b36a82789fDan Gohman if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op3)) 43575f43f92c69aae9837064cf08291db1b36a82789fDan Gohman Size = C->getValue(); 43585f43f92c69aae9837064cf08291db1b36a82789fDan Gohman if (AA.alias(I.getOperand(1), Size, I.getOperand(2), Size) == 43595f43f92c69aae9837064cf08291db1b36a82789fDan Gohman AliasAnalysis::NoAlias) 43605f43f92c69aae9837064cf08291db1b36a82789fDan Gohman Op = ISD::MEMCPY; 43615f43f92c69aae9837064cf08291db1b36a82789fDan Gohman } 43625f43f92c69aae9837064cf08291db1b36a82789fDan Gohman 43631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 43641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 43651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 43661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 43671db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 4368bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner SmallVector<SDOperand, 8> OutChains; 43691db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 4370ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 43711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 4372c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 4373c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 437480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 43751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 43761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 43771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 4378b55757ec5f6f0218342a8910e1bbd9f018adc7d7Dan Gohman unsigned VTSize = MVT::getSizeInBits(VT) / 8; 4379a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 4380786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng SDOperand Store = DAG.getStore(getRoot(), Value, 4381864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 43828b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), Offset); 4383c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 4384c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 4385c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 4386c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 4387c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 4388c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 4389c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 4390c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 4391c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 4392c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 4393cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 439474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 439574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 4396cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 439774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 439874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 439974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 440074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 440174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 440274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 440374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 4404cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 440574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 440674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 440774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 4408f3e486e069011c70abb771958dc1218912b98eeaEvan Cheng if (GV && GV->isConstant()) { 44090937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 4410cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 4411cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 4412cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 4413cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 4414cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 441574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 441674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 4417c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 4418c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 4419b55757ec5f6f0218342a8910e1bbd9f018adc7d7Dan Gohman unsigned VTSize = MVT::getSizeInBits(VT) / 8; 442074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 442174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 4422cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 442374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 442474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 442574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 4426786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 4427786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 44288b2794aeff151be8cdbd44786c1d0f94f8f2e427Evan Cheng I.getOperand(1), DstOff); 442974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 443074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 4431984e986929c34f9fa41ad33e3a4f19816f80c1adBill Wendling getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 4432984e986929c34f9fa41ad33e3a4f19816f80c1adBill Wendling I.getOperand(2), SrcOff, false, Align); 443374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 443474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 4435786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng DAG.getStore(Chain, Value, 4436786225adf09e606c795ef68a1f789c12f37869f2Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 4437984e986929c34f9fa41ad33e3a4f19816f80c1adBill Wendling I.getOperand(1), DstOff, false, Align); 443874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 4439c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 444074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 444174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 44421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 44431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 4444c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 44451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 44461db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 4447c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 4448c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 4449bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 4450bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &OutChains[0], OutChains.size())); 4451c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 4452c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 44531db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 44541db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 44555c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola SDOperand AlwaysInline = DAG.getConstant(0, MVT::i1); 44565c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola SDOperand Node; 44575c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola switch(Op) { 44585c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola default: 44595c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola assert(0 && "Unknown Op"); 44605c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola case ISD::MEMCPY: 44615c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola Node = DAG.getMemcpy(getRoot(), Op1, Op2, Op3, Op4, AlwaysInline); 44625c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola break; 44635c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola case ISD::MEMMOVE: 44645c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola Node = DAG.getMemmove(getRoot(), Op1, Op2, Op3, Op4, AlwaysInline); 44655c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola break; 44665c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola case ISD::MEMSET: 44675c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola Node = DAG.getMemset(getRoot(), Op1, Op2, Op3, Op4, AlwaysInline); 44685c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola break; 44695c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola } 44705c0d6ed325417baa5d119af9c2b6790231d8565fRafael Espindola DAG.setRoot(Node); 44711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 44721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44737041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 44747041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 44757041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 44761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 447884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner return RegInfo->createVirtualRegister(TLI.getRegClassFor(VT)); 44791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 44801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4481495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 4482c7c3f110eda0ff8040e4bd99e38d3112b910810fJim Laskey AU.addRequired<AliasAnalysis>(); 4483ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen AU.addRequired<CollectorModuleMetadata>(); 4484c8d288f8fa9e46199a29e1954550c980f184bd1cChris Lattner AU.setPreservesAll(); 4485495a0b51915eb763576874f29192820b731edc22Chris Lattner} 44861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4487c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 4488bad7f48c7070444eeb767c169f8bbed86b2c1ae1Chris Lattner 44891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 44905f43f92c69aae9837064cf08291db1b36a82789fDan Gohman // Get alias analysis for load/store combining. 44915f43f92c69aae9837064cf08291db1b36a82789fDan Gohman AA = &getAnalysis<AliasAnalysis>(); 44925f43f92c69aae9837064cf08291db1b36a82789fDan Gohman 44931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 4494ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen if (MF.getFunction()->hasCollector()) 4495ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen GCI = &getAnalysis<CollectorModuleMetadata>().get(*MF.getFunction()); 4496ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen else 4497ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen GCI = 0; 449884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner RegInfo = &MF.getRegInfo(); 4499832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "\n\n\n=== " << Fn.getName() << "\n"; 45001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 45011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 45021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4503ea632439d4259254670dc4a27b13d6f9370216a8Duncan Sands if (ExceptionHandling) 4504ea632439d4259254670dc4a27b13d6f9370216a8Duncan Sands for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 4505ea632439d4259254670dc4a27b13d6f9370216a8Duncan Sands if (InvokeInst *Invoke = dyn_cast<InvokeInst>(I->getTerminator())) 4506ea632439d4259254670dc4a27b13d6f9370216a8Duncan Sands // Mark landing pad. 4507ea632439d4259254670dc4a27b13d6f9370216a8Duncan Sands FuncInfo.MBBMap[Invoke->getSuccessor(1)]->setIsLandingPad(); 45089fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands 45099fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 45101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 4511edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 4512ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng // Add function live-ins to entry block live-in set. 4513ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng BasicBlock *EntryBB = &Fn.getEntryBlock(); 4514ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng BB = FuncInfo.MBBMap[EntryBB]; 451584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner if (!RegInfo->livein_empty()) 451684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner for (MachineRegisterInfo::livein_iterator I = RegInfo->livein_begin(), 451784bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner E = RegInfo->livein_end(); I != E; ++I) 4518ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng BB->addLiveIn(I->first); 4519ad2070c667ebabf1650be63e6b3e0b411da86918Evan Cheng 4520f40708223e409a152834b1553c6883ff2035b957Duncan Sands#ifndef NDEBUG 4521f40708223e409a152834b1553c6883ff2035b957Duncan Sands assert(FuncInfo.CatchInfoFound.size() == FuncInfo.CatchInfoLost.size() && 4522f40708223e409a152834b1553c6883ff2035b957Duncan Sands "Not all catch info was assigned to a landing pad!"); 4523f40708223e409a152834b1553c6883ff2035b957Duncan Sands#endif 4524f40708223e409a152834b1553c6883ff2035b957Duncan Sands 45251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 45261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 45271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4528571e434a34e26f295f13db2dd07551de7e25f8a9Chris LattnerSDOperand SelectionDAGLowering::CopyValueToVirtualRegister(Value *V, 4529571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner unsigned Reg) { 4530571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDOperand Op = getValue(V); 453118c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 4532d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 453318c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 4534d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 4535d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 4536b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman MVT::ValueType RegisterVT = TLI.getRegisterType(SrcVT); 4537b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman unsigned NumRegs = TLI.getNumRegisters(SrcVT); 4538b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SmallVector<SDOperand, 8> Regs(NumRegs); 4539b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman SmallVector<SDOperand, 8> Chains(NumRegs); 4540b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman 4541b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman // Copy the value by legal parts into sequential virtual registers. 4542532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman getCopyToParts(DAG, Op, &Regs[0], NumRegs, RegisterVT); 454327a70be55f8b63181598d144d034b396402be66eDan Gohman for (unsigned i = 0; i != NumRegs; ++i) 4544b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman Chains[i] = DAG.getCopyToReg(getRoot(), Reg + i, Regs[i]); 4545b6f5b00c3bad3415d3f2ee1a6d5ee5a6f66a4540Dan Gohman return DAG.getNode(ISD::TokenFactor, MVT::Other, &Chains[0], NumRegs); 45461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 45471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4548068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 454915699fc5ed0378205f9705d35d019d9ff0cf200dEvan ChengLowerArguments(BasicBlock *LLVMBB, SelectionDAGLowering &SDL, 4550068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 45511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 455215699fc5ed0378205f9705d35d019d9ff0cf200dEvan Cheng Function &F = *LLVMBB->getParent(); 45530afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 4554bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 4555bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 4556bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 4557bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 4558bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 4559bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 4560bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 4561bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 4562f7179bb56ea49e627cdc531ea73d7b6940e87372Evan Cheng 4563bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 4564bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 4565251db1890c1fe03d02ee878ada8129537844d031Chris Lattner DenseMap<const Value*, unsigned>::iterator VMI=FuncInfo.ValueMap.find(AI); 4566251db1890c1fe03d02ee878ada8129537844d031Chris Lattner if (VMI != FuncInfo.ValueMap.end()) { 4567251db1890c1fe03d02ee878ada8129537844d031Chris Lattner SDOperand Copy = SDL.CopyValueToVirtualRegister(AI, VMI->second); 4568bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 4569bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 45700afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 4571bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 4572bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 4573966454129dc62260df1f438f0243f6877dcd185cChris Lattner // FIXME: this should insert code into the DAG! 4574bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 4575068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 4576068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 4577f40708223e409a152834b1553c6883ff2035b957Duncan Sandsstatic void copyCatchInfo(BasicBlock *SrcBB, BasicBlock *DestBB, 4578f40708223e409a152834b1553c6883ff2035b957Duncan Sands MachineModuleInfo *MMI, FunctionLoweringInfo &FLI) { 4579f40708223e409a152834b1553c6883ff2035b957Duncan Sands for (BasicBlock::iterator I = SrcBB->begin(), E = --SrcBB->end(); I != E; ++I) 4580cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands if (isSelector(I)) { 4581f40708223e409a152834b1553c6883ff2035b957Duncan Sands // Apply the catch info to DestBB. 4582f40708223e409a152834b1553c6883ff2035b957Duncan Sands addCatchInfo(cast<CallInst>(*I), MMI, FLI.MBBMap[DestBB]); 4583f40708223e409a152834b1553c6883ff2035b957Duncan Sands#ifndef NDEBUG 4584560a737e073788463b9275c5e92ebc12f0ea62a2Duncan Sands if (!FLI.MBBMap[SrcBB]->isLandingPad()) 4585560a737e073788463b9275c5e92ebc12f0ea62a2Duncan Sands FLI.CatchInfoFound.insert(I); 4586f40708223e409a152834b1553c6883ff2035b957Duncan Sands#endif 4587f40708223e409a152834b1553c6883ff2035b957Duncan Sands } 4588f40708223e409a152834b1553c6883ff2035b957Duncan Sands} 4589f40708223e409a152834b1553c6883ff2035b957Duncan Sands 4590c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer/// CheckDAGForTailCallsAndFixThem - This Function looks for CALL nodes in the 459148abc5cf6ba6d53513034aa8c68b0a9abd748190Arnold Schwaighofer/// DAG and fixes their tailcall attribute operand. 4592c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighoferstatic void CheckDAGForTailCallsAndFixThem(SelectionDAG &DAG, 4593c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer TargetLowering& TLI) { 4594c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer SDNode * Ret = NULL; 4595c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer SDOperand Terminator = DAG.getRoot(); 4596c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 4597c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // Find RET node. 4598c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer if (Terminator.getOpcode() == ISD::RET) { 4599c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer Ret = Terminator.Val; 4600c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 4601c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 4602c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // Fix tail call attribute of CALL nodes. 4603c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer for (SelectionDAG::allnodes_iterator BE = DAG.allnodes_begin(), 4604c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer BI = prior(DAG.allnodes_end()); BI != BE; --BI) { 4605c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer if (BI->getOpcode() == ISD::CALL) { 4606c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer SDOperand OpRet(Ret, 0); 4607c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer SDOperand OpCall(static_cast<SDNode*>(BI), 0); 4608c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer bool isMarkedTailCall = 4609c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer cast<ConstantSDNode>(OpCall.getOperand(3))->getValue() != 0; 4610c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // If CALL node has tail call attribute set to true and the call is not 4611c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // eligible (no RET or the target rejects) the attribute is fixed to 461248abc5cf6ba6d53513034aa8c68b0a9abd748190Arnold Schwaighofer // false. The TargetLowering::IsEligibleForTailCallOptimization function 4613c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // must correctly identify tail call optimizable calls. 4614c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer if (isMarkedTailCall && 4615c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer (Ret==NULL || 4616c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer !TLI.IsEligibleForTailCallOptimization(OpCall, OpRet, DAG))) { 4617c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer SmallVector<SDOperand, 32> Ops; 4618c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer unsigned idx=0; 4619c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer for(SDNode::op_iterator I =OpCall.Val->op_begin(), 4620c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer E=OpCall.Val->op_end(); I!=E; I++, idx++) { 4621c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer if (idx!=3) 4622c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer Ops.push_back(*I); 4623c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer else 4624c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer Ops.push_back(DAG.getConstant(false, TLI.getPointerTy())); 4625c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 4626c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer DAG.UpdateNodeOperands(OpCall, Ops.begin(), Ops.size()); 4627c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 4628c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 4629c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer } 4630c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer} 4631c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 4632068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 4633068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 4634f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 4635ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen SelectionDAGLowering SDL(DAG, TLI, *AA, FuncInfo, GCI); 4636068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 4637068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 4638edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 4639bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 4640ecb7a77885b174cf4d001a9b48533b3979e7810dDan Gohman if (LLVMBB == &LLVMBB->getParent()->getEntryBlock()) 4641bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 46421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 46431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 46441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 46451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4646f40708223e409a152834b1553c6883ff2035b957Duncan Sands MachineModuleInfo *MMI = DAG.getMachineModuleInfo(); 46479fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands 4648f40708223e409a152834b1553c6883ff2035b957Duncan Sands if (ExceptionHandling && MMI && BB->isLandingPad()) { 4649f40708223e409a152834b1553c6883ff2035b957Duncan Sands // Add a label to mark the beginning of the landing pad. Deletion of the 4650f40708223e409a152834b1553c6883ff2035b957Duncan Sands // landing pad can thus be detected via the MachineModuleInfo. 4651f40708223e409a152834b1553c6883ff2035b957Duncan Sands unsigned LabelID = MMI->addLandingPad(BB); 4652f40708223e409a152834b1553c6883ff2035b957Duncan Sands DAG.setRoot(DAG.getNode(ISD::LABEL, MVT::Other, DAG.getEntryNode(), 4653bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(LabelID, MVT::i32), 4654bb81d97feb396a8bb21d074db1c57e9f66525f40Evan Cheng DAG.getConstant(1, MVT::i32))); 4655f40708223e409a152834b1553c6883ff2035b957Duncan Sands 4656e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng // Mark exception register as live in. 4657e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng unsigned Reg = TLI.getExceptionAddressRegister(); 4658e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng if (Reg) BB->addLiveIn(Reg); 4659e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng 4660e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng // Mark exception selector register as live in. 4661e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng Reg = TLI.getExceptionSelectorRegister(); 4662e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng if (Reg) BB->addLiveIn(Reg); 4663e47c333a12094296e54571ed1ac511a04d74840dEvan Cheng 4664f40708223e409a152834b1553c6883ff2035b957Duncan Sands // FIXME: Hack around an exception handling flaw (PR1508): the personality 4665f40708223e409a152834b1553c6883ff2035b957Duncan Sands // function and list of typeids logically belong to the invoke (or, if you 4666f40708223e409a152834b1553c6883ff2035b957Duncan Sands // like, the basic block containing the invoke), and need to be associated 4667f40708223e409a152834b1553c6883ff2035b957Duncan Sands // with it in the dwarf exception handling tables. Currently however the 4668cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // information is provided by an intrinsic (eh.selector) that can be moved 4669cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // to unexpected places by the optimizers: if the unwind edge is critical, 4670cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // then breaking it can result in the intrinsics being in the successor of 4671cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // the landing pad, not the landing pad itself. This results in exceptions 4672cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // not being caught because no typeids are associated with the invoke. 4673cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // This may not be the only way things can go wrong, but it is the only way 4674cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands // we try to work around for the moment. 4675f40708223e409a152834b1553c6883ff2035b957Duncan Sands BranchInst *Br = dyn_cast<BranchInst>(LLVMBB->getTerminator()); 4676f40708223e409a152834b1553c6883ff2035b957Duncan Sands 4677f40708223e409a152834b1553c6883ff2035b957Duncan Sands if (Br && Br->isUnconditional()) { // Critical edge? 4678f40708223e409a152834b1553c6883ff2035b957Duncan Sands BasicBlock::iterator I, E; 4679f40708223e409a152834b1553c6883ff2035b957Duncan Sands for (I = LLVMBB->begin(), E = --LLVMBB->end(); I != E; ++I) 4680cf26d7ccac1ad052b750edec36b13bc9ea8f70d7Duncan Sands if (isSelector(I)) 4681f40708223e409a152834b1553c6883ff2035b957Duncan Sands break; 4682f40708223e409a152834b1553c6883ff2035b957Duncan Sands 4683f40708223e409a152834b1553c6883ff2035b957Duncan Sands if (I == E) 4684f40708223e409a152834b1553c6883ff2035b957Duncan Sands // No catch info found - try to extract some from the successor. 4685f40708223e409a152834b1553c6883ff2035b957Duncan Sands copyCatchInfo(Br->getSuccessor(0), LLVMBB, MMI, FuncInfo); 46869fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands } 46879fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands } 46889fac0b5ff24e733072bdde68c7f34590c1892922Duncan Sands 46891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 46901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 46911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 46921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 4693f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands 46941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 4695f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands // blocks are available as virtual registers. Invoke is handled elsewhere. 46961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 4697f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands if (!I->use_empty() && !isa<PHINode>(I) && !isa<InvokeInst>(I)) { 46989f24ad79ce32200b06499ef638b502fc1c36ed04Chris Lattner DenseMap<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 46991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 4700ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 4701571e434a34e26f295f13db2dd07551de7e25f8a9Chris Lattner SDL.CopyValueToVirtualRegister(I, VMI->second)); 47021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 47031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 47041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 47051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 47061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 47071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 47081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 47091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 4710edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 47118c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 47121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 47131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 47141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 4715d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 47168c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Vector bool would be better, but vector<bool> is really slow. 47178c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner std::vector<unsigned char> SuccsHandled; 47188c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (TI->getNumSuccessors()) 47198c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled.resize(BB->getParent()->getNumBlockIDs()); 47208c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 4721532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman // Check successor nodes' PHI nodes that expect a constant to be available 4722532dc2e1f2473b16b48566c1cbc9eefe94a4e58eDan Gohman // from this block. 47231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 47241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 4725d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (!isa<PHINode>(SuccBB->begin())) continue; 47268c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB]; 4727d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 47288c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // If this terminator has multiple identical successors (common for 47298c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // switches), only handle each succ once. 47308c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned SuccMBBNo = SuccMBB->getNumber(); 47318c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (SuccsHandled[SuccMBBNo]) continue; 47328c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SuccsHandled[SuccMBBNo] = true; 47338c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 47348c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MachineBasicBlock::iterator MBBI = SuccMBB->begin(); 47351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 47361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 47371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 47381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 47391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 47401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 47418c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner (PN = dyn_cast<PHINode>(I)); ++I) { 47428c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Ignore dead phi's. 47438c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (PN->use_empty()) continue; 47448c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 47458c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned Reg; 47468c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 47473f7927c84c1b8c449378eaaf67eb9c563eb78949Chris Lattner 47488c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 47498c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner unsigned &RegOut = ConstantsOut[C]; 47508c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (RegOut == 0) { 47518c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner RegOut = FuncInfo.CreateRegForValue(C); 47528c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner UnorderedChains.push_back( 47538c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SDL.CopyValueToVirtualRegister(C, RegOut)); 47541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 47558c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = RegOut; 47568c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } else { 47578c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 47588c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner if (Reg == 0) { 47598c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner assert(isa<AllocaInst>(PHIOp) && 47608c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 47618c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner "Didn't codegen value into a register!??"); 47628c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 47638c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner UnorderedChains.push_back( 47648c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner SDL.CopyValueToVirtualRegister(PHIOp, Reg)); 47657e02151ce2686687446ba7293e66d6b096106e68Chris Lattner } 47661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 47678c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner 47688c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // Remember that this register needs to added to the machine PHI node as 47698c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner // the input for this MBB. 47708c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 47717f32156bb9c017b71971c52fac892fa7b9b06dd2Dan Gohman unsigned NumRegisters = TLI.getNumRegisters(VT); 4772b9f10196961ebe5b5573a5705048a5a8a6b56bb3Dan Gohman for (unsigned i = 0, e = NumRegisters; i != e; ++i) 47738c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 47748c494ab759266322aa05d5e99af9c05eb0d44576Chris Lattner } 47751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 47761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 47771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4778ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 47795a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 47807436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 47817436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 47827436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 47837436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 47847436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 47857436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 47867436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 47877436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 47887436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 47897436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 47907436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 47917436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 4792bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, 4793bd564bfc63163e31f320c3da9749db70992dc35eChris Lattner &UnorderedChains[0], UnorderedChains.size())); 4794ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 4795ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 47961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 4797f19f6bb31e45c5fc34b17d89d80ed938f61ff047Duncan Sands SDL.visit(*LLVMBB->getTerminator()); 4798a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 4799f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 480037efe6764568a3829fee26aba532283131d1a104Nate Begeman // lowering, as well as any jump table information. 4801f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 4802f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 48033a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JTCases.clear(); 48043a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JTCases = SDL.JTCases; 48054198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases.clear(); 48064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases = SDL.BitTestCases; 48074198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 4808a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 4809a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 4810c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer 4811c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // Check whether calls in this block are real tail calls. Fix up CALL nodes 4812c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // with correct tailcall attribute so that the target can rely on the tailcall 4813c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // attribute indicating whether the call is really eligible for tail call 4814c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer // optimization. 4815c85e1716f0e45e4c18a9ef2fbe431a51ac3a4252Arnold Schwaighofer CheckDAGForTailCallsAndFixThem(DAG, TLI); 48161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 48171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4818f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 4819417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DOUT << "Lowered selection DAG:\n"; 4820417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DEBUG(DAG.dump()); 4821417e11b9bf625b3626f8765d44248927fb200906Dan Gohman 4822af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 48235f43f92c69aae9837064cf08291db1b36a82789fDan Gohman DAG.Combine(false, *AA); 48242300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 4825417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DOUT << "Optimized lowered selection DAG:\n"; 48261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 4827f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 48281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 48291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 483001d029b82cb08367d81aa10cdc94d05360466649Chris Lattner#if 0 // Enable this some day. 483101d029b82cb08367d81aa10cdc94d05360466649Chris Lattner DAG.LegalizeTypes(); 483201d029b82cb08367d81aa10cdc94d05360466649Chris Lattner // Someday even later, enable a dag combine pass here. 483301d029b82cb08367d81aa10cdc94d05360466649Chris Lattner#endif 4834ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 4835f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4836832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Legalized selection DAG:\n"; 48371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 4838f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4839af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 48405f43f92c69aae9837064cf08291db1b36a82789fDan Gohman DAG.Combine(true, *AA); 48412300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 4842417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DOUT << "Optimized legalized selection DAG:\n"; 4843417e11b9bf625b3626f8765d44248927fb200906Dan Gohman DEBUG(DAG.dump()); 4844417e11b9bf625b3626f8765d44248927fb200906Dan Gohman 4845a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 4846552c4a849422ad91fa9988255ae35aebbf3acf7bEvan Cheng 4847a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 4848a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 48491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 4850f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4851832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling DOUT << "Selected machine code:\n"; 48521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 4853f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 4854f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4855f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 4856f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 4857f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 4858f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 485944c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 4860f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 4861f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4862f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 4863f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 4864f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 48651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4866f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 4867f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 4868f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 48694198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 48704198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Total amount of phi nodes to update: " 48714198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << PHINodesToUpdate.size() << "\n"; 48724198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DEBUG(for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) 48734198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov DOUT << "Node " << i << " : (" << PHINodesToUpdate[i].first 48744198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov << ", " << PHINodesToUpdate[i].second << ")\n";); 4875f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4876a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 48771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 48784198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (SwitchCases.empty() && JTCases.empty() && BitTestCases.empty()) { 4879f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 4880f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 4881f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 4882f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 48839ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[i].second, 48849ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 48859ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BB)); 4886f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 4887f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 48881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 48894198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 48904198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (unsigned i = 0, e = BitTestCases.size(); i != e; ++i) { 48914198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Lower header first, if it wasn't already lowered 48924198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (!BitTestCases[i].Emitted) { 48934198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SelectionDAG HSDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 48944198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurDAG = &HSDAG; 4895ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen SelectionDAGLowering HSDL(HSDAG, TLI, *AA, FuncInfo, GCI); 48964198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 48974198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BB = BitTestCases[i].Parent; 48984198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov HSDL.setCurrentBasicBlock(BB); 48994198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Emit the code 49004198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov HSDL.visitBitTestHeader(BitTestCases[i]); 49014198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov HSDAG.setRoot(HSDL.getRoot()); 49024198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CodeGenAndEmitDAG(HSDAG); 49034198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49044198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 49054198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (unsigned j = 0, ej = BitTestCases[i].Cases.size(); j != ej; ++j) { 49064198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov SelectionDAG BSDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 49074198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CurDAG = &BSDAG; 4908ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen SelectionDAGLowering BSDL(BSDAG, TLI, *AA, FuncInfo, GCI); 49094198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 49104198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BB = BitTestCases[i].Cases[j].ThisBB; 49114198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BSDL.setCurrentBasicBlock(BB); 49124198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Emit the code 49134198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (j+1 != ej) 49144198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BSDL.visitBitTestCase(BitTestCases[i].Cases[j+1].ThisBB, 49154198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases[i].Reg, 49164198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases[i].Cases[j]); 49174198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov else 49184198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BSDL.visitBitTestCase(BitTestCases[i].Default, 49194198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases[i].Reg, 49204198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BitTestCases[i].Cases[j]); 49214198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 49224198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 49234198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov BSDAG.setRoot(BSDL.getRoot()); 49244198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov CodeGenAndEmitDAG(BSDAG); 49254198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49264198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 49274198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // Update PHI Nodes 49284198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 49294198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineInstr *PHI = PHINodesToUpdate[pi].first; 49304198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock *PHIBB = PHI->getParent(); 49314198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov assert(PHI->getOpcode() == TargetInstrInfo::PHI && 49324198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov "This is not a machine PHI node that we are updating!"); 49334198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // This is "default" BB. We have two jumps to it. From "header" BB and 49344198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // from last "case" BB. 49354198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (PHIBB == BitTestCases[i].Default) { 49369ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[pi].second, 49379ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 49389ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BitTestCases[i].Parent)); 49399ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[pi].second, 49409ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 49419ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BitTestCases[i].Cases. 49429ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner back().ThisBB)); 49434198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49444198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // One of "cases" BB. 49454198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov for (unsigned j = 0, ej = BitTestCases[i].Cases.size(); j != ej; ++j) { 49464198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov MachineBasicBlock* cBB = BitTestCases[i].Cases[j].ThisBB; 49474198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov if (cBB->succ_end() != 49484198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov std::find(cBB->succ_begin(),cBB->succ_end(), PHIBB)) { 49499ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[pi].second, 49509ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 49519ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(cBB)); 49524198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49534198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49544198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49554198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49564198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov 49579453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 49589453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 49599453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 49603a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov for (unsigned i = 0, e = JTCases.size(); i != e; ++i) { 49613a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Lower header first, if it wasn't already lowered 49623a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (!JTCases[i].first.Emitted) { 49633a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAG HSDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 49643a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CurDAG = &HSDAG; 4965ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen SelectionDAGLowering HSDL(HSDAG, TLI, *AA, FuncInfo, GCI); 49663a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Set the current basic block to the mbb we wish to insert the code into 49673a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov BB = JTCases[i].first.HeaderBB; 49683a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov HSDL.setCurrentBasicBlock(BB); 49693a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov // Emit the code 49703a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov HSDL.visitJumpTableHeader(JTCases[i].second, JTCases[i].first); 49713a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov HSDAG.setRoot(HSDL.getRoot()); 49723a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CodeGenAndEmitDAG(HSDAG); 49734198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov } 49743a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 49753a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov SelectionDAG JSDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 49763a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CurDAG = &JSDAG; 4977ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen SelectionDAGLowering JSDL(JSDAG, TLI, *AA, FuncInfo, GCI); 497837efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 49793a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov BB = JTCases[i].second.MBB; 49803a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JSDL.setCurrentBasicBlock(BB); 498137efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 49823a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JSDL.visitJumpTable(JTCases[i].second); 49833a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov JSDAG.setRoot(JSDL.getRoot()); 49843a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov CodeGenAndEmitDAG(JSDAG); 49853a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov 498637efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 498737efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 498837efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 498937efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 499037efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 499137efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 49924198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // "default" BB. We can go there only from header BB. 49933a84b9baf67c938454840d10d9e53269c755cd3eAnton Korobeynikov if (PHIBB == JTCases[i].second.Default) { 49949ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[pi].second, 49959ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 49969ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(JTCases[i].first.HeaderBB)); 4997f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman } 49984198c58c716cbe4516ac3a1a407a3cd52548bc3bAnton Korobeynikov // JT BB. Just iterate over successors here 4999f4360a478944af45d5f851a0903fbbfa44f520dcNate Begeman if (BB->succ_end() != std::find(BB->succ_begin(),BB->succ_end(), PHIBB)) { 50009ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[pi].second, 50019ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 50029ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BB)); 500337efe6764568a3829fee26aba532283131d1a104Nate Begeman } 500437efe6764568a3829fee26aba532283131d1a104Nate Begeman } 500537efe6764568a3829fee26aba532283131d1a104Nate Begeman } 500637efe6764568a3829fee26aba532283131d1a104Nate Begeman 5007b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // If the switch block involved a branch to one of the actual successors, we 5008b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner // need to update PHI nodes in that block. 5009b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 5010b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner MachineInstr *PHI = PHINodesToUpdate[i].first; 5011b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner assert(PHI->getOpcode() == TargetInstrInfo::PHI && 5012b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner "This is not a machine PHI node that we are updating!"); 5013b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner if (BB->isSuccessor(PHI->getParent())) { 50149ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[i].second, 50159ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner false)); 50169ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner PHI->addOperand(MachineOperand::CreateMBB(BB)); 5017b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 5018b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner } 5019b2e806eecd85c98367f038817e742ef183dd9f87Chris Lattner 5020f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 5021f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 5022d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 502344c3b9fdd416c79f4b67cde1aecfced5921efd81Jim Laskey SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineModuleInfo>()); 5024f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 5025ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen SelectionDAGLowering SDL(SDAG, TLI, *AA, FuncInfo, GCI); 5026d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 5027f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 5028f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 5029f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 5030d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 5031f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 5032f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 5033f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 5034f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 5035d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 5036d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Handle any PHI nodes in successors of this chunk, as if we were coming 5037d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // from the original BB before switch expansion. Note that PHI nodes can 5038d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // occur multiple times in PHINodesToUpdate. We have to be very careful to 5039d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // handle them the right number of times. 504057ab65972e09be54da6461e483664ebf34afa1eeChris Lattner while ((BB = SwitchCases[i].TrueBB)) { // Handle LHS and RHS. 5041d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (MachineBasicBlock::iterator Phi = BB->begin(); 5042d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner Phi != BB->end() && Phi->getOpcode() == TargetInstrInfo::PHI; ++Phi){ 5043d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // This value for this PHI node is recorded in PHINodesToUpdate, get it. 5044d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner for (unsigned pn = 0; ; ++pn) { 5045d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner assert(pn != PHINodesToUpdate.size() && "Didn't find PHI entry!"); 5046d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner if (PHINodesToUpdate[pn].first == Phi) { 50479ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner Phi->addOperand(MachineOperand::CreateReg(PHINodesToUpdate[pn]. 50489ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner second, false)); 50499ce2e9d5a07cb3e0176cb32838231243829d67c5Chris Lattner Phi->addOperand(MachineOperand::CreateMBB(SwitchCases[i].ThisBB)); 5050d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner break; 5051d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 5052d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner } 5053f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 5054d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 5055d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // Don't process RHS if same block as LHS. 505657ab65972e09be54da6461e483664ebf34afa1eeChris Lattner if (BB == SwitchCases[i].FalseBB) 505757ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 5058d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner 5059d5e93c07957844e3086fb12d686b93dbbd2524c2Chris Lattner // If we haven't handled the RHS, do so now. Otherwise, we're done. 50602452595927a19a84ab20f012f1e2414a18f65ffbChris Lattner SwitchCases[i].TrueBB = SwitchCases[i].FalseBB; 506157ab65972e09be54da6461e483664ebf34afa1eeChris Lattner SwitchCases[i].FalseBB = 0; 5062f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 506357ab65972e09be54da6461e483664ebf34afa1eeChris Lattner assert(SwitchCases[i].TrueBB == 0 && SwitchCases[i].FalseBB == 0); 5064a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 50651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 5066a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 506713ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 5068a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 5069a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 5070a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 5071a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 5072a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 507313ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 5074eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey RegisterScheduler::FunctionPassCtor Ctor = RegisterScheduler::getDefault(); 507513ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 507613ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey if (!Ctor) { 5077eb577ba3b815a1fa4627b060dd2345d17abf672dJim Laskey Ctor = ISHeuristic; 50789373beba6010dd34316a801c3a9b37ab9e048031Jim Laskey RegisterScheduler::setDefault(Ctor); 50794ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 508013ec702c430b91ee49b9e6d9581cd95412f216c8Jim Laskey 50819ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey ScheduleDAG *SL = Ctor(this, &DAG, BB); 5082a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 50833e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohman 50843e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohman if (ViewSUnitDAGs) SL->viewGraph(); 50853e1a7aef17575d9c7058a035449d57e3c7295ed0Dan Gohman 5086cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 5087a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 50880e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 508903fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 50909ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim LaskeyHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 50919ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey return new HazardRecognizer(); 50929ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey} 50939ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 5094755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 5095755480681c795d585c73556c028b6143c46bda86Chris Lattner// Helper functions used by the generated instruction selector. 5096755480681c795d585c73556c028b6143c46bda86Chris Lattner//===----------------------------------------------------------------------===// 5097755480681c795d585c73556c028b6143c46bda86Chris Lattner// Calls to these methods are generated by tblgen. 5098755480681c795d585c73556c028b6143c46bda86Chris Lattner 5099755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckAndMask - The isel is trying to match something like (and X, 255). If 5100755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 5101755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an AND, and DesiredMaskS is the value 5102755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 5103755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckAndMask(SDOperand LHS, ConstantSDNode *RHS, 5104dc9b3d0bb5ed3a3f59cad61e264f0ec43c946459Dan Gohman int64_t DesiredMaskS) const { 5105755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 5106755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 5107755480681c795d585c73556c028b6143c46bda86Chris Lattner 5108755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 5109755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 5110755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 5111755480681c795d585c73556c028b6143c46bda86Chris Lattner 5112755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 5113755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 5114755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 5115755480681c795d585c73556c028b6143c46bda86Chris Lattner 5116755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 5117755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 5118755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 5119ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman if (CurDAG->MaskedValueIsZero(LHS, NeededMask)) 5120755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 5121755480681c795d585c73556c028b6143c46bda86Chris Lattner 5122755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 5123755480681c795d585c73556c028b6143c46bda86Chris Lattner 5124755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 5125755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 5126755480681c795d585c73556c028b6143c46bda86Chris Lattner} 5127755480681c795d585c73556c028b6143c46bda86Chris Lattner 5128755480681c795d585c73556c028b6143c46bda86Chris Lattner/// CheckOrMask - The isel is trying to match something like (or X, 255). If 5129755480681c795d585c73556c028b6143c46bda86Chris Lattner/// the dag combiner simplified the 255, we still want to match. RHS is the 5130755480681c795d585c73556c028b6143c46bda86Chris Lattner/// actual value in the DAG on the RHS of an OR, and DesiredMaskS is the value 5131755480681c795d585c73556c028b6143c46bda86Chris Lattner/// specified in the .td file (e.g. 255). 5132755480681c795d585c73556c028b6143c46bda86Chris Lattnerbool SelectionDAGISel::CheckOrMask(SDOperand LHS, ConstantSDNode *RHS, 5133dc9b3d0bb5ed3a3f59cad61e264f0ec43c946459Dan Gohman int64_t DesiredMaskS) const { 5134755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t ActualMask = RHS->getValue(); 5135755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t DesiredMask =DesiredMaskS & MVT::getIntVTBitMask(LHS.getValueType()); 5136755480681c795d585c73556c028b6143c46bda86Chris Lattner 5137755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual mask exactly matches, success! 5138755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask == DesiredMask) 5139755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 5140755480681c795d585c73556c028b6143c46bda86Chris Lattner 5141755480681c795d585c73556c028b6143c46bda86Chris Lattner // If the actual AND mask is allowing unallowed bits, this doesn't match. 5142755480681c795d585c73556c028b6143c46bda86Chris Lattner if (ActualMask & ~DesiredMask) 5143755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 5144755480681c795d585c73556c028b6143c46bda86Chris Lattner 5145755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, the DAG Combiner may have proven that the value coming in is 5146755480681c795d585c73556c028b6143c46bda86Chris Lattner // either already zero or is not demanded. Check for known zero input bits. 5147755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t NeededMask = DesiredMask & ~ActualMask; 5148755480681c795d585c73556c028b6143c46bda86Chris Lattner 5149755480681c795d585c73556c028b6143c46bda86Chris Lattner uint64_t KnownZero, KnownOne; 5150ea859be53ca13a1547c4675549946b74dc3c6f41Dan Gohman CurDAG->ComputeMaskedBits(LHS, NeededMask, KnownZero, KnownOne); 5151755480681c795d585c73556c028b6143c46bda86Chris Lattner 5152755480681c795d585c73556c028b6143c46bda86Chris Lattner // If all the missing bits in the or are already known to be set, match! 5153755480681c795d585c73556c028b6143c46bda86Chris Lattner if ((NeededMask & KnownOne) == NeededMask) 5154755480681c795d585c73556c028b6143c46bda86Chris Lattner return true; 5155755480681c795d585c73556c028b6143c46bda86Chris Lattner 5156755480681c795d585c73556c028b6143c46bda86Chris Lattner // TODO: check to see if missing bits are just not demanded. 5157755480681c795d585c73556c028b6143c46bda86Chris Lattner 5158755480681c795d585c73556c028b6143c46bda86Chris Lattner // Otherwise, this pattern doesn't match. 5159755480681c795d585c73556c028b6143c46bda86Chris Lattner return false; 5160755480681c795d585c73556c028b6143c46bda86Chris Lattner} 5161755480681c795d585c73556c028b6143c46bda86Chris Lattner 51629ff542f2cce5bf7bf3cf9f692cf3ec0690ad2b3bJim Laskey 51630e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 51640e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 51650e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 51660e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 51670e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 51680e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 51690e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 51700e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 51710e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 51720e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 51730e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 51740e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 51750e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 51760e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 51770e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 51780e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 51790e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 51800e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 51810e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 51820e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 51830e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 51840e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 51850e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 51860e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 51870e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 5188832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendling cerr << "Could not match memory address. Inline asm failure!\n"; 51890e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 51900e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 51910e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 51920e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 51934b993b19f9837fdf2db55a3e042e8adab3d63c26Chris Lattner MVT::ValueType IntPtrTy = DAG.getTargetLoweringInfo().getPointerTy(); 519436d439666c9f9f781d57dc2fd6d3cc80602fe095Chris Lattner Ops.push_back(DAG.getTargetConstant(4/*MEM*/ | (SelOps.size() << 3), 51954b993b19f9837fdf2db55a3e042e8adab3d63c26Chris Lattner IntPtrTy)); 51960e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 51970e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 51980e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 51990e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 52000e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 52010e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 52020e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 52030e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 52040e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 5205794fd75c67a2cdc128d67342c6d88a504d186896Devang Patel 52061997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patelchar SelectionDAGISel::ID = 0; 5207