SelectionDAGISel.cpp revision 3b0d286d0085fbf8314d9f5510c2f78558ab5dea
11c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 31c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// The LLVM Compiler Infrastructure 41c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 51c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This file was developed by the LLVM research group and is distributed under 61c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// the University of Illinois Open Source License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 81c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 91c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// This implements the SelectionDAGISel class. 111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner// 121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define DEBUG_TYPE "isel" 151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAGISel.h" 16a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng#include "llvm/CodeGen/ScheduleDAG.h" 17adf6a965a321372c640845407195594835921eb4Chris Lattner#include "llvm/CallingConv.h" 181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Constants.h" 191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/DerivedTypes.h" 201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Function.h" 2136ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner#include "llvm/GlobalVariable.h" 22ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner#include "llvm/InlineAsm.h" 231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instructions.h" 241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Intrinsics.h" 2543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey#include "llvm/IntrinsicInst.h" 26b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner#include "llvm/CodeGen/IntrinsicLowering.h" 27b2efb853f00d45b1c8d57f92acd0028fbdeffda6Jim Laskey#include "llvm/CodeGen/MachineDebugInfo.h" 281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 3037efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 34fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 40495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 417944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#include "llvm/Support/CommandLine.h" 427c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 454e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner#include <set> 461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 477e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 50da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 517944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 52a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 53a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 54a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 55a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 56a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 577944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 585e46a19ec848cd4fc9649bd5170c43d9e657668cChris Lattnerstatic const bool ViewISelDAGs = 0, ViewSchedDAGs = 0; 597944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#endif 607944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner 6120a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner// Scheduling heuristics 6220a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattnerenum SchedHeuristics { 6320a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner defaultScheduling, // Let the target specify its preference. 6420a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner noScheduling, // No scheduling, emit breadth first sequence. 6520a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner simpleScheduling, // Two pass, min. critical path, max. utilization. 6620a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner simpleNoItinScheduling, // Same as above exact using generic latency. 6720a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner listSchedulingBURR, // Bottom up reg reduction list scheduling. 6820a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner listSchedulingTD // Top-down list scheduler. 6920a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner}; 7020a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner 714ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Chengnamespace { 724ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng cl::opt<SchedHeuristics> 734ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng ISHeuristic( 744ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "sched", 754ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng cl::desc("Choose scheduling style"), 763f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng cl::init(defaultScheduling), 774ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng cl::values( 783f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng clEnumValN(defaultScheduling, "default", 793f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng "Target preferred scheduling style"), 804ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValN(noScheduling, "none", 8117d52f723421ce28d1b9fe2fc058366ed43ec094Jim Laskey "No scheduling: breadth first sequencing"), 824ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValN(simpleScheduling, "simple", 834ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "Simple two pass scheduling: minimize critical path " 844ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "and maximize processor utilization"), 854ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValN(simpleNoItinScheduling, "simple-noitin", 864ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "Simple two pass scheduling: Same as simple " 874ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng "except using generic latency"), 883f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng clEnumValN(listSchedulingBURR, "list-burr", 89f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng "Bottom up register reduction list scheduling"), 9003fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner clEnumValN(listSchedulingTD, "list-td", 9103fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner "Top-down list scheduler"), 924ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng clEnumValEnd)); 934ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng} // namespace 944ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 95864635ad7b3046d3042311423071152c613961deChris Lattnernamespace { 96864635ad7b3046d3042311423071152c613961deChris Lattner /// RegsForValue - This struct represents the physical registers that a 97864635ad7b3046d3042311423071152c613961deChris Lattner /// particular value is assigned and the type information about the value. 98864635ad7b3046d3042311423071152c613961deChris Lattner /// This is needed because values can be promoted into larger registers and 99864635ad7b3046d3042311423071152c613961deChris Lattner /// expanded into multiple smaller registers than the value. 100864635ad7b3046d3042311423071152c613961deChris Lattner struct RegsForValue { 101864635ad7b3046d3042311423071152c613961deChris Lattner /// Regs - This list hold the register (for legal and promoted values) 102864635ad7b3046d3042311423071152c613961deChris Lattner /// or register set (for expanded values) that the value should be assigned 103864635ad7b3046d3042311423071152c613961deChris Lattner /// to. 104864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 105864635ad7b3046d3042311423071152c613961deChris Lattner 106864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT - The value type of each register. 107864635ad7b3046d3042311423071152c613961deChris Lattner /// 108864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 109864635ad7b3046d3042311423071152c613961deChris Lattner 110864635ad7b3046d3042311423071152c613961deChris Lattner /// ValueVT - The value type of the LLVM value, which may be promoted from 111864635ad7b3046d3042311423071152c613961deChris Lattner /// RegVT or made from merging the two expanded parts. 112864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT; 113864635ad7b3046d3042311423071152c613961deChris Lattner 114864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue() : RegVT(MVT::Other), ValueVT(MVT::Other) {} 115864635ad7b3046d3042311423071152c613961deChris Lattner 116864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(unsigned Reg, MVT::ValueType regvt, MVT::ValueType valuevt) 117864635ad7b3046d3042311423071152c613961deChris Lattner : RegVT(regvt), ValueVT(valuevt) { 118864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 119864635ad7b3046d3042311423071152c613961deChris Lattner } 120864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue(const std::vector<unsigned> ®s, 121864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType regvt, MVT::ValueType valuevt) 122864635ad7b3046d3042311423071152c613961deChris Lattner : Regs(regs), RegVT(regvt), ValueVT(valuevt) { 123864635ad7b3046d3042311423071152c613961deChris Lattner } 124864635ad7b3046d3042311423071152c613961deChris Lattner 125864635ad7b3046d3042311423071152c613961deChris Lattner /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from 126864635ad7b3046d3042311423071152c613961deChris Lattner /// this value and returns the result as a ValueVT value. This uses 127864635ad7b3046d3042311423071152c613961deChris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 128864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand getCopyFromRegs(SelectionDAG &DAG, 1299f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const; 130c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 131c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 132c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// specified value into the registers specified by this object. This uses 133c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// Chain/Flag as the input and updates them for the output Chain/Flag. 134c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 1359f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const; 136c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 137c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// AddInlineAsmOperands - Add this value to the specified inlineasm node 138c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// operand list. This adds the code marker and includes the number of 139c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner /// values added into it. 140c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner void AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 1419f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const; 142864635ad7b3046d3042311423071152c613961deChris Lattner }; 143864635ad7b3046d3042311423071152c613961deChris Lattner} 1444ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 1451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 1461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner //===--------------------------------------------------------------------===// 1471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FunctionLoweringInfo - This contains information that is global to a 1481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// function that is used when lowering a region of the function. 149f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner class FunctionLoweringInfo { 150f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner public: 1511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 1521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Function &Fn; 1531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF; 1541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SSARegMap *RegMap; 1551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF); 1571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// MBBMap - A mapping from LLVM basic blocks to their machine code entry. 1591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const BasicBlock*, MachineBasicBlock *> MBBMap; 1601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// ValueMap - Since we emit code for the function a basic block at a time, 1621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// we must remember which virtual registers hold the values for 1631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// cross-basic-block values. 1641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, unsigned> ValueMap; 1651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in 1671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// the entry block. This allows the allocas to be efficiently referenced 1681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// anywhere in the function. 1691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const AllocaInst*, int> StaticAllocaMap; 1701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned MakeReg(MVT::ValueType VT) { 1721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 1731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 174edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1753c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned CreateRegForValue(const Value *V); 1763c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 1771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned InitializeRegForValue(const Value *V) { 1781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned &R = ValueMap[V]; 1791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(R == 0 && "Already initialized this value register!"); 1801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return R = CreateRegForValue(V); 1811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner }; 1831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by 186f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// PHI nodes or outside of the basic block that defines it, or used by a 187f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// switch instruction, which may expand to multiple basic blocks. 1881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerstatic bool isUsedOutsideOfDefiningBlock(Instruction *I) { 1891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (isa<PHINode>(I)) return true; 1901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *BB = I->getParent(); 1911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) 192f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI) || 193f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman isa<SwitchInst>(*UI)) 1941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 1951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return false; 1961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 1971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 198bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner/// isOnlyUsedInEntryBlock - If the specified argument is only used in the 199f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// entry block, return true. This includes arguments used by switches, since 200f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the switch may expand into multiple basic blocks. 201bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattnerstatic bool isOnlyUsedInEntryBlock(Argument *A) { 202bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner BasicBlock *Entry = A->getParent()->begin(); 203bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI) 204f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (cast<Instruction>(*UI)->getParent() != Entry || isa<SwitchInst>(*UI)) 205bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return false; // Use not in entry block. 206bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner return true; 207bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner} 208bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris LattnerFunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli, 210edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman Function &fn, MachineFunction &mf) 2111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) { 2121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 213bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Create a vreg for each argument register that is not dead and is used 214bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // outside of the entry block for the function. 21516ce0df92717cd1474029d87efe596d000dc2caaChris Lattner for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end(); 21616ce0df92717cd1474029d87efe596d000dc2caaChris Lattner AI != E; ++AI) 217bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!isOnlyUsedInEntryBlock(AI)) 218bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner InitializeRegForValue(AI); 2191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 220bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Initialize the mapping of values to registers. This is only set up for 221bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // instruction values that are used outside of the block that defines 222bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // them. 2232aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen Function::iterator BB = Fn.begin(), EB = Fn.end(); 2241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) 2261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) { 2271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = AI->getAllocatedType(); 2281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 229ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = 230ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 231ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman AI->getAlignment()); 232a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner 233a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // If the alignment of the value is smaller than the size of the value, 234a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // and if the size of the value is particularly small (<= 8 bytes), 235a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // round up to the size of the value for potentially better performance. 236a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // 237a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // FIXME: This could be made better with a preferred alignment hook in 238a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner // TargetData. It serves primarily to 8-byte align doubles for X86. 239a8217e3000b5b01c4a95316aef078a9d02a9a119Chris Lattner if (Align < TySize && TySize <= 8) Align = TySize; 2402dfa8192abaad8a3c29132dba50e8b85218e918cChris Lattner TySize *= CUI->getValue(); // Get total allocated size. 241d222f6ab67472fa2b2e211172a11b43905aa9445Chris Lattner if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects. 2421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner StaticAllocaMap[AI] = 243f26bc8ef4827cf0023a7052b62b920b41813d473Chris Lattner MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align); 2441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2462aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (; BB != EB; ++BB) 2472aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 2481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I)) 2491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (!isa<AllocaInst>(I) || 2501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner !StaticAllocaMap.count(cast<AllocaInst>(I))) 2511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InitializeRegForValue(I); 2521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This 2541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // also creates the initial PHI MachineInstrs, though none of the input 2551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // operands are populated. 2562aeaf4e839438d51766996006fc22310d05ab2a7Jeff Cohen for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) { 2571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *MBB = new MachineBasicBlock(BB); 2581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MBBMap[BB] = MBB; 2591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MF.getBasicBlockList().push_back(MBB); 2601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Create Machine PHI nodes for LLVM PHI nodes, lowering them as 2621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // appropriate. 2631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 2641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = BB->begin(); 265f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 266f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 26770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 26870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NumElements; 26970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) 27070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner NumElements = TLI.getNumElements(VT); 27170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else { 27270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType VT1,VT2; 27370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner NumElements = 27470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 27570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner VT1, VT2); 27670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 277f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 278f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 279f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 280f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 281f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2853c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// CreateRegForValue - Allocate the appropriate number of virtual registers of 2863c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// the correctly promoted or expanded types. Assign these registers 2873c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// consecutive vreg numbers and return the first assigned number. 2883c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattnerunsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) { 2893c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 2903c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 2913c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The number of multiples of registers that we need, to, e.g., split up 2923c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // a <2 x int64> -> 4 x i32 registers. 2933c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumVectorRegs = 1; 2943c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 2953c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a packed type, figure out what type it will decompose into 2963c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // and how many of the elements it will use. 2973c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (VT == MVT::Vector) { 2983c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner const PackedType *PTy = cast<PackedType>(V->getType()); 2993c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumElts = PTy->getNumElements(); 3003c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType EltTy = TLI.getValueType(PTy->getElementType()); 3013c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3023c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // Divide the input until we get to a supported size. This will always 3033c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // end with a scalar if the target doesn't support vectors. 3043c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (NumElts > 1 && !TLI.isTypeLegal(getVectorType(EltTy, NumElts))) { 3053c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumElts >>= 1; 3063c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumVectorRegs <<= 1; 3073c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3086cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner if (NumElts == 1) 3096cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = EltTy; 3106cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner else 3116cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = getVectorType(EltTy, NumElts); 3123c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3133c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3143c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The common case is that we will only create one register for this 3153c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // value. If we have that case, create and return the virtual register. 3163c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NV = TLI.getNumElements(VT); 3173c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (NV == 1) { 3183c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If we are promoting this value, pick the next largest supported type. 3193c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType PromotedType = TLI.getTypeToTransformTo(VT); 3203c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned Reg = MakeReg(PromotedType); 3213c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a vector of supported or promoted types (e.g. 4 x i16), 3223c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // create all of the registers. 3233c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NumVectorRegs; ++i) 3243c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg(PromotedType); 3253c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return Reg; 3263c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3273c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3283c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this value is represented with multiple target registers, make sure 3293c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // to create enough consecutive registers of the right (smaller) type. 3303c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NT = VT-1; // Find the type to use. 3313c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 3323c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner --NT; 3333c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3343c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 3353c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NV*NumVectorRegs; ++i) 3363c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg((MVT::ValueType)NT); 3373c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return R; 3383c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner} 3391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 3411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 3421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 3431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 3441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 3451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 3461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 3471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 3481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 3501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 351d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 352d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 353d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 354d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 355d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 356d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 357f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Case - A pair of values to record the Value for a switch case, and the 358f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// case's target basic block. 359f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<Constant*, MachineBasicBlock*> Case; 360f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::vector<Case>::iterator CaseItr; 361f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<CaseItr, CaseItr> CaseRange; 362f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 363f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseRec - A struct with ctor used in lowering switches to a binary tree 364f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// of conditional branches. 365f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseRec { 366f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec(MachineBasicBlock *bb, Constant *lt, Constant *ge, CaseRange r) : 367f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseBB(bb), LT(lt), GE(ge), Range(r) {} 368f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 369f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseBB - The MBB in which to emit the compare and branch 370f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *CaseBB; 371f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// LT, GE - If nonzero, we know the current case value must be less-than or 372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// greater-than-or-equal-to these Constants. 373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *LT; 374f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *GE; 375f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Range - A pair of iterators representing the range of case values to be 376f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// processed at this point in the binary search tree. 377f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange Range; 378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 379f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 380f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// The comparison function for sorting Case values. 381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman bool operator () (const Case& C1, const Case& C2) { 383f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (const ConstantUInt* U1 = dyn_cast<const ConstantUInt>(C1.first)) 384f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return U1->getValue() < cast<const ConstantUInt>(C2.first)->getValue(); 385f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 386f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const ConstantSInt* S1 = dyn_cast<const ConstantSInt>(C1.first); 387f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return S1->getValue() < cast<const ConstantSInt>(C2.first)->getValue(); 388f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 389f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 390f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 3921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 3931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 3941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 3951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 3961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 3971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const TargetData &TD; 3981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 399f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 400f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 401f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 40237efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGISel::JumpTable JT; 403f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 4051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 4061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 4071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 409edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 4101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 4119453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT(0,0,0,0), FuncInfo(funcinfo) { 4121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 414a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 415a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 416a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 417d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 418d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 419edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 420d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 421d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 422d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 423d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 424d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 425d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 426d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 427d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 428d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads); 429d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 430d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 431d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 432a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 433a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 4341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 45028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand SrcValue, SDOperand Root, 45128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile); 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 4551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 457199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 4601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4644e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 465864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue GetRegistersForValue(const std::string &ConstrCode, 466864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, 467864635ad7b3046d3042311423071152c613961deChris Lattner bool OutReg, bool InReg, 468864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 469864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &InputRegs); 470f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 474f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 4751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 4761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 477f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Helper for visitSwitch 478f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 47937efe6764568a3829fee26aba532283131d1a104Nate Begeman void visitJumpTable(SelectionDAGISel::JumpTable &JT); 480f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 4821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 4831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4855fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitBinary(User &I, unsigned IntOp, unsigned FPOp, unsigned VecOp); 486e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 4875fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 4885fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::ADD, ISD::FADD, ISD::VADD); 48901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 490b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 4915fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitMul(User &I) { 4925fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::MUL, ISD::FMUL, ISD::VMUL); 49301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 4941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 49501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 4963e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng visitBinary(I, 4973e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng Ty->isSigned() ? ISD::SDIV : ISD::UDIV, ISD::FDIV, 4983e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng Ty->isSigned() ? ISD::VSDIV : ISD::VUDIV); 4991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 50101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 5025fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SREM : ISD::UREM, ISD::FREM, 0); 5031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5043e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitAnd(User &I) { visitBinary(I, ISD::AND, 0, ISD::VAND); } 5053e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitOr (User &I) { visitBinary(I, ISD::OR, 0, ISD::VOR); } 5063e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitXor(User &I) { visitBinary(I, ISD::XOR, 0, ISD::VXOR); } 507e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShl(User &I) { visitShift(I, ISD::SHL); } 508e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShr(User &I) { 509e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman visitShift(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 5101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc); 5131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); } 5141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); } 5151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); } 5161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); } 5171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); } 5181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); } 5191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5202bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5212bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 5223e104b11168da4692b69cc6b236c1da22adff959Chris Lattner void visitShuffleVector(User &I); 523c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 5261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 535ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner void visitInlineAsm(CallInst &I); 536c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 5370eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 5381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 5401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 5411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 5421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 54339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5457041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 5461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 5481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 5491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 5521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 5531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 5561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 5571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 558199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 559199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 560199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 561199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 562199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 563199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 564199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 565199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 566199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 567199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 568199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 569199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 570199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 571199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 572199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 573199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 57423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner if (!isa<PackedType>(VTy)) 57523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 57623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 577b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR of undef nodes. 57823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner const PackedType *PTy = cast<PackedType>(VTy); 57923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 58023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 58123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 58223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner std::vector<SDOperand> Ops; 58323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 58423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 58523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 58623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 58723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 588b2827b0901162169bb2692b77a839c9767849134Chris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, Ops); 589199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 590199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 591199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (const PackedType *PTy = dyn_cast<PackedType>(VTy)) { 592199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 593199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 594199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 595199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 596199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 597199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // the packed constant. 598199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::vector<SDOperand> Ops; 599199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) { 6002bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 6012bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 602199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 603199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 604199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 605199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 606199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 607199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 608199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 609199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 610199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 611199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 612b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR node with generic Vector type. 61323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 61423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 615b2827b0901162169bb2692b77a839c9767849134Chris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, Ops); 616199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 617199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 618199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 619199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 620199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 621199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 622199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 623199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 624199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 625199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 626199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 627199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 628199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 629199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 630199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.ValueMap.find(V); 631199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 632199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 633199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned InReg = VMI->second; 634199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 635199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // If this type is not legal, make it so now. 63670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (VT != MVT::Vector) { 63770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 638199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 63970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 64070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (DestVT < VT) { 64170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Source must be expanded. This input value is actually coming from the 64270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // register pair VMI->second and VMI->second+1. 64370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 64470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 64570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (DestVT > VT) { // Promotion case 646199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(VT)) 647199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::FP_ROUND, VT, N); 648199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 649199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::TRUNCATE, VT, N); 650199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 65170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 65270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Otherwise, if this is a vector, make it available as a generic vector 65370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // here. 65470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 6552e2ef9535070bb352601482cceac1140c1158cddChris Lattner const PackedType *PTy = cast<PackedType>(VTy); 6562e2ef9535070bb352601482cceac1140c1158cddChris Lattner unsigned NE = TLI.getPackedTypeBreakdown(PTy, PTyElementVT, 65770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyLegalElementVT); 65870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 65970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Build a VBUILD_VECTOR with the input registers. 66070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner std::vector<SDOperand> Ops; 66170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 66270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the value types are legal, just VBUILD the CopyFromReg nodes. 66370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) 66470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 66570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT)); 66670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyElementVT < PTyLegalElementVT) { 66770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was promoted, use TRUNCATE of FP_ROUND as appropriate. 66870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 66970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 67070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 67170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyElementVT)) 67270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::FP_ROUND, PTyElementVT, Op); 67370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 67470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::TRUNCATE, PTyElementVT, Op); 67570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(Op); 67670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 67770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 67870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // If the register was expanded, use BUILD_PAIR. 67970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner assert((NE & 1) == 0 && "Must expand into a multiple of 2 elements!"); 68070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE/2; ++i) { 68170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op0 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 68270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 68370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Op1 = DAG.getCopyFromReg(DAG.getEntryNode(), InReg++, 68470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT); 68570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Op0, Op1)); 68670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 68770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 68870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 68970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getConstant(NE, MVT::i32)); 69070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Ops.push_back(DAG.getValueType(PTyLegalElementVT)); 69170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, Ops); 6922e2ef9535070bb352601482cceac1140c1158cddChris Lattner 6932e2ef9535070bb352601482cceac1140c1158cddChris Lattner // Finally, use a VBIT_CONVERT to make this available as the appropriate 6942e2ef9535070bb352601482cceac1140c1158cddChris Lattner // vector type. 6952e2ef9535070bb352601482cceac1140c1158cddChris Lattner N = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, N, 6962e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getConstant(PTy->getNumElements(), 6972e2ef9535070bb352601482cceac1140c1158cddChris Lattner MVT::i32), 6982e2ef9535070bb352601482cceac1140c1158cddChris Lattner DAG.getValueType(TLI.getValueType(PTy->getElementType()))); 699199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 700199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 701199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 702199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 703199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 704199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 7051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 7061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 707a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 7081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 7091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 710ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman std::vector<SDOperand> NewValues; 711ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 712ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 713ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 714ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman 715ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // If this is an integer return value, we need to promote it ourselves to 716ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // the full width of a register, since LegalizeOp will use ANY_EXTEND rather 717ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // than sign/zero. 718ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (MVT::isInteger(RetOp.getValueType()) && 719ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp.getValueType() < MVT::i64) { 720ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman MVT::ValueType TmpVT; 721ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 722ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = TLI.getTypeToTransformTo(MVT::i32); 723ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 724ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = MVT::i32; 7251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 726ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (I.getOperand(i)->getType()->isSigned()) 727ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, RetOp); 728ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 729ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, RetOp); 730ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 731ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(RetOp); 7321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 733ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, NewValues)); 7341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 7371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 7381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 739f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(Succ0MBB); 7401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 7421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 7431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 7441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 7451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 7461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 7481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 7491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 750a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 751dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 7521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 7531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 754f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(Succ1MBB); 7551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 7571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 7581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 7591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 760a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 761dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ0MBB))); 7621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 7631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 7641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 7651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 7661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 767a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 768dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ1MBB))); 7691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 770e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 771e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 772298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // If the false case is the current basic block, then this is a self 773298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // loop. We do not want to emit "Loop: ... brcond Out; br Loop", as it 774298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // adds an extra instruction in the loop. Instead, invert the 775298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // condition and emit "Loop: ... br!cond Loop; br Out. 776298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng if (CurMBB == Succ1MBB) { 777298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng std::swap(Succ0MBB, Succ1MBB); 778298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng SDOperand True = DAG.getConstant(1, Cond.getValueType()); 779298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 780298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng } 78181e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman SDOperand True = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 78281e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.getBasicBlock(Succ0MBB)); 78381e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, True, 78481e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.getBasicBlock(Succ1MBB))); 7851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 789f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 790f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 791f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 792f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand SwitchOp = getValue(CB.SwitchV); 793f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand CaseOp = getValue(CB.CaseC); 794f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand Cond = DAG.getSetCC(MVT::i1, SwitchOp, CaseOp, CB.CC); 795f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 796f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 797f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 798f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 799f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 800f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 801f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 802f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 803f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 804f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 805f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CB.LHSBB == NextBlock) { 806f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::swap(CB.LHSBB, CB.RHSBB); 807f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 808f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 809f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 810f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 811f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(CB.LHSBB)); 812f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CB.RHSBB == NextBlock) 813f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 814f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 815f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 816f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(CB.RHSBB))); 817f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 818f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(CB.LHSBB); 819f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(CB.RHSBB); 820f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 821f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 82237efe6764568a3829fee26aba532283131d1a104Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 82337efe6764568a3829fee26aba532283131d1a104Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 82437efe6764568a3829fee26aba532283131d1a104Nate Begemanvoid SelectionDAGLowering::visitJumpTable(SelectionDAGISel::JumpTable &JT) { 82537efe6764568a3829fee26aba532283131d1a104Nate Begeman // FIXME: Need to emit different code for PIC vs. Non-PIC, specifically, 82637efe6764568a3829fee26aba532283131d1a104Nate Begeman // we need to add the address of the jump table to the value loaded, since 82737efe6764568a3829fee26aba532283131d1a104Nate Begeman // the entries in the jump table will be differences rather than absolute 82837efe6764568a3829fee26aba532283131d1a104Nate Begeman // addresses. 82937efe6764568a3829fee26aba532283131d1a104Nate Begeman 83037efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code for the jump table 83137efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType PTy = TLI.getPointerTy(); 83237efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned PTyBytes = MVT::getSizeInBits(PTy)/8; 83337efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand Copy = DAG.getCopyFromReg(getRoot(), JT.Reg, PTy); 83437efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand IDX = DAG.getNode(ISD::MUL, PTy, Copy, 83537efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(PTyBytes, PTy)); 83637efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand ADD = DAG.getNode(ISD::ADD, PTy, IDX, DAG.getJumpTable(JT.JTI,PTy)); 83737efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand LD = DAG.getLoad(PTy, Copy.getValue(1), ADD, DAG.getSrcValue(0)); 83837efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRIND, MVT::Other, LD.getValue(1), LD)); 83937efe6764568a3829fee26aba532283131d1a104Nate Begeman 84037efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update successor info 84137efe6764568a3829fee26aba532283131d1a104Nate Begeman for (std::set<MachineBasicBlock*>::iterator ii = JT.SuccMBBs.begin(), 84237efe6764568a3829fee26aba532283131d1a104Nate Begeman ee = JT.SuccMBBs.end(); ii != ee; ++ii) 84337efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.MBB->addSuccessor(*ii); 84437efe6764568a3829fee26aba532283131d1a104Nate Begeman} 84537efe6764568a3829fee26aba532283131d1a104Nate Begeman 846f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitch(SwitchInst &I) { 847f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 848f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 849f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 850f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 851f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 852f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 853f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 854f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 855f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (I.getNumOperands() == 2) { 856f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 857f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[I.getDefaultDest()]; 858f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 859f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (DefaultMBB != NextBlock) 860f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 861f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(DefaultMBB))); 862f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 863f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 864f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 865f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 866f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 867f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 868f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<Case> Cases; 869f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 1; i < I.getNumSuccessors(); ++i) { 870f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *SMBB = FuncInfo.MBBMap[I.getSuccessor(i)]; 871f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cases.push_back(Case(I.getSuccessorValue(i), SMBB)); 872f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 873f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::sort(Cases.begin(), Cases.end(), CaseCmp()); 874f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 875f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 876f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 877f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 878f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Value *SV = I.getOperand(0); 879f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Default = FuncInfo.MBBMap[I.getDefaultDest()]; 88037efe6764568a3829fee26aba532283131d1a104Nate Begeman 88137efe6764568a3829fee26aba532283131d1a104Nate Begeman // Get the MachineFunction which holds the current MBB. This is used during 88237efe6764568a3829fee26aba532283131d1a104Nate Begeman // emission of jump tables, and when inserting any additional MBBs necessary 88337efe6764568a3829fee26aba532283131d1a104Nate Begeman // to represent the switch. 884f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction *CurMF = CurMBB->getParent(); 885f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const BasicBlock *LLVMBB = CurMBB->getBasicBlock(); 88637efe6764568a3829fee26aba532283131d1a104Nate Begeman Reloc::Model Relocs = TLI.getTargetMachine().getRelocationModel(); 88737efe6764568a3829fee26aba532283131d1a104Nate Begeman 88837efe6764568a3829fee26aba532283131d1a104Nate Begeman // If the switch has more than 3 blocks, and is 100% dense, then emit a jump 88937efe6764568a3829fee26aba532283131d1a104Nate Begeman // table rather than lowering the switch to a binary tree of conditional 89037efe6764568a3829fee26aba532283131d1a104Nate Begeman // branches. 89137efe6764568a3829fee26aba532283131d1a104Nate Begeman // FIXME: Make this work with 64 bit targets someday, possibly by always 89237efe6764568a3829fee26aba532283131d1a104Nate Begeman // doing differences there so that entries stay 32 bits. 89337efe6764568a3829fee26aba532283131d1a104Nate Begeman // FIXME: Make this work with PIC code 8949453eea49bca1c3904047db495855c93e001d1cdNate Begeman if (TLI.isOperationLegal(ISD::BRIND, TLI.getPointerTy()) && 89537efe6764568a3829fee26aba532283131d1a104Nate Begeman TLI.getPointerTy() == MVT::i32 && 89637efe6764568a3829fee26aba532283131d1a104Nate Begeman (Relocs == Reloc::Static || Relocs == Reloc::DynamicNoPIC) && 89737efe6764568a3829fee26aba532283131d1a104Nate Begeman Cases.size() > 3) { 89837efe6764568a3829fee26aba532283131d1a104Nate Begeman uint64_t First = cast<ConstantIntegral>(Cases.front().first)->getRawValue(); 89937efe6764568a3829fee26aba532283131d1a104Nate Begeman uint64_t Last = cast<ConstantIntegral>(Cases.back().first)->getRawValue(); 90037efe6764568a3829fee26aba532283131d1a104Nate Begeman 90137efe6764568a3829fee26aba532283131d1a104Nate Begeman // Determine density 90237efe6764568a3829fee26aba532283131d1a104Nate Begeman // FIXME: support sub-100% density 90337efe6764568a3829fee26aba532283131d1a104Nate Begeman if (((Last - First) + 1ULL) == (uint64_t)Cases.size()) { 90437efe6764568a3829fee26aba532283131d1a104Nate Begeman // Create a new basic block to hold the code for loading the address 90537efe6764568a3829fee26aba532283131d1a104Nate Begeman // of the jump table, and jumping to it. Update successor information; 90637efe6764568a3829fee26aba532283131d1a104Nate Begeman // we will either branch to the default case for the switch, or the jump 90737efe6764568a3829fee26aba532283131d1a104Nate Begeman // table. 90837efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *JumpTableBB = new MachineBasicBlock(LLVMBB); 90937efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMF->getBasicBlockList().insert(BBI, JumpTableBB); 91037efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(Default); 91137efe6764568a3829fee26aba532283131d1a104Nate Begeman CurMBB->addSuccessor(JumpTableBB); 91237efe6764568a3829fee26aba532283131d1a104Nate Begeman 91337efe6764568a3829fee26aba532283131d1a104Nate Begeman // Subtract the lowest switch case value from the value being switched on 91437efe6764568a3829fee26aba532283131d1a104Nate Begeman // and conditional branch to default mbb if the result is greater than the 91537efe6764568a3829fee26aba532283131d1a104Nate Begeman // difference between smallest and largest cases. 91637efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SwitchOp = getValue(SV); 91737efe6764568a3829fee26aba532283131d1a104Nate Begeman MVT::ValueType VT = SwitchOp.getValueType(); 91837efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand SUB = DAG.getNode(ISD::SUB, VT, SwitchOp, 91937efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(First, VT)); 92037efe6764568a3829fee26aba532283131d1a104Nate Begeman 92137efe6764568a3829fee26aba532283131d1a104Nate Begeman // The SDNode we just created, which holds the value being switched on 92237efe6764568a3829fee26aba532283131d1a104Nate Begeman // minus the the smallest case value, needs to be copied to a virtual 92337efe6764568a3829fee26aba532283131d1a104Nate Begeman // register so it can be used as an index into the jump table in a 92437efe6764568a3829fee26aba532283131d1a104Nate Begeman // subsequent basic block. This value may be smaller or larger than the 92537efe6764568a3829fee26aba532283131d1a104Nate Begeman // target's pointer type, and therefore require extension or truncating. 92637efe6764568a3829fee26aba532283131d1a104Nate Begeman if (VT > TLI.getPointerTy()) 92737efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::TRUNCATE, TLI.getPointerTy(), SUB); 92837efe6764568a3829fee26aba532283131d1a104Nate Begeman else 92937efe6764568a3829fee26aba532283131d1a104Nate Begeman SwitchOp = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), SUB); 93037efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JumpTableReg = FuncInfo.MakeReg(TLI.getPointerTy()); 93137efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CopyTo = DAG.getCopyToReg(getRoot(), JumpTableReg, SwitchOp); 93237efe6764568a3829fee26aba532283131d1a104Nate Begeman 93337efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the range check for the jump table, and branch to the default 93437efe6764568a3829fee26aba532283131d1a104Nate Begeman // block for the switch statement if the value being switched on exceeds 93537efe6764568a3829fee26aba532283131d1a104Nate Begeman // the largest case in the switch. 93637efe6764568a3829fee26aba532283131d1a104Nate Begeman SDOperand CMP = DAG.getSetCC(TLI.getSetCCResultTy(), SUB, 93737efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getConstant(Last-First,VT), ISD::SETUGT); 93837efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, CopyTo, CMP, 93937efe6764568a3829fee26aba532283131d1a104Nate Begeman DAG.getBasicBlock(Default))); 94037efe6764568a3829fee26aba532283131d1a104Nate Begeman 94137efe6764568a3829fee26aba532283131d1a104Nate Begeman // Build a sorted vector of destination BBs, corresponding to each target 94237efe6764568a3829fee26aba532283131d1a104Nate Begeman // of the switch. 94337efe6764568a3829fee26aba532283131d1a104Nate Begeman // FIXME: need to insert DefaultMBB for each "hole" in the jump table, 94437efe6764568a3829fee26aba532283131d1a104Nate Begeman // when we support jump tables with < 100% density. 94537efe6764568a3829fee26aba532283131d1a104Nate Begeman std::set<MachineBasicBlock*> UniqueBBs; 94637efe6764568a3829fee26aba532283131d1a104Nate Begeman std::vector<MachineBasicBlock*> DestBBs; 94737efe6764568a3829fee26aba532283131d1a104Nate Begeman for (CaseItr ii = Cases.begin(), ee = Cases.end(); ii != ee; ++ii) { 94837efe6764568a3829fee26aba532283131d1a104Nate Begeman DestBBs.push_back(ii->second); 94937efe6764568a3829fee26aba532283131d1a104Nate Begeman UniqueBBs.insert(ii->second); 95037efe6764568a3829fee26aba532283131d1a104Nate Begeman } 95137efe6764568a3829fee26aba532283131d1a104Nate Begeman unsigned JTI = CurMF->getJumpTableInfo()->getJumpTableIndex(DestBBs); 95237efe6764568a3829fee26aba532283131d1a104Nate Begeman 95337efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the jump table information so that we can codegen it as a second 95437efe6764568a3829fee26aba532283131d1a104Nate Begeman // MachineBasicBlock 95537efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.Reg = JumpTableReg; 95637efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.JTI = JTI; 95737efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.MBB = JumpTableBB; 9589453eea49bca1c3904047db495855c93e001d1cdNate Begeman JT.Default = Default; 95937efe6764568a3829fee26aba532283131d1a104Nate Begeman JT.SuccMBBs = UniqueBBs; 96037efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 96137efe6764568a3829fee26aba532283131d1a104Nate Begeman } 96237efe6764568a3829fee26aba532283131d1a104Nate Begeman } 963f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 964f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Push the initial CaseRec onto the worklist 965f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<CaseRec> CaseVec; 966f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 967f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 968f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman while (!CaseVec.empty()) { 969f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Grab a record representing a case range to process off the worklist 970f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec CR = CaseVec.back(); 971f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.pop_back(); 972f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 973f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Size is the number of Cases represented by this range. If Size is 1, 974f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // then we are processing a leaf of the binary search tree. Otherwise, 975f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // we need to pick a pivot, and push left and right ranges onto the 976f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // worklist. 977f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman unsigned Size = CR.Range.second - CR.Range.first; 978f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 979f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (Size == 1) { 980f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 981f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the Case's target mbb if the value being switched on SV is equal 982f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // to C. Otherwise, branch to default. 983f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = CR.Range.first->first; 984f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Target = CR.Range.first->second; 985f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, C, Target, Default, 986f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CR.CaseBB); 987f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the MBB representing the leaf node is the current MBB, then just 988f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // call visitSwitchCase to emit the code into the current block. 989f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, push the CaseBlock onto the vector to be later processed 990f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // by SDISel, and insert the node's MBB before the next MBB. 991f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 992f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 993f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else { 994f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 995f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMF->getBasicBlockList().insert(BBI, CR.CaseBB); 996f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 997f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 998f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // split case range at pivot 999f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseItr Pivot = CR.Range.first + (Size / 2); 1000f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange LHSR(CR.Range.first, Pivot); 1001f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange RHSR(Pivot, CR.Range.second); 1002f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = Pivot->first; 1003f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *RHSBB = 0, *LHSBB = 0; 1004f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // We know that we branch to the LHS if the Value being switched on is 1005f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // less than the Pivot value, C. We use this to optimize our binary 1006f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // tree a bit, by recognizing that if SV is greater than or equal to the 1007f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // LHS's Case Value, and that Case Value is exactly one less than the 1008f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Pivot's Value, then we can branch directly to the LHS's Target, 1009f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // rather than creating a leaf node for it. 1010f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((LHSR.second - LHSR.first) == 1 && 1011f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSR.first->first == CR.GE && 1012f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman cast<ConstantIntegral>(C)->getRawValue() == 1013f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman (cast<ConstantIntegral>(CR.GE)->getRawValue() + 1ULL)) { 1014f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSBB = LHSR.first->second; 1015f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1016f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSBB = new MachineBasicBlock(LLVMBB); 1017f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(LHSBB,C,CR.GE,LHSR)); 1018f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1019f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Similar to the optimization above, if the Value being switched on is 1020f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // known to be less than the Constant CR.LT, and the current Case Value 1021f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // is CR.LT - 1, then we can branch directly to the target block for 1022f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the current Case Value, rather than emitting a RHS leaf node for it. 1023f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((RHSR.second - RHSR.first) == 1 && CR.LT && 1024f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman cast<ConstantIntegral>(RHSR.first->first)->getRawValue() == 1025f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman (cast<ConstantIntegral>(CR.LT)->getRawValue() - 1ULL)) { 1026f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman RHSBB = RHSR.first->second; 1027f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 1028f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman RHSBB = new MachineBasicBlock(LLVMBB); 1029f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(RHSBB,CR.LT,C,RHSR)); 1030f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1031f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 1032f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the LHS node if the value being switched on SV is less than C. 1033f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, branch to LHS. 1034f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman ISD::CondCode CC = C->getType()->isSigned() ? ISD::SETLT : ISD::SETULT; 1035f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(CC, SV, C, LHSBB, RHSBB, CR.CaseBB); 1036f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 1037f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 1038f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else { 1039f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 1040f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMF->getBasicBlockList().insert(BBI, CR.CaseBB); 1041f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1042f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1043f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 1044f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 1045f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 1046b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 1047b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 104801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (I.getType()->isFloatingPoint()) { 104901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 105001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 105101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 105201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 105301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 105401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 105501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 10565fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::SUB, ISD::FSUB, ISD::VSUB); 1057b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 1058b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 10595fbb5d2459a5410590f285250faa604576308a93Nate Begemanvoid SelectionDAGLowering::visitBinary(User &I, unsigned IntOp, unsigned FPOp, 10605fbb5d2459a5410590f285250faa604576308a93Nate Begeman unsigned VecOp) { 10615fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 10621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 10631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 10642c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1065b67eb9131c5c04d2e55c6b587fde954619feceafChris Lattner if (Ty->isIntegral()) { 10665fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(IntOp, Op1.getValueType(), Op1, Op2)); 10675fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else if (Ty->isFloatingPoint()) { 10685fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(FPOp, Op1.getValueType(), Op1, Op2)); 10695fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 10705fbb5d2459a5410590f285250faa604576308a93Nate Begeman const PackedType *PTy = cast<PackedType>(Ty); 1071c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Num = DAG.getConstant(PTy->getNumElements(), MVT::i32); 1072c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Typ = DAG.getValueType(TLI.getValueType(PTy->getElementType())); 1073c7029805ef35ce9805931067b841e6af11db382eChris Lattner setValue(&I, DAG.getNode(VecOp, MVT::Vector, Op1, Op2, Num, Typ)); 10745fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1075e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 10762c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 1077e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 1078e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 1079e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 1080e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 1081e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 1082e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 10831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 10841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 10871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode UnsignedOpcode) { 10881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 10891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 10901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 10911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isUnsigned()) 10921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 10937cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 10941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 10971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 10981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 10991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 1100b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner if (!isa<PackedType>(I.getType())) { 1101b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 1102b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner TrueVal, FalseVal)); 1103b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } else { 1104b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner setValue(&I, DAG.getNode(ISD::VSELECT, MVT::Vector, Cond, TrueVal, FalseVal, 1105b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-2), 1106b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner *(TrueVal.Val->op_end()-1))); 1107b22e35a3c3bec07f5559c1476b3143e0d6d64269Chris Lattner } 11081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 11111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 1112e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 111328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 11141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1115e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner if (DestVT == MVT::Vector) { 1116e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast to a vector from something else. This is always a bit 1117e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1118e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 1119e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 1120e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N, 1121e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getConstant(DestTy->getNumElements(),MVT::i32), 1122e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getValueType(EltVT))); 1123e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (SrcVT == DestVT) { 11241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 112528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (DestVT == MVT::i1) { 1126ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 112728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand Zero = isInteger(SrcVT) ? DAG.getConstant(0, N.getValueType()) : 1128ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 11297cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 113028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isInteger(SrcVT)) { 113128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isInteger(DestVT)) { // Int -> Int cast 113228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Truncating cast? 113328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 1134ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 113528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 1136ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 113728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 11387e358908b885f50fb9258b7d10509bad20ca4c3bChris Lattner } else if (isFloatingPoint(DestVT)) { // Int -> FP cast 1139ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 114028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 1141ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 114228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 1143e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1144e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1145ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 114628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isFloatingPoint(SrcVT)) { 114728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isFloatingPoint(DestVT)) { // FP -> FP cast 114828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Rounding cast? 114928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N)); 1150ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 115128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 1152e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (isInteger(DestVT)) { // FP -> Int cast. 1153ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 115428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 1155ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 115628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 115728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else { 1158e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1159ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 1160e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1161e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(SrcVT == MVT::Vector && "Unknown cast!"); 1162e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(DestVT != MVT::Vector && "Casts to vector already handled!"); 1163e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast from a vector to something else. This is always a bit 1164e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1165e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N)); 11661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 11671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11692bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 1170c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1171c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 1172c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1173c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 1174c7029805ef35ce9805931067b841e6af11db382eChris Lattner 11752332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Num = *(InVec.Val->op_end()-2); 11762332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 11772332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner setValue(&I, DAG.getNode(ISD::VINSERT_VECTOR_ELT, MVT::Vector, 11782332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner InVec, InVal, InIdx, Num, Typ)); 1179c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 1180c7029805ef35ce9805931067b841e6af11db382eChris Lattner 11812bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 1182384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1183384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1184384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 1185384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 1186384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner setValue(&I, DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, 1187384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 1188384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 1189c7029805ef35ce9805931067b841e6af11db382eChris Lattner 11903e104b11168da4692b69cc6b236c1da22adff959Chris Lattnervoid SelectionDAGLowering::visitShuffleVector(User &I) { 11913e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V1 = getValue(I.getOperand(0)); 11923e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand V2 = getValue(I.getOperand(1)); 11933e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Mask = getValue(I.getOperand(2)); 11943e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 11953e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Num = *(V1.Val->op_end()-2); 11963e104b11168da4692b69cc6b236c1da22adff959Chris Lattner SDOperand Typ = *(V2.Val->op_end()-1); 11973e104b11168da4692b69cc6b236c1da22adff959Chris Lattner setValue(&I, DAG.getNode(ISD::VVECTOR_SHUFFLE, MVT::Vector, 11983e104b11168da4692b69cc6b236c1da22adff959Chris Lattner V1, V2, Mask, Num, Typ)); 11993e104b11168da4692b69cc6b236c1da22adff959Chris Lattner} 12003e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 12013e104b11168da4692b69cc6b236c1da22adff959Chris Lattner 12021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 12031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 12041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 12051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 12061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 12081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 12091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 1210c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 12111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 12121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 12131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 12141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field]; 12151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 1216dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 12171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 12191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 12201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 12217c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12227c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 12237c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 12247c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (CI->getRawValue() == 0) continue; 12257c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12267c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t Offs; 12277c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 12287c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 12297c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 12307c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 12317c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 12327c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 12337c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 12347c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12357c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 12367c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 12377c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 12387c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12397c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 12407c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 12417c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 12427c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (Idx->getType()->isSigned()) 12437c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 12447c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 12457c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN); 12467c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 12477c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 12487c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12497c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 12507c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 12517c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 12527c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 12537c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 12546b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 12551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 12567c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 12571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12587c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 12597c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 12607c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 12617c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 12621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 12641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 12651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 12661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 12681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 12691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 12701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 12711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 12721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 12741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 1275ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 1276ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman I.getAlignment()); 12771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12781c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 127968cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 128068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 128168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 128268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 128368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 12841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 128568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 12861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 12871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 12881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 12891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 12901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 12911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 12921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 12931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 12941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 12951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 12961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 12971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 12981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 12991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 13001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 13011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 13021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 13031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1304adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs; 1305adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(AllocSize.getValueType()); 1306adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(MVT::Other); 1307adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 1308adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getRoot()); 1309adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(AllocSize); 1310adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getIntPtrConstant(Align)); 1311adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 13121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 13131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 13151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 13161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 13171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 13201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 1321edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1322d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 1323d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 1324d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 1325d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 1326d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 1327d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 1328d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 132928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 133028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, getLoadFrom(I.getType(), Ptr, DAG.getSrcValue(I.getOperand(0)), 133128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner Root, I.isVolatile())); 133228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 133328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 133428b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 133528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand SrcValue, SDOperand Root, 133628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile) { 13375fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 13388cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 13394ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 1340c7029805ef35ce9805931067b841e6af11db382eChris Lattner L = DAG.getVecLoad(PTy->getNumElements(), PVT, Root, Ptr, SrcValue); 13415fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 134228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SrcValue); 13435fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1344d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 134528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 1346d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 1347d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 1348d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 134928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 135028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 13511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 13551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 13561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 13571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 1358369e6db9b6033bb60519b0ad84afeacc9ec9b416Chris Lattner DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr, 135906ef88472f7bac3512e224974e87a0a456471b82Andrew Lenharth DAG.getSrcValue(I.getOperand(1)))); 13601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 13611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 13620eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// IntrinsicCannotAccessMemory - Return true if the specified intrinsic cannot 13630eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// access memory and has no other side effects at all. 13640eade319cdb72e24c11d068728a98083737c6435Chris Lattnerstatic bool IntrinsicCannotAccessMemory(unsigned IntrinsicID) { 13650eade319cdb72e24c11d068728a98083737c6435Chris Lattner#define GET_NO_MEMORY_INTRINSICS 13660eade319cdb72e24c11d068728a98083737c6435Chris Lattner#include "llvm/Intrinsics.gen" 13670eade319cdb72e24c11d068728a98083737c6435Chris Lattner#undef GET_NO_MEMORY_INTRINSICS 13680eade319cdb72e24c11d068728a98083737c6435Chris Lattner return false; 13690eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 13700eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1371e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// IntrinsicOnlyReadsMemory - Return true if the specified intrinsic doesn't 1372e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner// have any side-effects or if it only reads memory. 1373e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattnerstatic bool IntrinsicOnlyReadsMemory(unsigned IntrinsicID) { 1374e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#define GET_SIDE_EFFECT_INFO 1375e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#include "llvm/Intrinsics.gen" 1376e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner#undef GET_SIDE_EFFECT_INFO 1377e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner return false; 1378e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner} 1379e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner 13800eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 13810eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 13820eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 13830eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 13847255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner bool HasChain = !IntrinsicCannotAccessMemory(Intrinsic); 1385e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner bool OnlyLoad = HasChain && IntrinsicOnlyReadsMemory(Intrinsic); 13860eade319cdb72e24c11d068728a98083737c6435Chris Lattner 13870eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 13880eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<SDOperand> Ops; 1389e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { // If this intrinsic has side-effects, chainify it. 1390e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) { 1391e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner // We don't need to serialize loads against other loads. 1392e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(DAG.getRoot()); 1393e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } else { 1394e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner Ops.push_back(getRoot()); 1395e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 1396e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 13970eade319cdb72e24c11d068728a98083737c6435Chris Lattner 13980eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 13990eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 14000eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14010eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 14020eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 14030eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 14040eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14050eade319cdb72e24c11d068728a98083737c6435Chris Lattner // If this is a vector type, force it to the right packed type. 14060eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (Op.getValueType() == MVT::Vector) { 14070eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *OpTy = cast<PackedType>(I.getOperand(i)->getType()); 14080eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType()); 14090eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14100eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VVT = MVT::getVectorType(EltVT, OpTy->getNumElements()); 14110eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VVT != MVT::Other && "Intrinsic uses a non-legal type?"); 14120eade319cdb72e24c11d068728a98083737c6435Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, VVT, Op); 14130eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14140eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14150eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 14160eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 14170eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 14180eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14190eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14200eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 14210eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 14220eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 14230eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (VT == MVT::Vector) { 14240eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 14250eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 14260eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14270eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 14280eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 14290eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14300eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14310eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 14320eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 14330eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14340eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 14350eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 14360eade319cdb72e24c11d068728a98083737c6435Chris Lattner 14370eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 143848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 143948b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 144048b61a729df6576c8833a83893d4086bddff69a5Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTs, Ops); 144148b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 144248b61a729df6576c8833a83893d4086bddff69a5Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTs, Ops); 144348b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 144448b61a729df6576c8833a83893d4086bddff69a5Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTs, Ops); 144548b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 1446e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (HasChain) { 1447e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner SDOperand Chain = Result.getValue(Result.Val->getNumValues()-1); 1448e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner if (OnlyLoad) 1449e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner PendingLoads.push_back(Chain); 1450e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner else 1451e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner DAG.setRoot(Chain); 1452e58a780166eb684164a0a95b999f29328d4e9b2bChris Lattner } 14530eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 14540eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (const PackedType *PTy = dyn_cast<PackedType>(I.getType())) { 14550eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EVT = TLI.getValueType(PTy->getElementType()); 14560eade319cdb72e24c11d068728a98083737c6435Chris Lattner Result = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Result, 14570eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getConstant(PTy->getNumElements(), MVT::i32), 14580eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getValueType(EVT)); 14590eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14600eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 14610eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 14620eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 14630eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1464c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 1465c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 1466c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 1467c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 1468c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 1469c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 14700eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 14710eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 14720eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 14730eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 1474c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 1475c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 1476c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 1477c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return 0; 1478c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return 0; 1479c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 1480c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1481c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 1482c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 1483c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1484c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 148503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 148603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 148703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 148803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 148903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 149003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 149103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 149203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 149303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 149403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 149503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 149603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 1497c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 149886cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 1499ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 150043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 1501fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && SPI.getContext() && DebugInfo->Verify(SPI.getContext())) { 1502ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey std::vector<SDOperand> Ops; 150336ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 1504ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey Ops.push_back(getRoot()); 150543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getValue(SPI.getLineValue())); 150643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getValue(SPI.getColumnValue())); 1507ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 150843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfoDesc *DD = DebugInfo->getDescFor(SPI.getContext()); 1509ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 151043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 151143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1512ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey Ops.push_back(DAG.getString(CompileUnit->getFileName())); 1513ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey Ops.push_back(DAG.getString(CompileUnit->getDirectory())); 1514ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 151543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops)); 151686cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 151743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1518b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 151936ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 152043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 152143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 152243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 1523fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && RSI.getContext() && DebugInfo->Verify(RSI.getContext())) { 152443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 152543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 152643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(RSI.getContext()); 152743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 152843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getRoot()); 152943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(DAG.getConstant(LabelID, MVT::i32)); 153043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 153143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops)); 153243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 153343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1534b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 153543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 153643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 153743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 153843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 1539fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && REI.getContext() && DebugInfo->Verify(REI.getContext())) { 154043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 154143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 154243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionEnd(REI.getContext()); 154343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 154443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getRoot()); 154543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(DAG.getConstant(LabelID, MVT::i32)); 154643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 154743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops)); 154843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 154943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1550b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 155143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 155243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 155343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 155443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 1555fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && FSI.getSubprogram() && 1556fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey DebugInfo->Verify(FSI.getSubprogram())) { 155743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 155843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 155943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(FSI.getSubprogram()); 156043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 156143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getRoot()); 156243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(DAG.getConstant(LabelID, MVT::i32)); 156343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 156443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops)); 156543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 156643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1567b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 156843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 156943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 157043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 157143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 1572bf7637d59028a5d9911769810f537c499e23bb8eJim Laskey if (DebugInfo && DI.getVariable() && DebugInfo->Verify(DI.getVariable())) { 157343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 157443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 15750892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey SDOperand AddressOp = getValue(DI.getAddress()); 15760892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(AddressOp)) { 157743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfo->RecordVariable(DI.getVariable(), FI->getIndex()); 157843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 157943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 158043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 158143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 158243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 1583c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 15840b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f32: 15850b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f64: 1586c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 1587c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 1588c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1589c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 15900b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 15910b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 1592c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 1593c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1594c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1595c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1596c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 1597c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1598c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 1599c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1600c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 16018b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 16028b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<MVT::ValueType> VTs; 16038b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::i64); 16048b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::Other); 16058b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<SDOperand> Ops; 16068b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth Ops.push_back(getRoot()); 16078b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, VTs, Ops); 16088b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 16098b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 161051b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 16118b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 1612d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 1613d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 1614d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 1615d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 1616d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 1617d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 1618d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 16190b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 16200b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 16210b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 16220b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 1623c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 1624c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1625c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1626c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 16270b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 16280b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 16290b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 16300b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 1631c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 1632c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1633c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1634c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 16350b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 16360b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 16370b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 16380b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 1639c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 1640c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1641c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1642c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1643140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 1644140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<MVT::ValueType> VTs; 1645140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(TLI.getPointerTy()); 1646140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(MVT::Other); 1647140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<SDOperand> Ops; 1648140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Ops.push_back(getRoot()); 1649140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, VTs, Ops); 1650140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 1651140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 1652140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 1653140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 165439a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 165539a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 165639a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 1657140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 165839a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 1659ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 1660ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 1661ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 1662c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1663c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 1664c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 1665c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 16661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 166764e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 1668c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 1669c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 1670c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 1671c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 1672c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 1673c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 1674c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 1675c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 1676a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (Name[0] == 'c' && (Name == "copysign" || Name == "copysignf")) { 1677a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 1678a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1679a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(1)->getType() && 1680a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(2)->getType()) { 1681a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand LHS = getValue(I.getOperand(1)); 1682a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand RHS = getValue(I.getOperand(2)); 1683a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 1684a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner LHS, RHS)); 1685a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner return; 1686a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 1687a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } else if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 1688c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1689c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1690c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1691c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1692c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 1693c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 1694c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1695c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 1696f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1697f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 169806a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1699c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1700f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 1701f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1702f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1703c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 1704f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1705f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 170606a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1707c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1708f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 1709f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1710f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1711f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1712c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1713ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 1714ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner visitInlineAsm(I); 1715ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 1716c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1717edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 171864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 171964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 172064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 172164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 172264e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 17231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1724c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 17251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 17261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 17271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 17281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 17291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1730edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 17318e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 17328e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 1733edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1734cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 17359092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 1736adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 17371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 1738cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 1739cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 17401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 17411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1742864635ad7b3046d3042311423071152c613961deChris LattnerSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 17439f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag)const{ 1744864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Val = DAG.getCopyFromReg(Chain, Regs[0], RegVT, Flag); 1745864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 1746864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 1747864635ad7b3046d3042311423071152c613961deChris Lattner 1748864635ad7b3046d3042311423071152c613961deChris Lattner // If the result was expanded, copy from the top part. 1749864635ad7b3046d3042311423071152c613961deChris Lattner if (Regs.size() > 1) { 1750864635ad7b3046d3042311423071152c613961deChris Lattner assert(Regs.size() == 2 && 1751864635ad7b3046d3042311423071152c613961deChris Lattner "Cannot expand to more than 2 elts yet!"); 1752864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Hi = DAG.getCopyFromReg(Chain, Regs[1], RegVT, Flag); 1753864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 1754864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 17559f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (DAG.getTargetLoweringInfo().isLittleEndian()) 17569f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Val, Hi); 17579f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner else 17589f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Hi, Val); 1759864635ad7b3046d3042311423071152c613961deChris Lattner } 1760864635ad7b3046d3042311423071152c613961deChris Lattner 1761864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, if the return value was promoted, truncate it to the 1762864635ad7b3046d3042311423071152c613961deChris Lattner // appropriate type. 1763864635ad7b3046d3042311423071152c613961deChris Lattner if (RegVT == ValueVT) 1764864635ad7b3046d3042311423071152c613961deChris Lattner return Val; 1765864635ad7b3046d3042311423071152c613961deChris Lattner 1766864635ad7b3046d3042311423071152c613961deChris Lattner if (MVT::isInteger(RegVT)) 1767864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 1768864635ad7b3046d3042311423071152c613961deChris Lattner else 1769864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::FP_ROUND, ValueVT, Val); 1770864635ad7b3046d3042311423071152c613961deChris Lattner} 1771864635ad7b3046d3042311423071152c613961deChris Lattner 1772c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 1773c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// specified value into the registers specified by this object. This uses 1774c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// Chain/Flag as the input and updates them for the output Chain/Flag. 1775c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 17769f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const { 1777c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (Regs.size() == 1) { 1778c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // If there is a single register and the types differ, this must be 1779c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // a promotion. 1780c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (RegVT != ValueVT) { 1781c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (MVT::isInteger(RegVT)) 1782c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::ANY_EXTEND, RegVT, Val); 1783c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner else 1784c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::FP_EXTEND, RegVT, Val); 1785c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1786c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Chain = DAG.getCopyToReg(Chain, Regs[0], Val, Flag); 1787c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 1788c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } else { 17899f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<unsigned> R(Regs); 17909f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (!DAG.getTargetLoweringInfo().isLittleEndian()) 17919f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::reverse(R.begin(), R.end()); 17929f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner 17939f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner for (unsigned i = 0, e = R.size(); i != e; ++i) { 1794c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner SDOperand Part = DAG.getNode(ISD::EXTRACT_ELEMENT, RegVT, Val, 1795c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner DAG.getConstant(i, MVT::i32)); 17969f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner Chain = DAG.getCopyToReg(Chain, R[i], Part, Flag); 1797c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 1798c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1799c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1800c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 1801864635ad7b3046d3042311423071152c613961deChris Lattner 1802c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 1803c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 1804c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 1805c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 18069f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 1807c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getConstant(Code | (Regs.size() << 3), MVT::i32)); 1808c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 1809c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 1810c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 1811864635ad7b3046d3042311423071152c613961deChris Lattner 1812864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 1813864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 1814864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 1815864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 18169b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 18179b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetLowering &TLI, const MRegisterInfo *MRI) { 1818f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType FoundVT = MVT::Other; 1819f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner const TargetRegisterClass *FoundRC = 0; 18209b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (MRegisterInfo::regclass_iterator RCI = MRI->regclass_begin(), 18219b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = MRI->regclass_end(); RCI != E; ++RCI) { 1822f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::ValueType ThisVT = MVT::Other; 1823f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner 18249b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 18259b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 18269b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 18279b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 18289b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 18299b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 1830f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // If we have already found this register in a different register class, 1831f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // choose the one with the largest VT specified. For example, on 1832f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // PowerPC, we favor f64 register classes over f32. 1833f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (FoundVT == MVT::Other || 1834f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner MVT::getSizeInBits(FoundVT) < MVT::getSizeInBits(*I)) { 1835f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner ThisVT = *I; 1836f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 1837f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 18389b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 18399b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 18409b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 1841f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (ThisVT == MVT::Other) continue; 18429b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 1843864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 1844864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 1845864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 1846864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 18479b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 18489b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 1849f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner if (*I == Reg) { 1850f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // We found a matching register class. Keep looking at others in case 1851f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner // we find one with larger registers that this physreg is also in. 1852f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundRC = RC; 1853f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner FoundVT = ThisVT; 1854f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner break; 1855f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner } 1856864635ad7b3046d3042311423071152c613961deChris Lattner } 1857f8814cf8b8ba8953add60078e304fd5a4113f9ccChris Lattner return FoundRC; 1858864635ad7b3046d3042311423071152c613961deChris Lattner} 1859864635ad7b3046d3042311423071152c613961deChris Lattner 1860864635ad7b3046d3042311423071152c613961deChris LattnerRegsForValue SelectionDAGLowering:: 1861864635ad7b3046d3042311423071152c613961deChris LattnerGetRegistersForValue(const std::string &ConstrCode, 1862864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, bool isOutReg, bool isInReg, 1863864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 18644e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 1865864635ad7b3046d3042311423071152c613961deChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 1866864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegForInlineAsmConstraint(ConstrCode, VT); 1867864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 1868864635ad7b3046d3042311423071152c613961deChris Lattner 1869864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumRegs = VT != MVT::Other ? TLI.getNumElements(VT) : 1; 1870864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 1871864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT = VT; 1872864635ad7b3046d3042311423071152c613961deChris Lattner 1873864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 1874864635ad7b3046d3042311423071152c613961deChris Lattner if (VT == MVT::Other) 1875864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 1876864635ad7b3046d3042311423071152c613961deChris Lattner RegVT = VT; 1877864635ad7b3046d3042311423071152c613961deChris Lattner 1878864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 1879864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 1880864635ad7b3046d3042311423071152c613961deChris Lattner 1881864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 1882864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 1883864635ad7b3046d3042311423071152c613961deChris Lattner RegVT = *PhysReg.second->vt_begin(); 1884864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 1885864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 1886864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 1887864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 1888864635ad7b3046d3042311423071152c613961deChris Lattner 1889864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 1890864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 1891864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 1892864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 1893864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 1894864635ad7b3046d3042311423071152c613961deChris Lattner } 1895864635ad7b3046d3042311423071152c613961deChris Lattner } 1896864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 1897864635ad7b3046d3042311423071152c613961deChris Lattner } 1898864635ad7b3046d3042311423071152c613961deChris Lattner 1899864635ad7b3046d3042311423071152c613961deChris Lattner // This is a reference to a register class. Allocate NumRegs consecutive, 1900864635ad7b3046d3042311423071152c613961deChris Lattner // available, registers from the class. 1901864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> RegClassRegs = 1902864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegClassForInlineAsmConstraint(ConstrCode, VT); 1903864635ad7b3046d3042311423071152c613961deChris Lattner 19044e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner const MRegisterInfo *MRI = DAG.getTarget().getRegisterInfo(); 19054e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner MachineFunction &MF = *CurMBB->getParent(); 1906864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 1907864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 1908864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 19094e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 1910864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 1911864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 1912864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 1913864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 1914864635ad7b3046d3042311423071152c613961deChris Lattner continue; 1915864635ad7b3046d3042311423071152c613961deChris Lattner } 1916864635ad7b3046d3042311423071152c613961deChris Lattner 19174e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 19184e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 19199b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, MRI); 1920864635ad7b3046d3042311423071152c613961deChris Lattner if (!RC) { 1921864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 1922864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 1923864635ad7b3046d3042311423071152c613961deChris Lattner continue; 19244e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 19254e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 1926864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 1927864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 1928864635ad7b3046d3042311423071152c613961deChris Lattner 1929864635ad7b3046d3042311423071152c613961deChris Lattner // If we allocated enough consecutive 1930864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 1931864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 1932864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 1933864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 1934864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) { 1935864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 1936864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 1937864635ad7b3046d3042311423071152c613961deChris Lattner if (isOutReg) OutputRegs.insert(Reg); // Mark reg used. 1938864635ad7b3046d3042311423071152c613961deChris Lattner if (isInReg) InputRegs.insert(Reg); // Mark reg used. 1939864635ad7b3046d3042311423071152c613961deChris Lattner } 1940864635ad7b3046d3042311423071152c613961deChris Lattner 1941864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, *RC->vt_begin(), VT); 1942864635ad7b3046d3042311423071152c613961deChris Lattner } 19434e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 1944864635ad7b3046d3042311423071152c613961deChris Lattner 1945864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 1946864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(); 19474e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 19484e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 1949864635ad7b3046d3042311423071152c613961deChris Lattner 1950ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 1951ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 1952ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattnervoid SelectionDAGLowering::visitInlineAsm(CallInst &I) { 1953ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner InlineAsm *IA = cast<InlineAsm>(I.getOperand(0)); 1954ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1955ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand AsmStr = DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), 1956ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner MVT::Other); 1957ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1958ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Note, we treat inline asms both with and without side-effects as the same. 1959ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // If an inline asm doesn't have side effects and doesn't access memory, we 1960ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // could not choose to not chain it. 1961ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner bool hasSideEffects = IA->hasSideEffects(); 1962ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 19632cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); 19641efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner std::vector<MVT::ValueType> ConstraintVTs; 1965ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1966ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// AsmNodeOperands - A list of pairs. The first element is a register, the 1967ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// second is a bitfield where bit #0 is set if it is a use and bit #1 is set 1968ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// if it is a def of that register. 1969ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> AsmNodeOperands; 1970ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 1971ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(AsmStr); 1972ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1973ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 1974ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 1975ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 19764e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We fully assign registers here at isel time. This is not optimal, but 19774e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // should work. For register classes that correspond to LLVM classes, we 19784e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // could let the LLVM RA do its thing, but we currently don't. Do a prepass 19794e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // over the constraints, collecting fixed registers that we know we can't use. 19804e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 19811efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner unsigned OpNum = 1; 19824e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 19834e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 19844e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 19852223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 19861efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner MVT::ValueType OpVT; 19871efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 19881efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Compute the value type for each operand and add it to ConstraintVTs. 19891efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner switch (Constraints[i].Type) { 19901efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 19911efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (!Constraints[i].isIndirectOutput) { 19921efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 19931efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getType()); 19941efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 199522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner const Type *OpTy = I.getOperand(OpNum)->getType(); 19961efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(cast<PointerType>(OpTy)->getElementType()); 19971efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 19981efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 19991efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20001efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 20011efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getOperand(OpNum)->getType()); 20021efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 20031efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20041efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 20051efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = MVT::Other; 20061efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20071efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 20081efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 20091efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner ConstraintVTs.push_back(OpVT); 20101efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2011864635ad7b3046d3042311423071152c613961deChris Lattner if (TLI.getRegForInlineAsmConstraint(ConstraintCode, OpVT).first == 0) 2012864635ad7b3046d3042311423071152c613961deChris Lattner continue; // Not assigned a fixed reg. 20131efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 2014864635ad7b3046d3042311423071152c613961deChris Lattner // Build a list of regs that this operand uses. This always has a single 2015864635ad7b3046d3042311423071152c613961deChris Lattner // element for promoted/expanded operands. 2016864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = GetRegistersForValue(ConstraintCode, OpVT, 2017864635ad7b3046d3042311423071152c613961deChris Lattner false, false, 2018864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 20194e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 20204e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner switch (Constraints[i].Type) { 20214e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isOutput: 20224e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We can't assign any other output to this register. 2023864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20244e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // If this is an early-clobber output, it cannot be assigned to the same 20254e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // value as the input reg. 20262223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2027864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20284e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 20291efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 20301efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // We can't assign any other input to this register. 2031864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20321efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 20334e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isClobber: 20344e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Clobbered regs cannot be used as inputs or outputs. 2035864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 2036864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 20374e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 20384e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 20394e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 20402cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 20410f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 20420f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 2043864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 2044864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 20451efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum = 1; 20460f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 20476656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 20482cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 20492cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 20501efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 20512cc2f66c25d9576743026688fdae5ed402726532Chris Lattner switch (Constraints[i].Type) { 20522cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 205322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 205422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 205522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 205622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 205722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (CTy == TargetLowering::C_Memory) { 205822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Memory output. 205922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 206022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 206122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Check that the operand (the address to store to) isn't a float. 206222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 206322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 206422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 206522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!Constraints[i].isIndirectOutput) 206622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 206722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 206822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner OpNum++; // Consumes a call operand. 206922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 207022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Extend/truncate to the right pointer type if needed. 207122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 207222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (InOperandVal.getValueType() < PtrType) 207322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 207422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner else if (InOperandVal.getValueType() > PtrType) 207522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 207622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 207722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 207822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 207922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 208022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(InOperandVal); 208122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 208222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 208322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 208422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Otherwise, this is a register output. 208522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 208622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 2087864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an early-clobber output, or if there is an input 2088864635ad7b3046d3042311423071152c613961deChris Lattner // constraint that matches this, we need to reserve the input register 2089864635ad7b3046d3042311423071152c613961deChris Lattner // so no other inputs allocate to it. 2090864635ad7b3046d3042311423071152c613961deChris Lattner bool UsesInputRegister = false; 2091864635ad7b3046d3042311423071152c613961deChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 2092864635ad7b3046d3042311423071152c613961deChris Lattner UsesInputRegister = true; 20932223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 2094864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 2095864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 2096864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = 2097864635ad7b3046d3042311423071152c613961deChris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 2098864635ad7b3046d3042311423071152c613961deChris Lattner true, UsesInputRegister, 2099864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 2100864635ad7b3046d3042311423071152c613961deChris Lattner assert(!Regs.Regs.empty() && "Couldn't allocate output reg!"); 21012cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 21022cc2f66c25d9576743026688fdae5ed402726532Chris Lattner if (!Constraints[i].isIndirectOutput) { 2103864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 21042cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 21052cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 2106864635ad7b3046d3042311423071152c613961deChris Lattner RetValRegs = Regs; 21072cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 210822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner IndirectStoresToEmit.push_back(std::make_pair(Regs, 210922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner I.getOperand(OpNum))); 21102cc2f66c25d9576743026688fdae5ed402726532Chris Lattner OpNum++; // Consumes a call operand. 21112cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 21126656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 21136656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 21146656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 2115c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Regs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, AsmNodeOperands); 21166656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 21176656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 21186656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 211922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 21204e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner OpNum++; // Consumes a call operand. 21213d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 21222223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (isdigit(ConstraintCode[0])) { // Matching constraint? 21232223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 21242223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 21252223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner unsigned OperandNo = atoi(ConstraintCode.c_str()); 21263d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 2127c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 2128c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 2129c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 2130c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 2131c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 2132c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2133c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2134c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner assert((NumOps & 7) == 2 /*REGDEF*/ && 2135c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2136c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 2137c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2138c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2139c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 2140c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 2141c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner assert((NumOps & 7) == 2 /*REGDEF*/ && 2142c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 2143c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2144c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 2145c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue MatchedRegs; 2146c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 2147c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 2148c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 2149c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned Reg=cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 2150c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.Regs.push_back(Reg); 2151c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 2152c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 2153c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Use the produced MatchedRegs object to 2154c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag); 2155c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 215687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 215787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 215887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 215987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 216087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 216187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 21623d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 216387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (CTy == TargetLowering::C_Other) { 216487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!TLI.isOperandValidForConstraint(InOperandVal, ConstraintCode[0])) 216587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2166c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 216787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 216887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 3 /*IMM*/ | (1 << 3); 216987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 217087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 217187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 217287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } else if (CTy == TargetLowering::C_Memory) { 217387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Memory input. 217487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 217587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Check that the operand isn't a float. 217687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 217787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 2178c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 217987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Extend/truncate to the right pointer type if needed. 218087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 218187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (InOperandVal.getValueType() < PtrType) 218287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 218387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner else if (InOperandVal.getValueType() > PtrType) 218487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 218587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 218687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 218787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 218887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 218987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 2190c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 21912223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 219287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 219387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 219487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 219587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 219687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner RegsForValue InRegs = 219787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 219887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner false, true, OutputRegs, InputRegs); 219987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // FIXME: should be match fail. 220087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(!InRegs.Regs.empty() && "Couldn't allocate input reg!"); 220187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 220287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag); 220387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 220487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, AsmNodeOperands); 22056656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 22066656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2207c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 2208c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue ClobberedRegs = 2209c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner GetRegistersForValue(ConstraintCode, MVT::Other, false, false, 2210c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner OutputRegs, InputRegs); 2211c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 2212c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 2213c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (!ClobberedRegs.Regs.empty()) 2214c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner ClobberedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, AsmNodeOperands); 22156656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 22166656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2217c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 22186656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2219ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2220ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 2221ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 2222ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 2223ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2224ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<MVT::ValueType> VTs; 2225ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner VTs.push_back(MVT::Other); 2226ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner VTs.push_back(MVT::Flag); 2227ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, VTs, AsmNodeOperands); 2228ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 2229ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22306656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 22316656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 2232864635ad7b3046d3042311423071152c613961deChris Lattner if (!RetValRegs.Regs.empty()) 2233864635ad7b3046d3042311423071152c613961deChris Lattner setValue(&I, RetValRegs.getCopyFromRegs(DAG, Chain, Flag)); 22346656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 22356656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 22366656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 22376656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 22386656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 22396656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 2240864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 22416656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 2242864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, Flag); 2243864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 22446656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2245ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22466656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 22476656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<SDOperand> OutChains; 22486656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 22496656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner OutChains.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain, 22506656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner StoresToEmit[i].first, 22516656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 22526656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner DAG.getSrcValue(StoresToEmit[i].second))); 22536656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 22546656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains); 2255ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 2256ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 2257ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2258ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 22591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 22601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 22611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 226368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 226468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 226568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 226668cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 226768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 22681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 22701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType()); 22711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 22721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 22731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 22751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType())); 2276cf5734dddd66af9388a171b44996505ede47feedChris Lattner 2277cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2278adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 2279cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 2280cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 2281cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 2282cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 22831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 22841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 22851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 22861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 22871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 22881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetData().getIntPtrType())); 22891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 2290cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2291adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 2292cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 2293cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 22941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 22951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2296025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 2297025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 2298025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 2299025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 2300025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 2301025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 2302025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 2303025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 2304025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 2305025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 2306025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 2307025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 2308025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 2309025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 231039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 2311acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 2312acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2313acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 231439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 231539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 23161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 2317acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 2318acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 2319acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 2320acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 2321acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 23221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 2325acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 2326acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2327acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 23281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 2331acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 2332acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2333acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 2334acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 2335acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 23361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2338fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// TargetLowering::LowerArguments - This is the default LowerArguments 2339fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// implementation, which just inserts a FORMAL_ARGUMENTS node. FIXME: When all 2340fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner/// targets are migrated to using FORMAL_ARGUMENTS, this hook should be removed. 2341fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattnerstd::vector<SDOperand> 2342fdfded55888e35b76bb70231a5bb2f60877c2f6aChris LattnerTargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { 2343fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. 2344fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<SDOperand> Ops; 2345fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.getCallingConv(), getPointerTy())); 2346fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getConstant(F.isVarArg(), getPointerTy())); 2347fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2348fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Add one result value for each formal argument. 2349fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::vector<MVT::ValueType> RetVals; 2350fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { 2351fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2352fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2353fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2354fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2355fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2356fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(VT); 2357fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2358fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: 2359fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(getTypeToTransformTo(VT)); 2360fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2361fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2362fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2363fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be broken up into small 2364fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the destination type is and how many small 2365fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it turns into. 2366fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2367fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2368fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (unsigned i = 0; i != NumVals; ++i) 2369fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(NVT); 2370fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2371fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2372fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2373fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumElems = cast<PackedType>(I->getType())->getNumElements(); 2374fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner const Type *EltTy = cast<PackedType>(I->getType())->getElementType(); 2375fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2376fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2377fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2378fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2379fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2380fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner RetVals.push_back(TVT); 2381fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2382fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2383fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2384fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2385fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2386fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2387fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 23883b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng 23893b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng if (RetVals.size() == 0) 23903b0d286d0085fbf8314d9f5510c2f78558ab5deaEvan Cheng RetVals.push_back(MVT::isVoid); 2391fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2392fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Create the node. 2393fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDNode *Result = DAG.getNode(ISD::FORMAL_ARGUMENTS, RetVals, Ops).Val; 2394fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2395fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Set up the return result vector. 2396fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.clear(); 2397fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned i = 0; 2398fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { 2399fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType VT = getValueType(I->getType()); 2400fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2401fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner switch (getTypeAction(VT)) { 2402fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner default: assert(0 && "Unknown type action!"); 2403fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Legal: 2404fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(SDOperand(Result, i++)); 2405fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2406fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Promote: { 2407fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Op(Result, i++); 2408fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (MVT::isInteger(VT)) { 2409fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned AssertOp = I->getType()->isSigned() ? ISD::AssertSext 2410fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner : ISD::AssertZext; 2411fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(AssertOp, Op.getValueType(), Op, DAG.getValueType(VT)); 2412fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::TRUNCATE, VT, Op); 2413fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2414fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(MVT::isFloatingPoint(VT) && "Not int or FP?"); 2415fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Op = DAG.getNode(ISD::FP_ROUND, VT, Op); 2416fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2417fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(Op); 2418fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2419fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2420fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner case Expand: 2421fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (VT != MVT::Vector) { 2422fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // If this is a large integer, it needs to be reassembled from small 2423fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers. Figure out what the source elt type is and how many small 2424fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // integers it is. 2425fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType NVT = getTypeToTransformTo(VT); 2426fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumVals = MVT::getSizeInBits(VT)/MVT::getSizeInBits(NVT); 2427fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (NumVals == 2) { 2428fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Lo = SDOperand(Result, i++); 2429fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner SDOperand Hi = SDOperand(Result, i++); 2430fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2431fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (!isLittleEndian()) 2432fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner std::swap(Lo, Hi); 2433fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2434fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(DAG.getNode(ISD::BUILD_PAIR, VT, Lo, Hi)); 2435fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2436fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Value scalarized into many values. Unimp for now. 2437fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Cannot expand i64 -> i16 yet!"); 2438fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2439fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2440fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Otherwise, this is a vector type. We only support legal vectors 2441fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // right now. 2442fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner unsigned NumElems = cast<PackedType>(I->getType())->getNumElements(); 2443fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner const Type *EltTy = cast<PackedType>(I->getType())->getElementType(); 2444fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 2445fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // Figure out if there is a Packed type corresponding to this Vector 2446fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner // type. If so, convert to the packed type. 2447fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); 2448fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner if (TVT != MVT::Other && isTypeLegal(TVT)) { 2449fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner Ops.push_back(SDOperand(Result, i++)); 2450fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } else { 2451fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner assert(0 && "Don't support illegal by-val vector arguments yet!"); 2452fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2453fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2454fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner break; 2455fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2456fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner } 2457fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner return Ops; 2458fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner} 2459fdfded55888e35b76bb70231a5bb2f60877c2f6aChris Lattner 246039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 246139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 246239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 246339ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 246439ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 246539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 24661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 24671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 246850381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 2469171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 2470171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 2471d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 2472171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 2473171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 24740aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 24750aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 24760aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 24770aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 24780aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 24790aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 24800aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 248139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 248239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 248339ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 2484a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 248539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 248639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 248739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 24881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 248974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 24901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 24911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 2492a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 24931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 24941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 24951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 24961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 24971db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 24981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 24991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 25001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 25011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 25021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 25031db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 25041db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 25051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 25061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 25071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 25081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 25091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 25101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 25111db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 25121db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 25131db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 25141db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 25151db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 25161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 25171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 25181db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 251974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 252074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 252174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 252274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 252374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 252474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 252574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng MVT::ValueType CurVT = VT; 252674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 252774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng unsigned MSB = getSizeInBits(VT) / 8; 252874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 252974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 253074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 253174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Val = (Val << 8) | Str[Offset]; 253274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 253374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 253474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 253574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 253674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 25371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 25381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 25391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 25401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 25411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 25421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 25431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 2544c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 254580e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 254680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 2547c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 2548c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 2549c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 25501db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 25511db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 25521db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 25531db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 25541db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 25551db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 25561db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 25571db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 25581db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 25591db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 25601db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 25611db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 25621db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 25631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 25641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 25651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 25661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 25671db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 25681db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 25691db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 25701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 257180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 257280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 257380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 257480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 25751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 257680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 257780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 257880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 2579dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 25801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 25811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 25821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 25831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 25841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 25851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 258680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 258780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 258880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 258980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 25901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 25911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 25921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 259380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 259480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 25951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 25961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 25977041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 25981db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 25991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 26001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 26011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 26021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 26031db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 26041db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 26051db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 26061db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 26071db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 26081db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 26091db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 26101db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<SDOperand> OutChains; 26111db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 2612ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 26131db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 2614c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 2615c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 261680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 26171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 26181db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 26191db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 26201db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 2621a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 2622c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, getRoot(), 2623c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Value, 2624864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 2625864635ad7b3046d3042311423071152c613961deChris Lattner DAG.getSrcValue(I.getOperand(1), Offset)); 2626c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 2627c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 2628c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2629c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2630c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 2631c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2632c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 2633c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 2634c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 2635c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 2636cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 263774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 263874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 2639cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 264074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 264174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 264274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 264374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 264474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 264574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 264674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 2647cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 264874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 264974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 265074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 2651cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (GV) { 26520937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 2653cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 2654cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 2655cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 2656cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 2657cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 265874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 265974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 2660c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 2661c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 2662c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 266374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 266474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 2665cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 266674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 266774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 266874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 266974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getNode(ISD::STORE, MVT::Other, Chain, Value, 267074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 267174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getSrcValue(I.getOperand(1), DstOff)); 267274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 267374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 267474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 267574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getSrcValue(I.getOperand(2), SrcOff)); 267674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 267774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 267874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getNode(ISD::STORE, MVT::Other, Chain, Value, 267974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 268074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getSrcValue(I.getOperand(1), DstOff)); 268174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 2682c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 268374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 268474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 26851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 26861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 2687c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 26881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 26891db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 2690c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 2691c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 2692c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains)); 2693c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 2694c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 26951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 26961db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 26977041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner std::vector<SDOperand> Ops; 2698a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner Ops.push_back(getRoot()); 26991db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op1); 27001db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op2); 27011db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op3); 27021db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op4); 27037041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops)); 27041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 27051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27067041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 27077041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 27087041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 27091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 27111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 27121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 27131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2714495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 271536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 271636b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 2717495a0b51915eb763576874f29192820b731edc22Chris Lattner} 27181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2719c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2720c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 2721c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// casting to the type of GEPI. 2722c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattnerstatic Value *InsertGEPComputeCode(Value *&V, BasicBlock *BB, Instruction *GEPI, 2723c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr, Value *PtrOffset) { 2724c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (V) return V; // Already computed. 2725c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2726c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock::iterator InsertPt; 2727c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (BB == GEPI->getParent()) { 2728c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If insert into the GEP's block, insert right after the GEP. 2729c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner InsertPt = GEPI; 2730c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ++InsertPt; 2731c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 2732c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 2733c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner InsertPt = BB->begin(); 2734c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 2735c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2736c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2737c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 2738c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // BB so that there is only one value live across basic blocks (the cast 2739c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // operand). 2740c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 2741c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 2742c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Ptr = new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 2743c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 2744c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Add the offset, cast it to the right type. 2745c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 2746c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = new CastInst(Ptr, GEPI->getType(), "", InsertPt); 2747c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner return V = Ptr; 2748c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 2749c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2750c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2751c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 2752c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 2753c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 2754c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 2755c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 2756c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 2757c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattnerstatic void OptimizeGEPExpression(GetElementPtrInst *GEPI, 2758c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const TargetData &TD) { 2759c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 2760c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 2761c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 2762c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 2763c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 2764c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 2765c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 2766c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 2767c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 2768c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2769c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2770c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (!isUsedOutsideDefBB) return; 2771c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2772c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 2773c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 2774c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 2775c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 2776c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 2777c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) 2778c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue()) { 2779c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 2780c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 2781c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2782c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 27833802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 27843802c2552fe4475418db3c948e7601d7259f996dChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) return; 2785c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2786c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 2787c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 2788c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 2789c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 2790c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr = new CastInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 2791c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 2792c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2793c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 2794c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 2795c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 2796c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 2797c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 2798c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 2799c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset += TD.getStructLayout(StTy)->MemberOffsets[Field]; 2800c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 2801c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 2802c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 2803c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2804c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 2805c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 2806c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue() == 0) continue; 2807c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2808c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 2809c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset += (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 2810c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner else 2811c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset+=TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 2812c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 2813c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2814c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2815c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 2816c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2817c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 2818c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = new CastInst(Idx, UIntPtrTy, "", GEPI); 2819c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2820c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 2821c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 2822c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 2823c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *SizeCst = ConstantUInt::get(UIntPtrTy, ElementSize); 2824c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2825c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 2826c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 2827c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 2828c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2829c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2830c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2831c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 2832c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 2833c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *PtrOffset = ConstantUInt::get(UIntPtrTy, ConstantOffset); 2834c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2835c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 2836c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 2837c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 2838c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 2839c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 2840c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 2841c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 2842c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 2843c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner std::map<BasicBlock*,Value*> InsertedExprs; 2844c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner while (!GEPI->use_empty()) { 2845c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Instruction *User = cast<Instruction>(GEPI->use_back()); 2846c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 2847c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // If this use is not foldable into the addressing mode, use a version 2848c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // emitted in the GEP block. 2849c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Value *NewVal; 2850c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (!isa<LoadInst>(User) && 2851c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner (!isa<StoreInst>(User) || User->getOperand(0) == GEPI)) { 2852c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 2853c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Ptr, PtrOffset); 2854c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner } else { 2855c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // Otherwise, insert the code in the User's block so it can be folded into 2856c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // any users in that block. 2857c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 2858c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner User->getParent(), GEPI, 2859c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr, PtrOffset); 2860c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2861c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner User->replaceUsesOfWith(GEPI, NewVal); 2862c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner } 2863c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2864c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 2865c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 2866c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 2867c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 28681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 28691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 28701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 28711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 28721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2873c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // First, split all critical edges for PHI nodes with incoming values that are 2874c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constants, this way the load of the constant into a vreg will not be placed 2875c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // into MBBs that are used some other way. 2876c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 2877c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // In this pass we also look for GEP instructions that are used across basic 2878c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // blocks and rewrites them to improve basic-block-at-a-time selection. 2879c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 288036b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 288136b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner PHINode *PN; 2882c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock::iterator BBI; 2883c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (BBI = BB->begin(); (PN = dyn_cast<PHINode>(BBI)); ++BBI) 288436b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 288536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 288636b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 2887c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2888c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (BasicBlock::iterator E = BB->end(); BBI != E; ) 2889c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(BBI++)) 2890c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner OptimizeGEPExpression(GEPI, TLI.getTargetData()); 289136b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 2892c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 28931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 28941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 28951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 28961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 2897edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 28981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 28991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 29001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 29011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2902ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 2903ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 2904f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 290518c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 2906d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 290718c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 2908d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 2909d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 2910d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 2911d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 2912d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 2913d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SelectionDAG &DAG = SDL.DAG; 2914d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 2915d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 29161c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } else if (SrcVT == MVT::Vector) { 291770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Handle copies from generic vectors to registers. 291870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner MVT::ValueType PTyElementVT, PTyLegalElementVT; 291970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner unsigned NE = TLI.getPackedTypeBreakdown(cast<PackedType>(V->getType()), 292070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner PTyElementVT, PTyLegalElementVT); 29211c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 292270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Insert a VBIT_CONVERT of the input vector to a "N x PTyElementVT" 292370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // MVT::Vector type. 292470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Op, 292570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getConstant(NE, MVT::i32), 292670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner DAG.getValueType(PTyElementVT)); 292770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner 292870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Loop over all of the elements of the resultant vector, 292970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // VEXTRACT_VECTOR_ELT'ing them, converting them to PTyLegalElementVT, then 293070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // copying them into output registers. 293170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner std::vector<SDOperand> OutChains; 293270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Root = SDL.getRoot(); 293370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner for (unsigned i = 0; i != NE; ++i) { 293470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Elt = DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, PTyElementVT, 293570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Op, DAG.getConstant(i, MVT::i32)); 293670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (PTyElementVT == PTyLegalElementVT) { 293770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are legal. 293870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 293970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else if (PTyLegalElementVT > PTyElementVT) { 294070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are promoted. 294170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner if (MVT::isFloatingPoint(PTyLegalElementVT)) 294270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::FP_EXTEND, PTyLegalElementVT, Elt); 294370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner else 294470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt = DAG.getNode(ISD::ANY_EXTEND, PTyLegalElementVT, Elt); 294570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Elt)); 294670c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } else { 294770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // Elements are expanded. 294870c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner // The src value is expanded into multiple registers. 294970c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 295070c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt, DAG.getConstant(0, MVT::i32)); 295170c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, PTyLegalElementVT, 295270c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner Elt, DAG.getConstant(1, MVT::i32)); 295370c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Lo)); 295470c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner OutChains.push_back(DAG.getCopyToReg(Root, Reg++, Hi)); 295570c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner } 29561c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } 295770c2a61e0a0fb0a7e8b9bddd26bdcc92762772f0Chris Lattner return DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains); 2958d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 2959d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 2960fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 2961fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 2962fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 2963fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 2964d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 2965d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 2966d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 2967d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 2968d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(0, MVT::i32)); 2969d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 2970d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(1, MVT::i32)); 2971d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo); 2972d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 2973d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 29741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 29751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2976068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 2977068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 2978068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 29791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 2980068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 29810afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 2982bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 2983bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 2984bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2985bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 2986bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 2987bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 2988bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 2989bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 2990fa57702388f139e964befecb4b98c7dfe836945fChris Lattner 2991bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 2992bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 2993bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 2994bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 2995bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 2996bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 2997bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 29980afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 2999bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3000bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Next, if the function has live ins that need to be copied into vregs, 3001bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // emit the copies now, into the top of the block. 3002bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MachineFunction &MF = SDL.DAG.getMachineFunction(); 3003bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (MF.livein_begin() != MF.livein_end()) { 3004bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SSARegMap *RegMap = MF.getSSARegMap(); 3005bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner const MRegisterInfo &MRI = *MF.getTarget().getRegisterInfo(); 3006bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (MachineFunction::livein_iterator LI = MF.livein_begin(), 3007bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner E = MF.livein_end(); LI != E; ++LI) 3008bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LI->second) 3009bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MRI.copyRegToReg(*MF.begin(), MF.begin()->end(), LI->second, 3010bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LI->first, RegMap->getRegClass(LI->second)); 30111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3012bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 3013bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 3014bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 3015068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 3016068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3017068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3018068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 3019068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 3020f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 3021068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 3022068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 3023068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 3024edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3025bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 3026bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 3027bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 30281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 30291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 30301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 30311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 30321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 30331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 30341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 30351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 3036f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 30371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 30381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 30391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 3040f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 3041ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 30421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 3043ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3044ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 30451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 30461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 30471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 30481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 30491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 30501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 30511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 30521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 3053edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 30541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 30551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 30561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 30571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 30581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 30591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 30601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 30611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 30621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 30631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 30641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 30651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 30661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 30671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 30681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 30691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 3070f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 3071f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 3072f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 3073f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 3074f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 3075f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 3076f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 3077f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 3078ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3079ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 3080f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 3081f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 3082f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 3083f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 3084ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 3085edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 3086ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 3087ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 3088ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 3089ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 3090ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 3091ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 30921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3093edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 3094f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 3095f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 30967e02151ce2686687446ba7293e66d6b096106e68Chris Lattner MVT::ValueType VT = TLI.getValueType(PN->getType()); 30977e02151ce2686687446ba7293e66d6b096106e68Chris Lattner unsigned NumElements; 30987e02151ce2686687446ba7293e66d6b096106e68Chris Lattner if (VT != MVT::Vector) 30997e02151ce2686687446ba7293e66d6b096106e68Chris Lattner NumElements = TLI.getNumElements(VT); 31007e02151ce2686687446ba7293e66d6b096106e68Chris Lattner else { 31017e02151ce2686687446ba7293e66d6b096106e68Chris Lattner MVT::ValueType VT1,VT2; 31027e02151ce2686687446ba7293e66d6b096106e68Chris Lattner NumElements = 31037e02151ce2686687446ba7293e66d6b096106e68Chris Lattner TLI.getPackedTypeBreakdown(cast<PackedType>(PN->getType()), 31047e02151ce2686687446ba7293e66d6b096106e68Chris Lattner VT1, VT2); 31057e02151ce2686687446ba7293e66d6b096106e68Chris Lattner } 3106f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 3107f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 31081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 31091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 31101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 31111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3112ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 31135a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 31147436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 31157436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 31167436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 31177436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 31187436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 31197436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 31207436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 31217436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 31227436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 31237436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 31247436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 31257436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 3126ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains)); 3127ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 3128ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 31291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 31301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 3131a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 3132f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 313337efe6764568a3829fee26aba532283131d1a104Nate Begeman // lowering, as well as any jump table information. 3134f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 3135f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 313637efe6764568a3829fee26aba532283131d1a104Nate Begeman JT = SDL.JT; 3137f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3138a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 3139a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 31401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 31411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3142f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 3143af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 3144af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(false); 31452300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 31461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 31471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 3148f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 31491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 31501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 3151ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 3152f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 31531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 31541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 3155f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3156af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 3157af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(true); 31582300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 3159a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 3160d48050aa1509130871b8bb2453270c92b969c2e7Chris Lattner 3161a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 3162a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 31631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 3164f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 31651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 31661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 3167f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 3168f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3169f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 3170f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 3171f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 3172f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 3173f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 3174f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 3175f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3176f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 3177f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 3178f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 31791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3180f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 3181f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 3182f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3183f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3184a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 31851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 318637efe6764568a3829fee26aba532283131d1a104Nate Begeman if (SwitchCases.empty() && JT.Reg == 0) { 3187f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 3188f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 3189f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 3190f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 3191f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addRegOperand(PHINodesToUpdate[i].second); 3192f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 3193f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3194f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 31951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 3196f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 31979453eea49bca1c3904047db495855c93e001d1cdNate Begeman // If the JumpTable record is filled in, then we need to emit a jump table. 31989453eea49bca1c3904047db495855c93e001d1cdNate Begeman // Updating the PHI nodes is tricky in this case, since we need to determine 31999453eea49bca1c3904047db495855c93e001d1cdNate Begeman // whether the PHI is a successor of the range check MBB or the jump table MBB 320037efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.Reg) { 320137efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(SwitchCases.empty() && "Cannot have jump table and lowered switch"); 320237efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 320337efe6764568a3829fee26aba532283131d1a104Nate Begeman CurDAG = &SDAG; 320437efe6764568a3829fee26aba532283131d1a104Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 32059453eea49bca1c3904047db495855c93e001d1cdNate Begeman MachineBasicBlock *RangeBB = BB; 320637efe6764568a3829fee26aba532283131d1a104Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 320737efe6764568a3829fee26aba532283131d1a104Nate Begeman BB = JT.MBB; 320837efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.setCurrentBasicBlock(BB); 320937efe6764568a3829fee26aba532283131d1a104Nate Begeman // Emit the code 321037efe6764568a3829fee26aba532283131d1a104Nate Begeman SDL.visitJumpTable(JT); 321137efe6764568a3829fee26aba532283131d1a104Nate Begeman SDAG.setRoot(SDL.getRoot()); 321237efe6764568a3829fee26aba532283131d1a104Nate Begeman CodeGenAndEmitDAG(SDAG); 321337efe6764568a3829fee26aba532283131d1a104Nate Begeman // Update PHI Nodes 321437efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 321537efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 321637efe6764568a3829fee26aba532283131d1a104Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 321737efe6764568a3829fee26aba532283131d1a104Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 321837efe6764568a3829fee26aba532283131d1a104Nate Begeman "This is not a machine PHI node that we are updating!"); 32199453eea49bca1c3904047db495855c93e001d1cdNate Begeman if (PHIBB == JT.Default || JT.SuccMBBs.find(PHIBB) != JT.SuccMBBs.end()) { 32209453eea49bca1c3904047db495855c93e001d1cdNate Begeman PHIBB = (PHIBB == JT.Default) ? RangeBB : BB; 322137efe6764568a3829fee26aba532283131d1a104Nate Begeman PHI->addRegOperand(PHINodesToUpdate[pi].second); 32229453eea49bca1c3904047db495855c93e001d1cdNate Begeman PHI->addMachineBasicBlockOperand(PHIBB); 322337efe6764568a3829fee26aba532283131d1a104Nate Begeman } 322437efe6764568a3829fee26aba532283131d1a104Nate Begeman } 322537efe6764568a3829fee26aba532283131d1a104Nate Begeman return; 322637efe6764568a3829fee26aba532283131d1a104Nate Begeman } 322737efe6764568a3829fee26aba532283131d1a104Nate Begeman 3228f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 3229f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 3230f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for(unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 3231f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 3232f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 3233f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 3234f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 3235f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 3236f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 3237f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 3238f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 3239f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 3240f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 3241f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Iterate over the phi nodes, if there is a phi node in a successor of this 3242f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // block (for instance, the default block), then add a pair of operands to 3243f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the phi node for this block, as if we were coming from the original 3244f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // BB before switch expansion. 3245f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 3246f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 3247f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 3248f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 3249f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 3250f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (PHIBB == SwitchCases[i].LHSBB || PHIBB == SwitchCases[i].RHSBB) { 3251f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addRegOperand(PHINodesToUpdate[pi].second); 3252f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 3253f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3254f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 3255a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 32561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 3257a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 3258a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 3259a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 3260a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 3261a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 3262a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 32634ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng ScheduleDAG *SL = NULL; 32644ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 32654ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng switch (ISHeuristic) { 32664ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng default: assert(0 && "Unrecognized scheduling heuristic"); 32673f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng case defaultScheduling: 32683f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) 32694a1cd9c61e3e648587d33d5f02ddad97e87f16aaChris Lattner SL = createTDListDAGScheduler(DAG, BB, CreateTargetHazardRecognizer()); 32704a1cd9c61e3e648587d33d5f02ddad97e87f16aaChris Lattner else { 32714a1cd9c61e3e648587d33d5f02ddad97e87f16aaChris Lattner assert(TLI.getSchedulingPreference() == 32724a1cd9c61e3e648587d33d5f02ddad97e87f16aaChris Lattner TargetLowering::SchedulingForRegPressure && "Unknown sched type!"); 32733f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng SL = createBURRListDAGScheduler(DAG, BB); 32744a1cd9c61e3e648587d33d5f02ddad97e87f16aaChris Lattner } 32753f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng break; 32764ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case noScheduling: 327720a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner SL = createBFS_DAGScheduler(DAG, BB); 327820a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner break; 32794ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case simpleScheduling: 328020a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner SL = createSimpleDAGScheduler(false, DAG, BB); 328120a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner break; 32824ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case simpleNoItinScheduling: 328320a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner SL = createSimpleDAGScheduler(true, DAG, BB); 32844ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng break; 3285f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng case listSchedulingBURR: 3286f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng SL = createBURRListDAGScheduler(DAG, BB); 3287a5de484bc7c8f896b5903999797c4d57f4e45185Chris Lattner break; 328803fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner case listSchedulingTD: 3289b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner SL = createTDListDAGScheduler(DAG, BB, CreateTargetHazardRecognizer()); 3290a5de484bc7c8f896b5903999797c4d57f4e45185Chris Lattner break; 32914ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 3292a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 3293cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 3294a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 32950e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 3296b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris LattnerHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 3297b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner return new HazardRecognizer(); 329803fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner} 329903fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 33000e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 33010e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 33020e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 33030e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 33040e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 33050e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 33060e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 33070e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 33080e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 33090e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 33100e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner const char *AsmStr = cast<ExternalSymbolSDNode>(InOps[1])->getSymbol(); 33110e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 33120e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 33130e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 33140e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 33150e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 33160e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 33170e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 33180e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 33190e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 33200e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 33210e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 33220e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 33230e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 33240e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 33250e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 33260e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::cerr << "Could not match memory address. Inline asm failure!\n"; 33270e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 33280e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 33290e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 33300e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 33310e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(DAG.getConstant(4/*MEM*/ | (SelOps.size() << 3), MVT::i32)); 33320e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 33330e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 33340e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 33350e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 33360e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 33370e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 33380e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 33390e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 33400e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 3341