SelectionDAGISel.cpp revision 2bbd81064a6998496a71ff7ae8160b3caada64fa
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" 301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/MachineInstrBuilder.h" 311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SelectionDAG.h" 321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/CodeGen/SSARegMap.h" 33fa57702388f139e964befecb4b98c7dfe836945fChris Lattner#include "llvm/Target/MRegisterInfo.h" 341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetData.h" 351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetInstrInfo.h" 371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetLowering.h" 381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Target/TargetMachine.h" 39495a0b51915eb763576874f29192820b731edc22Chris Lattner#include "llvm/Transforms/Utils/BasicBlockUtils.h" 407944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#include "llvm/Support/CommandLine.h" 417c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner#include "llvm/Support/MathExtras.h" 421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Support/Debug.h" 431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <map> 444e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner#include <set> 451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include <iostream> 467e88103cdea8c36b2229dae8c60def14e3816512Jeff Cohen#include <algorithm> 471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerusing namespace llvm; 481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 49da8abb02397d7cd62a1e16e7c534edd7096ac873Chris Lattner#ifndef NDEBUG 507944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattnerstatic cl::opt<bool> 51a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewISelDAGs("view-isel-dags", cl::Hidden, 52a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show isel dags as they are selected")); 53a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic cl::opt<bool> 54a9c2091cd38e401c846391c9951ff416e709b65eEvan ChengViewSchedDAGs("view-sched-dags", cl::Hidden, 55a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng cl::desc("Pop up a window to show sched dags as they are processed")); 567944d9d9957db1efe085d9df3ea89826f50029b7Chris Lattner#else 57a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic const bool ViewISelDAGs = 0; 58a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengstatic const bool 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()) { 267f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 268f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 269f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned PHIReg = ValueMap[PN]; 270f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner assert(PHIReg &&"PHI node does not have an assigned virtual register!"); 271f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0; i != NumElements; ++i) 272f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i); 273f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2773c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// CreateRegForValue - Allocate the appropriate number of virtual registers of 2783c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// the correctly promoted or expanded types. Assign these registers 2793c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner/// consecutive vreg numbers and return the first assigned number. 2803c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattnerunsigned FunctionLoweringInfo::CreateRegForValue(const Value *V) { 2813c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType VT = TLI.getValueType(V->getType()); 2823c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 2833c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The number of multiples of registers that we need, to, e.g., split up 2843c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // a <2 x int64> -> 4 x i32 registers. 2853c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumVectorRegs = 1; 2863c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 2873c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a packed type, figure out what type it will decompose into 2883c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // and how many of the elements it will use. 2893c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (VT == MVT::Vector) { 2903c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner const PackedType *PTy = cast<PackedType>(V->getType()); 2913c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NumElts = PTy->getNumElements(); 2923c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType EltTy = TLI.getValueType(PTy->getElementType()); 2933c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 2943c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // Divide the input until we get to a supported size. This will always 2953c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // end with a scalar if the target doesn't support vectors. 2963c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (NumElts > 1 && !TLI.isTypeLegal(getVectorType(EltTy, NumElts))) { 2973c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumElts >>= 1; 2983c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner NumVectorRegs <<= 1; 2993c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3006cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner if (NumElts == 1) 3016cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = EltTy; 3026cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner else 3036cb7004c3499f07c034a01f6335b5058aa80a5ceChris Lattner VT = getVectorType(EltTy, NumElts); 3043c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3053c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3063c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // The common case is that we will only create one register for this 3073c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // value. If we have that case, create and return the virtual register. 3083c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NV = TLI.getNumElements(VT); 3093c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner if (NV == 1) { 3103c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If we are promoting this value, pick the next largest supported type. 3113c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MVT::ValueType PromotedType = TLI.getTypeToTransformTo(VT); 3123c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned Reg = MakeReg(PromotedType); 3133c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this is a vector of supported or promoted types (e.g. 4 x i16), 3143c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // create all of the registers. 3153c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NumVectorRegs; ++i) 3163c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg(PromotedType); 3173c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return Reg; 3183c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner } 3193c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3203c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // If this value is represented with multiple target registers, make sure 3213c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner // to create enough consecutive registers of the right (smaller) type. 3223c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned NT = VT-1; // Find the type to use. 3233c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner while (TLI.getNumElements((MVT::ValueType)NT) != 1) 3243c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner --NT; 3253c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner 3263c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner unsigned R = MakeReg((MVT::ValueType)NT); 3273c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner for (unsigned i = 1; i != NV*NumVectorRegs; ++i) 3283c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner MakeReg((MVT::ValueType)NT); 3293c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner return R; 3303c38449be6371d53a58d0df80ecf3772a2f9a79fChris Lattner} 3311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner//===----------------------------------------------------------------------===// 3331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// SelectionDAGLowering - This is the common target-independent lowering 3341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// implementation that is parameterized by a TargetLowering object. 3351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// Also, targets can overload any lowering method. 3361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner/// 3371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnernamespace llvm { 3381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerclass SelectionDAGLowering { 3391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *CurMBB; 3401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<const Value*, SDOperand> NodeMap; 3421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 343d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// PendingLoads - Loads are not emitted to the program immediately. We bunch 344d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// them up and then emit token factor nodes when possible. This allows us to 345d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// get simple disambiguation between loads without worrying about alias 346d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner /// analysis. 347d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner std::vector<SDOperand> PendingLoads; 348d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 349f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Case - A pair of values to record the Value for a switch case, and the 350f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// case's target basic block. 351f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<Constant*, MachineBasicBlock*> Case; 352f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::vector<Case>::iterator CaseItr; 353f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman typedef std::pair<CaseItr, CaseItr> CaseRange; 354f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 355f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseRec - A struct with ctor used in lowering switches to a binary tree 356f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// of conditional branches. 357f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseRec { 358f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec(MachineBasicBlock *bb, Constant *lt, Constant *ge, CaseRange r) : 359f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseBB(bb), LT(lt), GE(ge), Range(r) {} 360f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 361f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// CaseBB - The MBB in which to emit the compare and branch 362f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *CaseBB; 363f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// LT, GE - If nonzero, we know the current case value must be less-than or 364f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// greater-than-or-equal-to these Constants. 365f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *LT; 366f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *GE; 367f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// Range - A pair of iterators representing the range of case values to be 368f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// processed at this point in the binary search tree. 369f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange Range; 370f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 371f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 372f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// The comparison function for sorting Case values. 373f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman struct CaseCmp { 374f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman bool operator () (const Case& C1, const Case& C2) { 375f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (const ConstantUInt* U1 = dyn_cast<const ConstantUInt>(C1.first)) 376f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return U1->getValue() < cast<const ConstantUInt>(C2.first)->getValue(); 377f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 378f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const ConstantSInt* S1 = dyn_cast<const ConstantSInt>(C1.first); 379f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return S1->getValue() < cast<const ConstantSInt>(C2.first)->getValue(); 380f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 381f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman }; 382f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerpublic: 3841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // TLI - This is information that describes the available target features we 3851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // need for lowering. This indicates when operations are unavailable, 3861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // implemented with a libcall, etc. 3871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TargetLowering &TLI; 3881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAG &DAG; 3891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const TargetData &TD; 3901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 391f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchCases - Vector of CaseBlock structures used to communicate 392f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman /// SwitchInst code generation information. 393f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<SelectionDAGISel::CaseBlock> SwitchCases; 394f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 3951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// FuncInfo - Information about the function as a whole. 3961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner /// 3971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo &FuncInfo; 3981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 3991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, 400edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman FunctionLoweringInfo &funcinfo) 4011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), 4021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FuncInfo(funcinfo) { 4031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 405a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// getRoot - Return the current virtual root of the Selection DAG. 406a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner /// 407a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner SDOperand getRoot() { 408d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.empty()) 409d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return DAG.getRoot(); 410edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 411d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (PendingLoads.size() == 1) { 412d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = PendingLoads[0]; 413d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 414d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 415d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 416d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 417d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 418d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Otherwise, we have to make a token factor node. 419d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads); 420d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.clear(); 421d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(Root); 422d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner return Root; 423a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner } 424a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 4251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(Instruction &I) { visit(I.getOpcode(), I); } 4261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visit(unsigned Opcode, User &I) { 4281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner switch (Opcode) { 4291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner default: assert(0 && "Unknown instruction type encountered!"); 4301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 4311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Build the switch statement using the Instruction.def file. 4321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 4331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner case Instruction::OPCODE:return visit##OPCODE((CLASS&)I); 4341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner#include "llvm/Instruction.def" 4351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; } 4391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 44028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand getLoadFrom(const Type *Ty, SDOperand Ptr, 44128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand SrcValue, SDOperand Root, 44228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile); 4431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand getIntPtrConstant(uint64_t Val) { 4451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return DAG.getConstant(Val, TLI.getPointerTy()); 4461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 448199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand getValue(const Value *V); 4491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const SDOperand &setValue(const Value *V, SDOperand NewN) { 4511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand &N = NodeMap[V]; 4521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(N.Val == 0 && "Already set a value for this node!"); 4531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return N = NewN; 4541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4554e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 456864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue GetRegistersForValue(const std::string &ConstrCode, 457864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, 458864635ad7b3046d3042311423071152c613961deChris Lattner bool OutReg, bool InReg, 459864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 460864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &InputRegs); 461f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Terminator instructions. 4631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRet(ReturnInst &I); 4641c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitBr(BranchInst &I); 465f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitch(SwitchInst &I); 4661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnreachable(UnreachableInst &I) { /* noop */ } 4671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 468f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Helper for visitSwitch 469f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman void visitSwitchCase(SelectionDAGISel::CaseBlock &CB); 470f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 4711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // These all get lowered before this pass. 4721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); } 4731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); } 4741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 4755fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitBinary(User &I, unsigned IntOp, unsigned FPOp, unsigned VecOp); 476e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShift(User &I, unsigned Opcode); 4775fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitAdd(User &I) { 4785fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::ADD, ISD::FADD, ISD::VADD); 47901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 480b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner void visitSub(User &I); 4815fbb5d2459a5410590f285250faa604576308a93Nate Begeman void visitMul(User &I) { 4825fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::MUL, ISD::FMUL, ISD::VMUL); 48301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 4841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitDiv(User &I) { 48501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 4863e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng visitBinary(I, 4873e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng Ty->isSigned() ? ISD::SDIV : ISD::UDIV, ISD::FDIV, 4883e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng Ty->isSigned() ? ISD::VSDIV : ISD::VUDIV); 4891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitRem(User &I) { 49101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner const Type *Ty = I.getType(); 4925fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, Ty->isSigned() ? ISD::SREM : ISD::UREM, ISD::FREM, 0); 4931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 4943e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitAnd(User &I) { visitBinary(I, ISD::AND, 0, ISD::VAND); } 4953e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitOr (User &I) { visitBinary(I, ISD::OR, 0, ISD::VOR); } 4963e1ce5a44d3d59b2b9ca68a21261f0f487d69269Evan Cheng void visitXor(User &I) { visitBinary(I, ISD::XOR, 0, ISD::VXOR); } 497e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShl(User &I) { visitShift(I, ISD::SHL); } 498e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman void visitShr(User &I) { 499e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman visitShift(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA); 5001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc); 5031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); } 5041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); } 5051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); } 5061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); } 5071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); } 5081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); } 5091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5102bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitExtractElement(User &I); 5112bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner void visitInsertElement(User &I); 512c7029805ef35ce9805931067b841e6af11db382eChris Lattner 5131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitGetElementPtr(User &I); 5141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCast(User &I); 5151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitSelect(User &I); 5161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitMalloc(MallocInst &I); 5181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitFree(FreeInst &I); 5191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitAlloca(AllocaInst &I); 5201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitLoad(LoadInst &I); 5211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitStore(StoreInst &I); 5221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitPHI(PHINode &I) { } // PHI nodes are handled specially. 5231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitCall(CallInst &I); 524ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner void visitInlineAsm(CallInst &I); 525c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const char *visitIntrinsicCall(CallInst &I, unsigned Intrinsic); 5260eade319cdb72e24c11d068728a98083737c6435Chris Lattner void visitTargetIntrinsic(CallInst &I, unsigned Intrinsic); 5271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAStart(CallInst &I); 5291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAArg(VAArgInst &I); 5301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVAEnd(CallInst &I); 5311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitVACopy(CallInst &I); 53239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner void visitFrameReturnAddress(CallInst &I, bool isFrameAddress); 5331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5347041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner void visitMemIntrinsic(CallInst &I, unsigned Op); 5351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 5361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp1(Instruction &I) { 5371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp1 should not exist at instruction selection time!"); 5381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner void visitUserOp2(Instruction &I) { 5411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner assert(0 && "UserOp2 should not exist at instruction selection time!"); 5421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner abort(); 5431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 5441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner}; 5451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} // end namespace llvm 5461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 547199862b74973198c2ab5a139f664c86713e7b579Chris LattnerSDOperand SelectionDAGLowering::getValue(const Value *V) { 548199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand &N = NodeMap[V]; 549199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (N.Val) return N; 550199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 551199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const Type *VTy = V->getType(); 552199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType VT = TLI.getValueType(VTy); 553199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) { 554199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 555199862b74973198c2ab5a139f664c86713e7b579Chris Lattner visit(CE->getOpcode(), *CE); 556199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(N.Val && "visit didn't populate the ValueMap!"); 557199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 558199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) { 559199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getGlobalAddress(GV, VT); 560199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<ConstantPointerNull>(C)) { 561199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(0, TLI.getPointerTy()); 562199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (isa<UndefValue>(C)) { 56323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner if (!isa<PackedType>(VTy)) 56423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner return N = DAG.getNode(ISD::UNDEF, VT); 56523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 566b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR of undef nodes. 56723d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner const PackedType *PTy = cast<PackedType>(VTy); 56823d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner unsigned NumElements = PTy->getNumElements(); 56923d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 57023d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 57123d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner std::vector<SDOperand> Ops; 57223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.assign(NumElements, DAG.getNode(ISD::UNDEF, PVT)); 57323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner 57423d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner // Create a VConstant node with generic Vector type. 57523d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 57623d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 577b2827b0901162169bb2692b77a839c9767849134Chris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, Ops); 578199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 579199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstantFP(CFP->getValue(), VT); 580199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else if (const PackedType *PTy = dyn_cast<PackedType>(VTy)) { 581199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 582199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 583199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 584199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Now that we know the number and type of the elements, push a 585199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Constant or ConstantFP node onto the ops list for each element of 586199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // the packed constant. 587199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::vector<SDOperand> Ops; 588199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) { 5892bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner for (unsigned i = 0; i != NumElements; ++i) 5902bbd81064a6998496a71ff7ae8160b3caada64faChris Lattner Ops.push_back(getValue(CP->getOperand(i))); 591199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 592199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(isa<ConstantAggregateZero>(C) && "Unknown packed constant!"); 593199862b74973198c2ab5a139f664c86713e7b579Chris Lattner SDOperand Op; 594199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (MVT::isFloatingPoint(PVT)) 595199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstantFP(0, PVT); 596199862b74973198c2ab5a139f664c86713e7b579Chris Lattner else 597199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Op = DAG.getConstant(0, PVT); 598199862b74973198c2ab5a139f664c86713e7b579Chris Lattner Ops.assign(NumElements, Op); 599199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 600199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 601b2827b0901162169bb2692b77a839c9767849134Chris Lattner // Create a VBUILD_VECTOR node with generic Vector type. 60223d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getConstant(NumElements, MVT::i32)); 60323d564c11fbe628dbebd6d8f09d7d07fa862b719Chris Lattner Ops.push_back(DAG.getValueType(PVT)); 604b2827b0901162169bb2692b77a839c9767849134Chris Lattner return N = DAG.getNode(ISD::VBUILD_VECTOR, MVT::Vector, Ops); 605199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 606199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Canonicalize all constant ints to be unsigned. 607199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT); 608199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 609199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 610199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 611199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 612199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const AllocaInst*, int>::iterator SI = 613199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.StaticAllocaMap.find(AI); 614199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (SI != FuncInfo.StaticAllocaMap.end()) 615199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return DAG.getFrameIndex(SI->second, TLI.getPointerTy()); 616199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 617199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 618199862b74973198c2ab5a139f664c86713e7b579Chris Lattner std::map<const Value*, unsigned>::const_iterator VMI = 619199862b74973198c2ab5a139f664c86713e7b579Chris Lattner FuncInfo.ValueMap.find(V); 620199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!"); 621199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 622199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned InReg = VMI->second; 623199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 624199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // If this type is not legal, make it so now. 625199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (VT == MVT::Vector) { 626199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // FIXME: We only handle legal vectors right now. We need a VBUILD_VECTOR 627199862b74973198c2ab5a139f664c86713e7b579Chris Lattner const PackedType *PTy = cast<PackedType>(VTy); 628199862b74973198c2ab5a139f664c86713e7b579Chris Lattner unsigned NumElements = PTy->getNumElements(); 629199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 630199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType TVT = MVT::getVectorType(PVT, NumElements); 631199862b74973198c2ab5a139f664c86713e7b579Chris Lattner assert(TLI.isTypeLegal(TVT) && 632199862b74973198c2ab5a139f664c86713e7b579Chris Lattner "FIXME: Cannot handle illegal vector types here yet!"); 633199862b74973198c2ab5a139f664c86713e7b579Chris Lattner VT = TVT; 6347255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner } 635199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 636199862b74973198c2ab5a139f664c86713e7b579Chris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT); 637199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 638199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT); 639199862b74973198c2ab5a139f664c86713e7b579Chris Lattner if (DestVT < VT) { 640199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // Source must be expanded. This input value is actually coming from the 641199862b74973198c2ab5a139f664c86713e7b579Chris Lattner // register pair VMI->second and VMI->second+1. 642199862b74973198c2ab5a139f664c86713e7b579Chris Lattner N = DAG.getNode(ISD::BUILD_PAIR, VT, N, 643199862b74973198c2ab5a139f664c86713e7b579Chris Lattner DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT)); 644199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } else { 645199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 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 } 651199862b74973198c2ab5a139f664c86713e7b579Chris Lattner } 652199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 653199862b74973198c2ab5a139f664c86713e7b579Chris Lattner return N; 654199862b74973198c2ab5a139f664c86713e7b579Chris Lattner} 655199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 656199862b74973198c2ab5a139f664c86713e7b579Chris Lattner 6571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitRet(ReturnInst &I) { 6581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getNumOperands() == 0) { 659a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot())); 6601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; 6611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 662ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman std::vector<SDOperand> NewValues; 663ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(getRoot()); 664ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { 665ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman SDOperand RetOp = getValue(I.getOperand(i)); 666ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman 667ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // If this is an integer return value, we need to promote it ourselves to 668ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // the full width of a register, since LegalizeOp will use ANY_EXTEND rather 669ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman // than sign/zero. 670ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (MVT::isInteger(RetOp.getValueType()) && 671ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp.getValueType() < MVT::i64) { 672ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman MVT::ValueType TmpVT; 673ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote) 674ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = TLI.getTypeToTransformTo(MVT::i32); 675ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 676ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman TmpVT = MVT::i32; 6771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 678ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman if (I.getOperand(i)->getType()->isSigned()) 679ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, RetOp); 680ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman else 681ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman RetOp = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, RetOp); 682ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman } 683ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman NewValues.push_back(RetOp); 6841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 685ee625573b5b39b91441fc6ea23f3ba415abdc71fNate Begeman DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, NewValues)); 6861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 6871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitBr(BranchInst &I) { 6891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Update machine-CFG edges. 6901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)]; 691f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(Succ0MBB); 6921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Figure out which block is immediately after the current one. 6941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *NextBlock = 0; 6951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction::iterator BBI = CurMBB; 6961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (++BBI != CurMBB->getParent()->end()) 6971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner NextBlock = BBI; 6981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 6991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.isUnconditional()) { 7001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is not a fall-through branch, emit the branch. 7011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ0MBB != NextBlock) 702a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 703dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman DAG.getBasicBlock(Succ0MBB))); 7041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 7051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)]; 706f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(Succ1MBB); 7071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 7081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getCondition()); 7091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Succ1MBB == NextBlock) { 7101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is false, fall through. This means we should branch 7111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // if the condition is true to Succ #0. 712a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 713dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ0MBB))); 7141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else if (Succ0MBB == NextBlock) { 7151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If the condition is true, fall through. This means we should branch if 7161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the condition is false to Succ #1. Invert the condition first. 7171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand True = DAG.getConstant(1, Cond.getValueType()); 7181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 719a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), 720dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman Cond, DAG.getBasicBlock(Succ1MBB))); 7211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 722e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner std::vector<SDOperand> Ops; 723e7ccd4acd2ee9753e6d212efd522be5c7de154d7Chris Lattner Ops.push_back(getRoot()); 724298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // If the false case is the current basic block, then this is a self 725298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // loop. We do not want to emit "Loop: ... brcond Out; br Loop", as it 726298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // adds an extra instruction in the loop. Instead, invert the 727298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng // condition and emit "Loop: ... br!cond Loop; br Out. 728298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng if (CurMBB == Succ1MBB) { 729298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng std::swap(Succ0MBB, Succ1MBB); 730298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng SDOperand True = DAG.getConstant(1, Cond.getValueType()); 731298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 732298ebf2bd80ca415e58bbcbd9866ee58f167b620Evan Cheng } 73381e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman SDOperand True = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 73481e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.getBasicBlock(Succ0MBB)); 73581e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, True, 73681e8097377529dc3b666f33bb525c49cfbac3f51Nate Begeman DAG.getBasicBlock(Succ1MBB))); 7371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 7391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 7401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 741f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// visitSwitchCase - Emits the necessary code to represent a single node in 742f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman/// the binary search tree resulting from lowering a switch instruction. 743f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitchCase(SelectionDAGISel::CaseBlock &CB) { 744f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand SwitchOp = getValue(CB.SwitchV); 745f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand CaseOp = getValue(CB.CaseC); 746f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand Cond = DAG.getSetCC(MVT::i1, SwitchOp, CaseOp, CB.CC); 747f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 748f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set NextBlock to be the MBB immediately after the current one, if any. 749f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // This is used to avoid emitting unnecessary branches to the next block. 750f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 751f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 752f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 753f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 754f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 755f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the lhs block is the next block, invert the condition so that we can 756f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // fall through to the lhs instead of the rhs block. 757f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CB.LHSBB == NextBlock) { 758f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::swap(CB.LHSBB, CB.RHSBB); 759f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand True = DAG.getConstant(1, Cond.getValueType()); 760f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True); 761f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 762f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDOperand BrCond = DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(), Cond, 763f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(CB.LHSBB)); 764f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CB.RHSBB == NextBlock) 765f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(BrCond); 766f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else 767f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, BrCond, 768f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(CB.RHSBB))); 769f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update successor info 770f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(CB.LHSBB); 771f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMBB->addSuccessor(CB.RHSBB); 772f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 773f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 774f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGLowering::visitSwitch(SwitchInst &I) { 775f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Figure out which block is immediately after the current one. 776f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *NextBlock = 0; 777f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction::iterator BBI = CurMBB; 778f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (++BBI != CurMBB->getParent()->end()) 779f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman NextBlock = BBI; 780f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 781f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there is only the default destination, branch to it if it is not the 782f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // next basic block. Otherwise, just fall through. 783f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (I.getNumOperands() == 2) { 784f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Update machine-CFG edges. 785f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[I.getDefaultDest()]; 786f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If this is not a fall-through branch, emit the branch. 787f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (DefaultMBB != NextBlock) 788f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(), 789f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman DAG.getBasicBlock(DefaultMBB))); 790f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 791f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 792f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 793f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If there are any non-default case statements, create a vector of Cases 794f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // representing each one, and sort the vector so that we can efficiently 795f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // create a binary search tree from them. 796f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<Case> Cases; 797f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 1; i < I.getNumSuccessors(); ++i) { 798f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *SMBB = FuncInfo.MBBMap[I.getSuccessor(i)]; 799f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Cases.push_back(Case(I.getSuccessorValue(i), SMBB)); 800f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 801f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::sort(Cases.begin(), Cases.end(), CaseCmp()); 802f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 803f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the Value to be switched on and default basic blocks, which will be 804f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // inserted into CaseBlock records, representing basic blocks in the binary 805f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // search tree. 806f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Value *SV = I.getOperand(0); 807f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Default = FuncInfo.MBBMap[I.getDefaultDest()]; 808f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 809f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Get the current MachineFunction and LLVM basic block, for use in creating 810f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // and inserting new MBBs during the creation of the binary search tree. 811f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineFunction *CurMF = CurMBB->getParent(); 812f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman const BasicBlock *LLVMBB = CurMBB->getBasicBlock(); 813f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 814f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Push the initial CaseRec onto the worklist 815f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<CaseRec> CaseVec; 816f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(CurMBB,0,0,CaseRange(Cases.begin(),Cases.end()))); 817f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 818f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman while (!CaseVec.empty()) { 819f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Grab a record representing a case range to process off the worklist 820f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRec CR = CaseVec.back(); 821f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.pop_back(); 822f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 823f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Size is the number of Cases represented by this range. If Size is 1, 824f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // then we are processing a leaf of the binary search tree. Otherwise, 825f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // we need to pick a pivot, and push left and right ranges onto the 826f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // worklist. 827f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman unsigned Size = CR.Range.second - CR.Range.first; 828f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 829f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (Size == 1) { 830f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 831f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the Case's target mbb if the value being switched on SV is equal 832f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // to C. Otherwise, branch to default. 833f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = CR.Range.first->first; 834f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *Target = CR.Range.first->second; 835f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(ISD::SETEQ, SV, C, Target, Default, 836f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CR.CaseBB); 837f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If the MBB representing the leaf node is the current MBB, then just 838f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // call visitSwitchCase to emit the code into the current block. 839f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, push the CaseBlock onto the vector to be later processed 840f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // by SDISel, and insert the node's MBB before the next MBB. 841f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 842f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 843f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else { 844f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 845f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMF->getBasicBlockList().insert(BBI, CR.CaseBB); 846f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 847f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 848f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // split case range at pivot 849f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseItr Pivot = CR.Range.first + (Size / 2); 850f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange LHSR(CR.Range.first, Pivot); 851f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseRange RHSR(Pivot, CR.Range.second); 852f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman Constant *C = Pivot->first; 853f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *RHSBB = 0, *LHSBB = 0; 854f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // We know that we branch to the LHS if the Value being switched on is 855f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // less than the Pivot value, C. We use this to optimize our binary 856f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // tree a bit, by recognizing that if SV is greater than or equal to the 857f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // LHS's Case Value, and that Case Value is exactly one less than the 858f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Pivot's Value, then we can branch directly to the LHS's Target, 859f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // rather than creating a leaf node for it. 860f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((LHSR.second - LHSR.first) == 1 && 861f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSR.first->first == CR.GE && 862f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman cast<ConstantIntegral>(C)->getRawValue() == 863f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman (cast<ConstantIntegral>(CR.GE)->getRawValue() + 1ULL)) { 864f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSBB = LHSR.first->second; 865f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 866f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman LHSBB = new MachineBasicBlock(LLVMBB); 867f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(LHSBB,C,CR.GE,LHSR)); 868f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 869f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Similar to the optimization above, if the Value being switched on is 870f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // known to be less than the Constant CR.LT, and the current Case Value 871f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // is CR.LT - 1, then we can branch directly to the target block for 872f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the current Case Value, rather than emitting a RHS leaf node for it. 873f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if ((RHSR.second - RHSR.first) == 1 && CR.LT && 874f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman cast<ConstantIntegral>(RHSR.first->first)->getRawValue() == 875f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman (cast<ConstantIntegral>(CR.LT)->getRawValue() - 1ULL)) { 876f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman RHSBB = RHSR.first->second; 877f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } else { 878f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman RHSBB = new MachineBasicBlock(LLVMBB); 879f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CaseVec.push_back(CaseRec(RHSBB,CR.LT,C,RHSR)); 880f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 881f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Create a CaseBlock record representing a conditional branch to 882f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the LHS node if the value being switched on SV is less than C. 883f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Otherwise, branch to LHS. 884f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman ISD::CondCode CC = C->getType()->isSigned() ? ISD::SETLT : ISD::SETULT; 885f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGISel::CaseBlock CB(CC, SV, C, LHSBB, RHSBB, CR.CaseBB); 886f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (CR.CaseBB == CurMBB) 887f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman visitSwitchCase(CB); 888f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman else { 889f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.push_back(CB); 890f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurMF->getBasicBlockList().insert(BBI, CR.CaseBB); 891f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 892f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 893f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 894f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 895f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 896b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattnervoid SelectionDAGLowering::visitSub(User &I) { 897b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner // -0.0 - X --> fneg 89801b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (I.getType()->isFloatingPoint()) { 89901b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) 90001b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner if (CFP->isExactlyValue(-0.0)) { 90101b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 90201b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2)); 90301b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner return; 90401b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 90501b3d73c20f5afb8265ae943a8ba23c2238c5eeaChris Lattner } 9065fbb5d2459a5410590f285250faa604576308a93Nate Begeman visitBinary(I, ISD::SUB, ISD::FSUB, ISD::VSUB); 907b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner} 908b9fccc41933648647e3f7669612c683eb5de0d58Chris Lattner 9095fbb5d2459a5410590f285250faa604576308a93Nate Begemanvoid SelectionDAGLowering::visitBinary(User &I, unsigned IntOp, unsigned FPOp, 9105fbb5d2459a5410590f285250faa604576308a93Nate Begeman unsigned VecOp) { 9115fbb5d2459a5410590f285250faa604576308a93Nate Begeman const Type *Ty = I.getType(); 9121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 9131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 9142c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 915b67eb9131c5c04d2e55c6b587fde954619feceafChris Lattner if (Ty->isIntegral()) { 9165fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(IntOp, Op1.getValueType(), Op1, Op2)); 9175fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else if (Ty->isFloatingPoint()) { 9185fbb5d2459a5410590f285250faa604576308a93Nate Begeman setValue(&I, DAG.getNode(FPOp, Op1.getValueType(), Op1, Op2)); 9195fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 9205fbb5d2459a5410590f285250faa604576308a93Nate Begeman const PackedType *PTy = cast<PackedType>(Ty); 921c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Num = DAG.getConstant(PTy->getNumElements(), MVT::i32); 922c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand Typ = DAG.getValueType(TLI.getValueType(PTy->getElementType())); 923c7029805ef35ce9805931067b841e6af11db382eChris Lattner setValue(&I, DAG.getNode(VecOp, MVT::Vector, Op1, Op2, Num, Typ)); 9245fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 925e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman} 9262c49f2795514a7c56b680ba0310d7eb0a8a43289Chris Lattner 927e21ea61588996609f827213a2701a204f2f13fb3Nate Begemanvoid SelectionDAGLowering::visitShift(User &I, unsigned Opcode) { 928e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op1 = getValue(I.getOperand(0)); 929e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman SDOperand Op2 = getValue(I.getOperand(1)); 930e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 931e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2); 932e21ea61588996609f827213a2701a204f2f13fb3Nate Begeman 9331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2)); 9341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode, 9371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode UnsignedOpcode) { 9381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op1 = getValue(I.getOperand(0)); 9391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Op2 = getValue(I.getOperand(1)); 9401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ISD::CondCode Opcode = SignedOpcode; 9411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getOperand(0)->getType()->isUnsigned()) 9421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Opcode = UnsignedOpcode; 9437cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode)); 9441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitSelect(User &I) { 9471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Cond = getValue(I.getOperand(0)); 9481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand TrueVal = getValue(I.getOperand(1)); 9491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand FalseVal = getValue(I.getOperand(2)); 9501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond, 9511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TrueVal, FalseVal)); 9521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 9531c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 9541c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCast(User &I) { 9551c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 956e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType SrcVT = N.getValueType(); 95728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner MVT::ValueType DestVT = TLI.getValueType(I.getType()); 9581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 959e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner if (DestVT == MVT::Vector) { 960e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast to a vector from something else. This is always a bit 961e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 962e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 963e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 964e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N, 965e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getConstant(DestTy->getNumElements(),MVT::i32), 966e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner DAG.getValueType(EltVT))); 967e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (SrcVT == DestVT) { 9681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); // noop cast. 96928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (DestVT == MVT::i1) { 970ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner // Cast to bool is a comparison against zero, not truncation to zero. 97128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand Zero = isInteger(SrcVT) ? DAG.getConstant(0, N.getValueType()) : 972ef311aa7cf26ae0cbb6e784d767801b9058dd24bChris Lattner DAG.getConstantFP(0.0, N.getValueType()); 9737cf7e3f33f25544d08492d47cc8a1cbba25dc8d7Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE)); 97428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isInteger(SrcVT)) { 97528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isInteger(DestVT)) { // Int -> Int cast 97628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Truncating cast? 97728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::TRUNCATE, DestVT, N)); 978ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else if (I.getOperand(0)->getType()->isSigned()) 97928b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestVT, N)); 980ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 98128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestVT, N)); 9827e358908b885f50fb9258b7d10509bad20ca4c3bChris Lattner } else if (isFloatingPoint(DestVT)) { // Int -> FP cast 983ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getOperand(0)->getType()->isSigned()) 98428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestVT, N)); 985ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 98628b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestVT, N)); 987e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 988e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 989ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 99028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else if (isFloatingPoint(SrcVT)) { 99128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isFloatingPoint(DestVT)) { // FP -> FP cast 99228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (DestVT < SrcVT) // Rounding cast? 99328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_ROUND, DestVT, N)); 994ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 99528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestVT, N)); 996e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else if (isInteger(DestVT)) { // FP -> Int cast. 997ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner if (I.getType()->isSigned()) 99828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestVT, N)); 999ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner else 100028b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestVT, N)); 100128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner } else { 1002e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(0 && "Unknown cast!"); 1003ae0aacb8331e1227abea6601e531a10d0e65fdcaChris Lattner } 1004e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner } else { 1005e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(SrcVT == MVT::Vector && "Unknown cast!"); 1006e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner assert(DestVT != MVT::Vector && "Casts to vector already handled!"); 1007e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // This is a cast from a vector to something else. This is always a bit 1008e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner // convert. Get information about the input vector. 1009e25ca692c0478af5e15170fce23cea2a5b5fd0b9Chris Lattner setValue(&I, DAG.getNode(ISD::VBIT_CONVERT, DestVT, N)); 10101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10121c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10132bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitInsertElement(User &I) { 1014c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1015c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InVal = getValue(I.getOperand(1)); 1016c7029805ef35ce9805931067b841e6af11db382eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1017c7029805ef35ce9805931067b841e6af11db382eChris Lattner getValue(I.getOperand(2))); 1018c7029805ef35ce9805931067b841e6af11db382eChris Lattner 10192332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Num = *(InVec.Val->op_end()-2); 10202332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 10212332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner setValue(&I, DAG.getNode(ISD::VINSERT_VECTOR_ELT, MVT::Vector, 10222332b9f16fe17d1886566729b2241b8cd90f9916Chris Lattner InVec, InVal, InIdx, Num, Typ)); 1023c7029805ef35ce9805931067b841e6af11db382eChris Lattner} 1024c7029805ef35ce9805931067b841e6af11db382eChris Lattner 10252bbd81064a6998496a71ff7ae8160b3caada64faChris Lattnervoid SelectionDAGLowering::visitExtractElement(User &I) { 1026384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InVec = getValue(I.getOperand(0)); 1027384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand InIdx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), 1028384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner getValue(I.getOperand(1))); 1029384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner SDOperand Typ = *(InVec.Val->op_end()-1); 1030384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner setValue(&I, DAG.getNode(ISD::VEXTRACT_VECTOR_ELT, 1031384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner TLI.getValueType(I.getType()), InVec, InIdx)); 1032384504cea6c392125a2318d8bbb7f25aa0bbff7eChris Lattner} 1033c7029805ef35ce9805931067b841e6af11db382eChris Lattner 10341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitGetElementPtr(User &I) { 10351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand N = getValue(I.getOperand(0)); 10361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getOperand(0)->getType(); 10371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 10381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end(); 10401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner OI != E; ++OI) { 10411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Idx = *OI; 1042c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 10431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 10441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Field) { 10451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // N = N + Offset 10461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field]; 10471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, 1048dedf2bd5a34dac25e4245f58bb902ced6b64edd9Misha Brukman getIntPtrConstant(Offset)); 10491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = StTy->getElementType(Field); 10511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } else { 10521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 10537c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 10547c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a constant subscript, handle it quickly. 10557c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 10567c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (CI->getRawValue() == 0) continue; 10577c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 10587c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t Offs; 10597c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 10607c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 10617c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 10627c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner Offs = TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 10637c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs)); 10647c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 10657c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } 10667c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 10677c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // N = N + Idx * ElementSize; 10687c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 10697c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand IdxN = getValue(Idx); 10707c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 10717c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If the index is smaller or larger than intptr_t, truncate or extend 10727c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // it. 10737c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (IdxN.getValueType() < N.getValueType()) { 10747c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (Idx->getType()->isSigned()) 10757c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN); 10767c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner else 10777c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN); 10787c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner } else if (IdxN.getValueType() > N.getValueType()) 10797c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN); 10807c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 10817c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // If this is a multiply by a power of two, turn it into a shl 10827c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner // immediately. This is a very common case. 10837c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner if (isPowerOf2_64(ElementSize)) { 10847c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner unsigned Amt = Log2_64(ElementSize); 10857c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN, 10866b2d69655ace2788b244c8a4ebcfb6f2a926ad92Chris Lattner DAG.getConstant(Amt, TLI.getShiftAmountTy())); 10871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 10887c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner continue; 10891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10907c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner 10917c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner SDOperand Scale = getIntPtrConstant(ElementSize); 10927c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale); 10937c0104b525a4ba8b5268ee5455f92b011f7cc263Chris Lattner N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN); 10941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10951c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 10961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner setValue(&I, N); 10971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 10981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 10991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitAlloca(AllocaInst &I) { 11001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is a fixed sized alloca in the entry block of the function, 11011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // allocate it statically on the stack. 11021c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (FuncInfo.StaticAllocaMap.count(&I)) 11031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return; // getValue will auto-populate this. 11041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner const Type *Ty = I.getAllocatedType(); 11061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t TySize = TLI.getTargetData().getTypeSize(Ty); 1107ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman unsigned Align = std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty), 1108ae232e7a1055033436370c0b3aecf054fa44d5e7Nate Begeman I.getAlignment()); 11091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand AllocSize = getValue(I.getArraySize()); 111168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 111268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < AllocSize.getValueType()) 111368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize); 111468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > AllocSize.getValueType()) 111568cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize); 11161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 111768cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize, 11181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(TySize)); 11191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle alignment. If the requested alignment is less than or equal to the 11211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment, ignore it and round the size of the allocation up to the 11221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // stack alignment size. If the size is greater than the stack alignment, we 11231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // note this in the DYNAMIC_STACKALLOC node. 11241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner unsigned StackAlign = 11251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetMachine().getFrameInfo()->getStackAlignment(); 11261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (Align <= StackAlign) { 11271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Align = 0; 11281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Add SA-1 to the size. 11291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize, 11301c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(StackAlign-1)); 11311c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Mask out the low bits for alignment purposes. 11321c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize, 11331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner getIntPtrConstant(~(uint64_t)(StackAlign-1))); 11341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 11351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1136adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<MVT::ValueType> VTs; 1137adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(AllocSize.getValueType()); 1138adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner VTs.push_back(MVT::Other); 1139adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner std::vector<SDOperand> Ops; 1140adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getRoot()); 1141adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(AllocSize); 1142adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner Ops.push_back(getIntPtrConstant(Align)); 1143adf6c2a0cb638e8b211200b57b927d16f6e1cfc4Chris Lattner SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); 11441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DAG.setRoot(setValue(&I, DSA).getValue(1)); 11451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Inform the Frame Information that we have just allocated a variable-sized 11471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // object. 11481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject(); 11491c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11501c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitLoad(LoadInst &I) { 11521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(0)); 1153edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1154d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner SDOperand Root; 1155d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner if (I.isVolatile()) 1156d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = getRoot(); 1157d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else { 1158d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner // Do not serialize non-volatile loads against each other. 1159d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner Root = DAG.getRoot(); 1160d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner } 116128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 116228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner setValue(&I, getLoadFrom(I.getType(), Ptr, DAG.getSrcValue(I.getOperand(0)), 116328b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner Root, I.isVolatile())); 116428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner} 116528b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 116628b5b1c7b54c2065882b98af2406c38a3bcee802Chris LattnerSDOperand SelectionDAGLowering::getLoadFrom(const Type *Ty, SDOperand Ptr, 116728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner SDOperand SrcValue, SDOperand Root, 116828b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner bool isVolatile) { 11695fbb5d2459a5410590f285250faa604576308a93Nate Begeman SDOperand L; 11708cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 11714ef3b817fee7ea5be7219e00ab8e15976bfe279fNate Begeman MVT::ValueType PVT = TLI.getValueType(PTy->getElementType()); 1172c7029805ef35ce9805931067b841e6af11db382eChris Lattner L = DAG.getVecLoad(PTy->getNumElements(), PVT, Root, Ptr, SrcValue); 11735fbb5d2459a5410590f285250faa604576308a93Nate Begeman } else { 117428b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner L = DAG.getLoad(TLI.getValueType(Ty), Root, Ptr, SrcValue); 11755fbb5d2459a5410590f285250faa604576308a93Nate Begeman } 1176d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner 117728b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner if (isVolatile) 1178d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner DAG.setRoot(L.getValue(1)); 1179d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner else 1180d3948116b81b11e82246c11389a9b4ce7e619fbbChris Lattner PendingLoads.push_back(L.getValue(1)); 118128b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner 118228b5b1c7b54c2065882b98af2406c38a3bcee802Chris Lattner return L; 11831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitStore(StoreInst &I) { 11871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *SrcV = I.getOperand(0); 11881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(SrcV); 11891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Ptr = getValue(I.getOperand(1)); 1190369e6db9b6033bb60519b0ad84afeacc9ec9b416Chris Lattner DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr, 119106ef88472f7bac3512e224974e87a0a456471b82Andrew Lenharth DAG.getSrcValue(I.getOperand(1)))); 11921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 11931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 11940eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// IntrinsicCannotAccessMemory - Return true if the specified intrinsic cannot 11950eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// access memory and has no other side effects at all. 11960eade319cdb72e24c11d068728a98083737c6435Chris Lattnerstatic bool IntrinsicCannotAccessMemory(unsigned IntrinsicID) { 11970eade319cdb72e24c11d068728a98083737c6435Chris Lattner#define GET_NO_MEMORY_INTRINSICS 11980eade319cdb72e24c11d068728a98083737c6435Chris Lattner#include "llvm/Intrinsics.gen" 11990eade319cdb72e24c11d068728a98083737c6435Chris Lattner#undef GET_NO_MEMORY_INTRINSICS 12000eade319cdb72e24c11d068728a98083737c6435Chris Lattner return false; 12010eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 12020eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12030eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC 12040eade319cdb72e24c11d068728a98083737c6435Chris Lattner/// node. 12050eade319cdb72e24c11d068728a98083737c6435Chris Lattnervoid SelectionDAGLowering::visitTargetIntrinsic(CallInst &I, 12060eade319cdb72e24c11d068728a98083737c6435Chris Lattner unsigned Intrinsic) { 12077255a545613f9e713779ca81f55711c0863d9cc9Chris Lattner bool HasChain = !IntrinsicCannotAccessMemory(Intrinsic); 12080eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12090eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Build the operand list. 12100eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<SDOperand> Ops; 12110eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) // If this intrinsic has side-effects, chainify it. 12120eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(getRoot()); 12130eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12140eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add the intrinsic ID as an integer operand. 12150eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy())); 12160eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12170eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Add all operands of the call to the operand list. 12180eade319cdb72e24c11d068728a98083737c6435Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 12190eade319cdb72e24c11d068728a98083737c6435Chris Lattner SDOperand Op = getValue(I.getOperand(i)); 12200eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12210eade319cdb72e24c11d068728a98083737c6435Chris Lattner // If this is a vector type, force it to the right packed type. 12220eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (Op.getValueType() == MVT::Vector) { 12230eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *OpTy = cast<PackedType>(I.getOperand(i)->getType()); 12240eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(OpTy->getElementType()); 12250eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12260eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VVT = MVT::getVectorType(EltVT, OpTy->getNumElements()); 12270eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VVT != MVT::Other && "Intrinsic uses a non-legal type?"); 12280eade319cdb72e24c11d068728a98083737c6435Chris Lattner Op = DAG.getNode(ISD::VBIT_CONVERT, VVT, Op); 12290eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 12300eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12310eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(Op.getValueType()) && 12320eade319cdb72e24c11d068728a98083737c6435Chris Lattner "Intrinsic uses a non-legal type?"); 12330eade319cdb72e24c11d068728a98083737c6435Chris Lattner Ops.push_back(Op); 12340eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 12350eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12360eade319cdb72e24c11d068728a98083737c6435Chris Lattner std::vector<MVT::ValueType> VTs; 12370eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 12380eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType VT = TLI.getValueType(I.getType()); 12390eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (VT == MVT::Vector) { 12400eade319cdb72e24c11d068728a98083737c6435Chris Lattner const PackedType *DestTy = cast<PackedType>(I.getType()); 12410eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EltVT = TLI.getValueType(DestTy->getElementType()); 12420eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12430eade319cdb72e24c11d068728a98083737c6435Chris Lattner VT = MVT::getVectorType(EltVT, DestTy->getNumElements()); 12440eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(VT != MVT::Other && "Intrinsic uses a non-legal type?"); 12450eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 12460eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12470eade319cdb72e24c11d068728a98083737c6435Chris Lattner assert(TLI.isTypeLegal(VT) && "Intrinsic uses a non-legal type?"); 12480eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(VT); 12490eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 12500eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 12510eade319cdb72e24c11d068728a98083737c6435Chris Lattner VTs.push_back(MVT::Other); 12520eade319cdb72e24c11d068728a98083737c6435Chris Lattner 12530eade319cdb72e24c11d068728a98083737c6435Chris Lattner // Create the node. 125448b61a729df6576c8833a83893d4086bddff69a5Chris Lattner SDOperand Result; 125548b61a729df6576c8833a83893d4086bddff69a5Chris Lattner if (!HasChain) 125648b61a729df6576c8833a83893d4086bddff69a5Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VTs, Ops); 125748b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else if (I.getType() != Type::VoidTy) 125848b61a729df6576c8833a83893d4086bddff69a5Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, VTs, Ops); 125948b61a729df6576c8833a83893d4086bddff69a5Chris Lattner else 126048b61a729df6576c8833a83893d4086bddff69a5Chris Lattner Result = DAG.getNode(ISD::INTRINSIC_VOID, VTs, Ops); 126148b61a729df6576c8833a83893d4086bddff69a5Chris Lattner 12620eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (HasChain) 12630eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.setRoot(Result.getValue(Result.Val->getNumValues()-1)); 12640eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (I.getType() != Type::VoidTy) { 12650eade319cdb72e24c11d068728a98083737c6435Chris Lattner if (const PackedType *PTy = dyn_cast<PackedType>(I.getType())) { 12660eade319cdb72e24c11d068728a98083737c6435Chris Lattner MVT::ValueType EVT = TLI.getValueType(PTy->getElementType()); 12670eade319cdb72e24c11d068728a98083737c6435Chris Lattner Result = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, Result, 12680eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getConstant(PTy->getNumElements(), MVT::i32), 12690eade319cdb72e24c11d068728a98083737c6435Chris Lattner DAG.getValueType(EVT)); 12700eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 12710eade319cdb72e24c11d068728a98083737c6435Chris Lattner setValue(&I, Result); 12720eade319cdb72e24c11d068728a98083737c6435Chris Lattner } 12730eade319cdb72e24c11d068728a98083737c6435Chris Lattner} 12740eade319cdb72e24c11d068728a98083737c6435Chris Lattner 1275c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// visitIntrinsicCall - Lower the call to the specified intrinsic function. If 1276c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// we want to emit this as a call to a named external function, return the name 1277c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner/// otherwise lower it and return null. 1278c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattnerconst char * 1279c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris LattnerSelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { 1280c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner switch (Intrinsic) { 12810eade319cdb72e24c11d068728a98083737c6435Chris Lattner default: 12820eade319cdb72e24c11d068728a98083737c6435Chris Lattner // By default, turn this into a target intrinsic node. 12830eade319cdb72e24c11d068728a98083737c6435Chris Lattner visitTargetIntrinsic(I, Intrinsic); 12840eade319cdb72e24c11d068728a98083737c6435Chris Lattner return 0; 1285c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vastart: visitVAStart(I); return 0; 1286c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vaend: visitVAEnd(I); return 0; 1287c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::vacopy: visitVACopy(I); return 0; 1288c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return 0; 1289c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return 0; 1290c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::setjmp: 1291c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1292c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 1293c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::longjmp: 1294c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp(); 1295c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner break; 129603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i32: 129703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memcpy_i64: 129803dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMCPY); 129903dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 130003dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i32: 130103dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memset_i64: 130203dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMSET); 130303dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 130403dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i32: 130503dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner case Intrinsic::memmove_i64: 130603dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner visitMemIntrinsic(I, ISD::MEMMOVE); 130703dd4652158f8a4c1db65f066195342d4a3695a7Chris Lattner return 0; 1308c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 130986cb643801be1308ba1da7db774b64852a119e94Chris Lattner case Intrinsic::dbg_stoppoint: { 1310ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 131143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgStopPointInst &SPI = cast<DbgStopPointInst>(I); 1312fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && SPI.getContext() && DebugInfo->Verify(SPI.getContext())) { 1313ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey std::vector<SDOperand> Ops; 131436ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner 1315ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey Ops.push_back(getRoot()); 131643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getValue(SPI.getLineValue())); 131743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getValue(SPI.getColumnValue())); 1318ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 131943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfoDesc *DD = DebugInfo->getDescFor(SPI.getContext()); 1320ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey assert(DD && "Not a debug information descriptor"); 132143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey CompileUnitDesc *CompileUnit = cast<CompileUnitDesc>(DD); 132243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1323ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey Ops.push_back(DAG.getString(CompileUnit->getFileName())); 1324ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey Ops.push_back(DAG.getString(CompileUnit->getDirectory())); 1325ce72b1755f5993a42c2e04e32a93fa5228a285d4Jim Laskey 132643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::LOCATION, MVT::Other, Ops)); 132786cb643801be1308ba1da7db774b64852a119e94Chris Lattner } 132843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1329b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 133036ce69195ed488034d0bb11180cc2ebd923679c8Chris Lattner } 133143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_start: { 133243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 133343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I); 1334fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && RSI.getContext() && DebugInfo->Verify(RSI.getContext())) { 133543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 133643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 133743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(RSI.getContext()); 133843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 133943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getRoot()); 134043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(DAG.getConstant(LabelID, MVT::i32)); 134143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 134243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops)); 134343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 134443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1345b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 134643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 134743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_region_end: { 134843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 134943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I); 1350fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && REI.getContext() && DebugInfo->Verify(REI.getContext())) { 135143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 135243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 135343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionEnd(REI.getContext()); 135443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 135543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getRoot()); 135643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(DAG.getConstant(LabelID, MVT::i32)); 135743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 135843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops)); 135943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 136043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1361b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 136243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 136343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_func_start: { 136443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 136543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgFuncStartInst &FSI = cast<DbgFuncStartInst>(I); 1366fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey if (DebugInfo && FSI.getSubprogram() && 1367fbcf23c3c12449c264f1448a2eee524be0b799f7Jim Laskey DebugInfo->Verify(FSI.getSubprogram())) { 136843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 136943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 137043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey unsigned LabelID = DebugInfo->RecordRegionStart(FSI.getSubprogram()); 137143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 137243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(getRoot()); 137343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey Ops.push_back(DAG.getConstant(LabelID, MVT::i32)); 137443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 137543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DAG.setRoot(DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Ops)); 137643970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 137743970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 1378b1a5a5c4c0182205b91b962def7b008228a1f7e6Chris Lattner return 0; 137943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 138043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey case Intrinsic::dbg_declare: { 138143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey MachineDebugInfo *DebugInfo = DAG.getMachineDebugInfo(); 138243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DbgDeclareInst &DI = cast<DbgDeclareInst>(I); 1383bf7637d59028a5d9911769810f537c499e23bb8eJim Laskey if (DebugInfo && DI.getVariable() && DebugInfo->Verify(DI.getVariable())) { 138443970fec322d9e0153ca513de41d80af1c79bddeJim Laskey std::vector<SDOperand> Ops; 138543970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 13860892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey SDOperand AddressOp = getValue(DI.getAddress()); 13870892cee81fa8c1ea6a0901b268fe9ad2b8fa733aJim Laskey if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(AddressOp)) { 138843970fec322d9e0153ca513de41d80af1c79bddeJim Laskey DebugInfo->RecordVariable(DI.getVariable(), FI->getIndex()); 138943970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 139043970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 139143970fec322d9e0153ca513de41d80af1c79bddeJim Laskey 139243970fec322d9e0153ca513de41d80af1c79bddeJim Laskey return 0; 139343970fec322d9e0153ca513de41d80af1c79bddeJim Laskey } 1394c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 13950b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f32: 13960b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::isunordered_f64: 1397c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)), 1398c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(2)), ISD::SETUO)); 1399c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1400c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 14010b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f32: 14020b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::sqrt_f64: 1403c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::FSQRT, 1404c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1405c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1406c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1407c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner case Intrinsic::pcmarker: { 1408c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1409c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp)); 1410c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1411c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 14128b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth case Intrinsic::readcyclecounter: { 14138b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<MVT::ValueType> VTs; 14148b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::i64); 14158b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth VTs.push_back(MVT::Other); 14168b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth std::vector<SDOperand> Ops; 14178b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth Ops.push_back(getRoot()); 14188b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth SDOperand Tmp = DAG.getNode(ISD::READCYCLECOUNTER, VTs, Ops); 14198b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth setValue(&I, Tmp); 14208b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth DAG.setRoot(Tmp.getValue(1)); 142151b8d54922350b7e1c2cd5a5183ef2c5f5d1b1d5Andrew Lenharth return 0; 14228b91c77385a055474d271aa8c10f0382fdeaafebAndrew Lenharth } 1423d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i16: 1424d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i32: 1425d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman case Intrinsic::bswap_i64: 1426d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman setValue(&I, DAG.getNode(ISD::BSWAP, 1427d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)).getValueType(), 1428d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman getValue(I.getOperand(1)))); 1429d88fc03602947b5baa35c8b09fe8bcfa2b4a03c1Nate Begeman return 0; 14300b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i8: 14310b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i16: 14320b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i32: 14330b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::cttz_i64: 1434c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTTZ, 1435c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1436c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1437c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 14380b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i8: 14390b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i16: 14400b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i32: 14410b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctlz_i64: 1442c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTLZ, 1443c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1444c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1445c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 14460b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i8: 14470b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i16: 14480b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i32: 14490b118206bf3411722707f2e5cab8fd2eedcd50d6Reid Spencer case Intrinsic::ctpop_i64: 1450c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner setValue(&I, DAG.getNode(ISD::CTPOP, 1451c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)).getValueType(), 1452c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner getValue(I.getOperand(1)))); 1453c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return 0; 1454140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner case Intrinsic::stacksave: { 1455140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<MVT::ValueType> VTs; 1456140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(TLI.getPointerTy()); 1457140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner VTs.push_back(MVT::Other); 1458140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner std::vector<SDOperand> Ops; 1459140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner Ops.push_back(getRoot()); 1460140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner SDOperand Tmp = DAG.getNode(ISD::STACKSAVE, VTs, Ops); 1461140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner setValue(&I, Tmp); 1462140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner DAG.setRoot(Tmp.getValue(1)); 1463140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 1464140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner } 146539a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner case Intrinsic::stackrestore: { 146639a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 146739a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, MVT::Other, getRoot(), Tmp)); 1468140d53c99c3a70b9d3858a3c87f8ecb098994748Chris Lattner return 0; 146939a17dd31ddc4af6067940cb31e2c7d380773478Chris Lattner } 1470ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner case Intrinsic::prefetch: 1471ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner // FIXME: Currently discarding prefetches. 1472ac22c83e6853c759a10eb7310b019b22e1d42d16Chris Lattner return 0; 1473c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1474c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner} 1475c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 1476c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 14771c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitCall(CallInst &I) { 147864e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner const char *RenameFn = 0; 1479c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (Function *F = I.getCalledFunction()) { 1480c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (F->isExternal()) 1481c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (unsigned IID = F->getIntrinsicID()) { 1482c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner RenameFn = visitIntrinsicCall(I, IID); 1483c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner if (!RenameFn) 1484c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner return; 1485c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else { // Not an LLVM intrinsic. 1486c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner const std::string &Name = F->getName(); 1487a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (Name[0] == 'c' && (Name == "copysign" || Name == "copysignf")) { 1488a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner if (I.getNumOperands() == 3 && // Basic sanity checks. 1489a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1490a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(1)->getType() && 1491a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner I.getType() == I.getOperand(2)->getType()) { 1492a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand LHS = getValue(I.getOperand(1)); 1493a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner SDOperand RHS = getValue(I.getOperand(2)); 1494a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner setValue(&I, DAG.getNode(ISD::FCOPYSIGN, LHS.getValueType(), 1495a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner LHS, RHS)); 1496a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner return; 1497a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } 1498a09f848c11c9db3c2614e0275a3256310ac26653Chris Lattner } else if (Name[0] == 'f' && (Name == "fabs" || Name == "fabsf")) { 1499c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1500c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 1501c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1502c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1503c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp)); 1504c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner return; 1505c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1506c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 's' && (Name == "sin" || Name == "sinf")) { 1507f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1508f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 150906a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1510c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1511f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp)); 1512f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1513f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1514c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } else if (Name[0] == 'c' && (Name == "cos" || Name == "cosf")) { 1515f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner if (I.getNumOperands() == 2 && // Basic sanity checks. 1516f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner I.getOperand(1)->getType()->isFloatingPoint() && 151706a248c9b398049d41cf6dd1a3f9eecc75603401Chris Lattner I.getType() == I.getOperand(1)->getType()) { 1518c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner SDOperand Tmp = getValue(I.getOperand(1)); 1519f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp)); 1520f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner return; 1521f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1522f76e7dc8d8ac1855ef59698e82c757548ef4ca65Chris Lattner } 1523c0f18152d94bf65061fab4b80869998cfb0439e1Chris Lattner } 1524ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner } else if (isa<InlineAsm>(I.getOperand(0))) { 1525ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner visitInlineAsm(I); 1526ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner return; 1527c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner } 1528edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 152964e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner SDOperand Callee; 153064e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner if (!RenameFn) 153164e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = getValue(I.getOperand(0)); 153264e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner else 153364e14b1679fa3649b286402ea254d663ac43ef91Chris Lattner Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); 15341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 1535c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner Args.reserve(I.getNumOperands()); 15361c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 15371c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Value *Arg = I.getOperand(i); 15381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand ArgNode = getValue(Arg); 15391c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(ArgNode, Arg->getType())); 15401c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 1541edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 15428e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType()); 15438e21e71b248365c69c0f666518c378b5819ce6fbNate Begeman const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); 1544edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 1545cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 15469092fa310c8b2b1645b0d448c4c34b1e8ddc131dChris Lattner TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(), 1547adf6a965a321372c640845407195594835921eb4Chris Lattner I.isTailCall(), Callee, Args, DAG); 15481c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (I.getType() != Type::VoidTy) 1549cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); 1550cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 15511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 15521c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 1553864635ad7b3046d3042311423071152c613961deChris LattnerSDOperand RegsForValue::getCopyFromRegs(SelectionDAG &DAG, 15549f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag)const{ 1555864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Val = DAG.getCopyFromReg(Chain, Regs[0], RegVT, Flag); 1556864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 1557864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 1558864635ad7b3046d3042311423071152c613961deChris Lattner 1559864635ad7b3046d3042311423071152c613961deChris Lattner // If the result was expanded, copy from the top part. 1560864635ad7b3046d3042311423071152c613961deChris Lattner if (Regs.size() > 1) { 1561864635ad7b3046d3042311423071152c613961deChris Lattner assert(Regs.size() == 2 && 1562864635ad7b3046d3042311423071152c613961deChris Lattner "Cannot expand to more than 2 elts yet!"); 1563864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand Hi = DAG.getCopyFromReg(Chain, Regs[1], RegVT, Flag); 1564864635ad7b3046d3042311423071152c613961deChris Lattner Chain = Val.getValue(1); 1565864635ad7b3046d3042311423071152c613961deChris Lattner Flag = Val.getValue(2); 15669f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (DAG.getTargetLoweringInfo().isLittleEndian()) 15679f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Val, Hi); 15689f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner else 15699f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner return DAG.getNode(ISD::BUILD_PAIR, ValueVT, Hi, Val); 1570864635ad7b3046d3042311423071152c613961deChris Lattner } 1571864635ad7b3046d3042311423071152c613961deChris Lattner 1572864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, if the return value was promoted, truncate it to the 1573864635ad7b3046d3042311423071152c613961deChris Lattner // appropriate type. 1574864635ad7b3046d3042311423071152c613961deChris Lattner if (RegVT == ValueVT) 1575864635ad7b3046d3042311423071152c613961deChris Lattner return Val; 1576864635ad7b3046d3042311423071152c613961deChris Lattner 1577864635ad7b3046d3042311423071152c613961deChris Lattner if (MVT::isInteger(RegVT)) 1578864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::TRUNCATE, ValueVT, Val); 1579864635ad7b3046d3042311423071152c613961deChris Lattner else 1580864635ad7b3046d3042311423071152c613961deChris Lattner return DAG.getNode(ISD::FP_ROUND, ValueVT, Val); 1581864635ad7b3046d3042311423071152c613961deChris Lattner} 1582864635ad7b3046d3042311423071152c613961deChris Lattner 1583c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// getCopyToRegs - Emit a series of CopyToReg nodes that copies the 1584c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// specified value into the registers specified by this object. This uses 1585c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// Chain/Flag as the input and updates them for the output Chain/Flag. 1586c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::getCopyToRegs(SDOperand Val, SelectionDAG &DAG, 15879f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner SDOperand &Chain, SDOperand &Flag) const { 1588c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (Regs.size() == 1) { 1589c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // If there is a single register and the types differ, this must be 1590c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // a promotion. 1591c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (RegVT != ValueVT) { 1592c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (MVT::isInteger(RegVT)) 1593c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::ANY_EXTEND, RegVT, Val); 1594c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner else 1595c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Val = DAG.getNode(ISD::FP_EXTEND, RegVT, Val); 1596c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1597c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Chain = DAG.getCopyToReg(Chain, Regs[0], Val, Flag); 1598c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 1599c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } else { 16009f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<unsigned> R(Regs); 16019f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner if (!DAG.getTargetLoweringInfo().isLittleEndian()) 16029f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::reverse(R.begin(), R.end()); 16039f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner 16049f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner for (unsigned i = 0, e = R.size(); i != e; ++i) { 1605c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner SDOperand Part = DAG.getNode(ISD::EXTRACT_ELEMENT, RegVT, Val, 1606c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner DAG.getConstant(i, MVT::i32)); 16079f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner Chain = DAG.getCopyToReg(Chain, R[i], Part, Flag); 1608c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Flag = Chain.getValue(1); 1609c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1610c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1611c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 1612864635ad7b3046d3042311423071152c613961deChris Lattner 1613c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// AddInlineAsmOperands - Add this value to the specified inlineasm node 1614c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// operand list. This adds the code marker and includes the number of 1615c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner/// values added into it. 1616c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattnervoid RegsForValue::AddInlineAsmOperands(unsigned Code, SelectionDAG &DAG, 16179f6637db10642fae51fa3628b7833c6999f7fdb3Chris Lattner std::vector<SDOperand> &Ops) const { 1618c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getConstant(Code | (Regs.size() << 3), MVT::i32)); 1619c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = Regs.size(); i != e; ++i) 1620c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Ops.push_back(DAG.getRegister(Regs[i], RegVT)); 1621c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner} 1622864635ad7b3046d3042311423071152c613961deChris Lattner 1623864635ad7b3046d3042311423071152c613961deChris Lattner/// isAllocatableRegister - If the specified register is safe to allocate, 1624864635ad7b3046d3042311423071152c613961deChris Lattner/// i.e. it isn't a stack pointer or some other special register, return the 1625864635ad7b3046d3042311423071152c613961deChris Lattner/// register class for the register. Otherwise, return null. 1626864635ad7b3046d3042311423071152c613961deChris Lattnerstatic const TargetRegisterClass * 16279b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris LattnerisAllocatableRegister(unsigned Reg, MachineFunction &MF, 16289b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetLowering &TLI, const MRegisterInfo *MRI) { 16299b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (MRegisterInfo::regclass_iterator RCI = MRI->regclass_begin(), 16309b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = MRI->regclass_end(); RCI != E; ++RCI) { 16319b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = *RCI; 16329b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // If none of the the value types for this register class are valid, we 16339b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner // can't use it. For example, 64-bit reg classes on 32-bit targets. 16349b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner bool isLegal = false; 16359b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end(); 16369b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner I != E; ++I) { 16379b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (TLI.isTypeLegal(*I)) { 16389b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner isLegal = true; 16399b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner break; 16409b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 16419b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner } 16429b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 16439b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner if (!isLegal) continue; 16449b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner 1645864635ad7b3046d3042311423071152c613961deChris Lattner // NOTE: This isn't ideal. In particular, this might allocate the 1646864635ad7b3046d3042311423071152c613961deChris Lattner // frame pointer in functions that need it (due to them not being taken 1647864635ad7b3046d3042311423071152c613961deChris Lattner // out of allocation, because a variable sized allocation hasn't been seen 1648864635ad7b3046d3042311423071152c613961deChris Lattner // yet). This is a slight code pessimization, but should still work. 16499b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF), 16509b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner E = RC->allocation_order_end(MF); I != E; ++I) 1651864635ad7b3046d3042311423071152c613961deChris Lattner if (*I == Reg) 16529b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner return RC; 1653864635ad7b3046d3042311423071152c613961deChris Lattner } 1654864635ad7b3046d3042311423071152c613961deChris Lattner return 0; 1655864635ad7b3046d3042311423071152c613961deChris Lattner} 1656864635ad7b3046d3042311423071152c613961deChris Lattner 1657864635ad7b3046d3042311423071152c613961deChris LattnerRegsForValue SelectionDAGLowering:: 1658864635ad7b3046d3042311423071152c613961deChris LattnerGetRegistersForValue(const std::string &ConstrCode, 1659864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType VT, bool isOutReg, bool isInReg, 1660864635ad7b3046d3042311423071152c613961deChris Lattner std::set<unsigned> &OutputRegs, 16614e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> &InputRegs) { 1662864635ad7b3046d3042311423071152c613961deChris Lattner std::pair<unsigned, const TargetRegisterClass*> PhysReg = 1663864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegForInlineAsmConstraint(ConstrCode, VT); 1664864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> Regs; 1665864635ad7b3046d3042311423071152c613961deChris Lattner 1666864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumRegs = VT != MVT::Other ? TLI.getNumElements(VT) : 1; 1667864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType RegVT; 1668864635ad7b3046d3042311423071152c613961deChris Lattner MVT::ValueType ValueVT = VT; 1669864635ad7b3046d3042311423071152c613961deChris Lattner 1670864635ad7b3046d3042311423071152c613961deChris Lattner if (PhysReg.first) { 1671864635ad7b3046d3042311423071152c613961deChris Lattner if (VT == MVT::Other) 1672864635ad7b3046d3042311423071152c613961deChris Lattner ValueVT = *PhysReg.second->vt_begin(); 1673864635ad7b3046d3042311423071152c613961deChris Lattner RegVT = VT; 1674864635ad7b3046d3042311423071152c613961deChris Lattner 1675864635ad7b3046d3042311423071152c613961deChris Lattner // This is a explicit reference to a physical register. 1676864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(PhysReg.first); 1677864635ad7b3046d3042311423071152c613961deChris Lattner 1678864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an expanded reference, add the rest of the regs to Regs. 1679864635ad7b3046d3042311423071152c613961deChris Lattner if (NumRegs != 1) { 1680864635ad7b3046d3042311423071152c613961deChris Lattner RegVT = *PhysReg.second->vt_begin(); 1681864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator I = PhysReg.second->begin(); 1682864635ad7b3046d3042311423071152c613961deChris Lattner TargetRegisterClass::iterator E = PhysReg.second->end(); 1683864635ad7b3046d3042311423071152c613961deChris Lattner for (; *I != PhysReg.first; ++I) 1684864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Didn't find reg!"); 1685864635ad7b3046d3042311423071152c613961deChris Lattner 1686864635ad7b3046d3042311423071152c613961deChris Lattner // Already added the first reg. 1687864635ad7b3046d3042311423071152c613961deChris Lattner --NumRegs; ++I; 1688864635ad7b3046d3042311423071152c613961deChris Lattner for (; NumRegs; --NumRegs, ++I) { 1689864635ad7b3046d3042311423071152c613961deChris Lattner assert(I != E && "Ran out of registers to allocate!"); 1690864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(*I); 1691864635ad7b3046d3042311423071152c613961deChris Lattner } 1692864635ad7b3046d3042311423071152c613961deChris Lattner } 1693864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, RegVT, ValueVT); 1694864635ad7b3046d3042311423071152c613961deChris Lattner } 1695864635ad7b3046d3042311423071152c613961deChris Lattner 1696864635ad7b3046d3042311423071152c613961deChris Lattner // This is a reference to a register class. Allocate NumRegs consecutive, 1697864635ad7b3046d3042311423071152c613961deChris Lattner // available, registers from the class. 1698864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<unsigned> RegClassRegs = 1699864635ad7b3046d3042311423071152c613961deChris Lattner TLI.getRegClassForInlineAsmConstraint(ConstrCode, VT); 1700864635ad7b3046d3042311423071152c613961deChris Lattner 17014e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner const MRegisterInfo *MRI = DAG.getTarget().getRegisterInfo(); 17024e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner MachineFunction &MF = *CurMBB->getParent(); 1703864635ad7b3046d3042311423071152c613961deChris Lattner unsigned NumAllocated = 0; 1704864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) { 1705864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 17064e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // See if this register is available. 1707864635ad7b3046d3042311423071152c613961deChris Lattner if ((isOutReg && OutputRegs.count(Reg)) || // Already used. 1708864635ad7b3046d3042311423071152c613961deChris Lattner (isInReg && InputRegs.count(Reg))) { // Already used. 1709864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 1710864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 1711864635ad7b3046d3042311423071152c613961deChris Lattner continue; 1712864635ad7b3046d3042311423071152c613961deChris Lattner } 1713864635ad7b3046d3042311423071152c613961deChris Lattner 17144e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Check to see if this register is allocatable (i.e. don't give out the 17154e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // stack pointer). 17169b6fb5de49f30d03b3e3f2fcb99e777b3149b783Chris Lattner const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, MRI); 1717864635ad7b3046d3042311423071152c613961deChris Lattner if (!RC) { 1718864635ad7b3046d3042311423071152c613961deChris Lattner // Make sure we find consecutive registers. 1719864635ad7b3046d3042311423071152c613961deChris Lattner NumAllocated = 0; 1720864635ad7b3046d3042311423071152c613961deChris Lattner continue; 17214e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 17224e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 1723864635ad7b3046d3042311423071152c613961deChris Lattner // Okay, this register is good, we can use it. 1724864635ad7b3046d3042311423071152c613961deChris Lattner ++NumAllocated; 1725864635ad7b3046d3042311423071152c613961deChris Lattner 1726864635ad7b3046d3042311423071152c613961deChris Lattner // If we allocated enough consecutive 1727864635ad7b3046d3042311423071152c613961deChris Lattner if (NumAllocated == NumRegs) { 1728864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegStart = (i-NumAllocated)+1; 1729864635ad7b3046d3042311423071152c613961deChris Lattner unsigned RegEnd = i+1; 1730864635ad7b3046d3042311423071152c613961deChris Lattner // Mark all of the allocated registers used. 1731864635ad7b3046d3042311423071152c613961deChris Lattner for (unsigned i = RegStart; i != RegEnd; ++i) { 1732864635ad7b3046d3042311423071152c613961deChris Lattner unsigned Reg = RegClassRegs[i]; 1733864635ad7b3046d3042311423071152c613961deChris Lattner Regs.push_back(Reg); 1734864635ad7b3046d3042311423071152c613961deChris Lattner if (isOutReg) OutputRegs.insert(Reg); // Mark reg used. 1735864635ad7b3046d3042311423071152c613961deChris Lattner if (isInReg) InputRegs.insert(Reg); // Mark reg used. 1736864635ad7b3046d3042311423071152c613961deChris Lattner } 1737864635ad7b3046d3042311423071152c613961deChris Lattner 1738864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(Regs, *RC->vt_begin(), VT); 1739864635ad7b3046d3042311423071152c613961deChris Lattner } 17404e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 1741864635ad7b3046d3042311423071152c613961deChris Lattner 1742864635ad7b3046d3042311423071152c613961deChris Lattner // Otherwise, we couldn't allocate enough registers for this. 1743864635ad7b3046d3042311423071152c613961deChris Lattner return RegsForValue(); 17444e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner} 17454e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 1746864635ad7b3046d3042311423071152c613961deChris Lattner 1747ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// visitInlineAsm - Handle a call to an InlineAsm object. 1748ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner/// 1749ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattnervoid SelectionDAGLowering::visitInlineAsm(CallInst &I) { 1750ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner InlineAsm *IA = cast<InlineAsm>(I.getOperand(0)); 1751ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1752ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand AsmStr = DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), 1753ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner MVT::Other); 1754ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1755ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Note, we treat inline asms both with and without side-effects as the same. 1756ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // If an inline asm doesn't have side effects and doesn't access memory, we 1757ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // could not choose to not chain it. 1758ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner bool hasSideEffects = IA->hasSideEffects(); 1759ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 17602cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); 17611efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner std::vector<MVT::ValueType> ConstraintVTs; 1762ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1763ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// AsmNodeOperands - A list of pairs. The first element is a register, the 1764ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// second is a bitfield where bit #0 is set if it is a use and bit #1 is set 1765ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner /// if it is a def of that register. 1766ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<SDOperand> AsmNodeOperands; 1767ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(SDOperand()); // reserve space for input chain 1768ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands.push_back(AsmStr); 1769ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 1770ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Chain = getRoot(); 1771ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner SDOperand Flag; 1772ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 17734e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We fully assign registers here at isel time. This is not optimal, but 17744e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // should work. For register classes that correspond to LLVM classes, we 17754e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // could let the LLVM RA do its thing, but we currently don't. Do a prepass 17764e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // over the constraints, collecting fixed registers that we know we can't use. 17774e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::set<unsigned> OutputRegs, InputRegs; 17781efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner unsigned OpNum = 1; 17794e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 17804e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 17814e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 17822223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 17831efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner MVT::ValueType OpVT; 17841efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 17851efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // Compute the value type for each operand and add it to ConstraintVTs. 17861efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner switch (Constraints[i].Type) { 17871efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isOutput: 17881efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner if (!Constraints[i].isIndirectOutput) { 17891efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 17901efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getType()); 17911efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } else { 179222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner const Type *OpTy = I.getOperand(OpNum)->getType(); 17931efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(cast<PointerType>(OpTy)->getElementType()); 17941efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 17951efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 17961efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 17971efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 17981efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = TLI.getValueType(I.getOperand(OpNum)->getType()); 17991efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum++; // Consumes a call operand. 18001efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 18011efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isClobber: 18021efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpVT = MVT::Other; 18031efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 18041efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner } 18051efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 18061efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner ConstraintVTs.push_back(OpVT); 18071efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 1808864635ad7b3046d3042311423071152c613961deChris Lattner if (TLI.getRegForInlineAsmConstraint(ConstraintCode, OpVT).first == 0) 1809864635ad7b3046d3042311423071152c613961deChris Lattner continue; // Not assigned a fixed reg. 18101efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 1811864635ad7b3046d3042311423071152c613961deChris Lattner // Build a list of regs that this operand uses. This always has a single 1812864635ad7b3046d3042311423071152c613961deChris Lattner // element for promoted/expanded operands. 1813864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = GetRegistersForValue(ConstraintCode, OpVT, 1814864635ad7b3046d3042311423071152c613961deChris Lattner false, false, 1815864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 18164e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner 18174e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner switch (Constraints[i].Type) { 18184e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isOutput: 18194e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // We can't assign any other output to this register. 1820864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 18214e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // If this is an early-clobber output, it cannot be assigned to the same 18224e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // value as the input reg. 18232223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 1824864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 18254e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 18261efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner case InlineAsm::isInput: 18271efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner // We can't assign any other input to this register. 1828864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 18291efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner break; 18304e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner case InlineAsm::isClobber: 18314e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner // Clobbered regs cannot be used as inputs or outputs. 1832864635ad7b3046d3042311423071152c613961deChris Lattner InputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 1833864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs.insert(Regs.Regs.begin(), Regs.Regs.end()); 18344e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner break; 18354e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 18364e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner } 18372cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 18380f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // Loop over all of the inputs, copying the operand values into the 18390f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner // appropriate registers and processing the output regs. 1840864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue RetValRegs; 1841864635ad7b3046d3042311423071152c613961deChris Lattner std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit; 18421efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner OpNum = 1; 18430f0b7d4927e56e622cf43da0db56f3e0d40b8aafChris Lattner 18446656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = Constraints.size(); i != e; ++i) { 18452cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(Constraints[i].Codes.size() == 1 && "Only handles one code so far!"); 18462cc2f66c25d9576743026688fdae5ed402726532Chris Lattner std::string &ConstraintCode = Constraints[i].Codes[0]; 18471efa40f6a4b561cf8f80fe018684236010645cd0Chris Lattner 18482cc2f66c25d9576743026688fdae5ed402726532Chris Lattner switch (Constraints[i].Type) { 18492cc2f66c25d9576743026688fdae5ed402726532Chris Lattner case InlineAsm::isOutput: { 185022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 185122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 185222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 185322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 185422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (CTy == TargetLowering::C_Memory) { 185522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Memory output. 185622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 185722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 185822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Check that the operand (the address to store to) isn't a float. 185922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 186022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 186122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 186222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (!Constraints[i].isIndirectOutput) 186322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(0 && "MATCH FAIL!"); 186422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 186522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner OpNum++; // Consumes a call operand. 186622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 186722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Extend/truncate to the right pointer type if needed. 186822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 186922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner if (InOperandVal.getValueType() < PtrType) 187022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 187122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner else if (InOperandVal.getValueType() > PtrType) 187222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 187322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 187422873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Add information to the INLINEASM node to know about this output. 187522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 187622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 187722873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner AsmNodeOperands.push_back(InOperandVal); 187822873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner break; 187922873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner } 188022873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 188122873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner // Otherwise, this is a register output. 188222873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 188322873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner 1884864635ad7b3046d3042311423071152c613961deChris Lattner // If this is an early-clobber output, or if there is an input 1885864635ad7b3046d3042311423071152c613961deChris Lattner // constraint that matches this, we need to reserve the input register 1886864635ad7b3046d3042311423071152c613961deChris Lattner // so no other inputs allocate to it. 1887864635ad7b3046d3042311423071152c613961deChris Lattner bool UsesInputRegister = false; 1888864635ad7b3046d3042311423071152c613961deChris Lattner if (Constraints[i].isEarlyClobber || Constraints[i].hasMatchingInput) 1889864635ad7b3046d3042311423071152c613961deChris Lattner UsesInputRegister = true; 18902223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner 1891864635ad7b3046d3042311423071152c613961deChris Lattner // Copy the output from the appropriate register. Find a register that 1892864635ad7b3046d3042311423071152c613961deChris Lattner // we can use. 1893864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue Regs = 1894864635ad7b3046d3042311423071152c613961deChris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 1895864635ad7b3046d3042311423071152c613961deChris Lattner true, UsesInputRegister, 1896864635ad7b3046d3042311423071152c613961deChris Lattner OutputRegs, InputRegs); 1897864635ad7b3046d3042311423071152c613961deChris Lattner assert(!Regs.Regs.empty() && "Couldn't allocate output reg!"); 18982cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 18992cc2f66c25d9576743026688fdae5ed402726532Chris Lattner if (!Constraints[i].isIndirectOutput) { 1900864635ad7b3046d3042311423071152c613961deChris Lattner assert(RetValRegs.Regs.empty() && 19012cc2f66c25d9576743026688fdae5ed402726532Chris Lattner "Cannot have multiple output constraints yet!"); 19022cc2f66c25d9576743026688fdae5ed402726532Chris Lattner assert(I.getType() != Type::VoidTy && "Bad inline asm!"); 1903864635ad7b3046d3042311423071152c613961deChris Lattner RetValRegs = Regs; 19042cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } else { 190522873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner IndirectStoresToEmit.push_back(std::make_pair(Regs, 190622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner I.getOperand(OpNum))); 19072cc2f66c25d9576743026688fdae5ed402726532Chris Lattner OpNum++; // Consumes a call operand. 19082cc2f66c25d9576743026688fdae5ed402726532Chris Lattner } 19096656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 19106656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Add information to the INLINEASM node to know that this register is 19116656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // set. 1912c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner Regs.AddInlineAsmOperands(2 /*REGDEF*/, DAG, AsmNodeOperands); 19136656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 19146656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 19156656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner case InlineAsm::isInput: { 191622873462c965a57664c4e375aa6e8bf02c9c6ad8Chris Lattner SDOperand InOperandVal = getValue(I.getOperand(OpNum)); 19174e4b576e2edfc7d40a3d7177c639acbe91cfd45fChris Lattner OpNum++; // Consumes a call operand. 19183d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 19192223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner if (isdigit(ConstraintCode[0])) { // Matching constraint? 19202223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // If this is required to match an output register we have already set, 19212223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner // just use its register. 19222223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner unsigned OperandNo = atoi(ConstraintCode.c_str()); 19233d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 1924c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan until we find the definition we already emitted of this operand. 1925c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // When we find it, create a RegsForValue operand. 1926c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned CurOp = 2; // The first operand. 1927c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (; OperandNo; --OperandNo) { 1928c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Advance to the next operand. 1929c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 1930c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 1931c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner assert((NumOps & 7) == 2 /*REGDEF*/ && 1932c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 1933c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner CurOp += (NumOps>>3)+1; 1934c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1935c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 1936c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned NumOps = 1937c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getValue(); 1938c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner assert((NumOps & 7) == 2 /*REGDEF*/ && 1939c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner "Skipped past definitions?"); 1940c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 1941c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add NumOps>>3 registers to MatchedRegs. 1942c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue MatchedRegs; 1943c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.ValueVT = InOperandVal.getValueType(); 1944c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.RegVT = AsmNodeOperands[CurOp+1].getValueType(); 1945c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner for (unsigned i = 0, e = NumOps>>3; i != e; ++i) { 1946c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned Reg=cast<RegisterSDNode>(AsmNodeOperands[++CurOp])->getReg(); 1947c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.Regs.push_back(Reg); 1948c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 1949c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 1950c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Use the produced MatchedRegs object to 1951c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag); 1952c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner MatchedRegs.AddInlineAsmOperands(1 /*REGUSE*/, DAG, AsmNodeOperands); 195387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 195487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } 195587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 195687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner TargetLowering::ConstraintType CTy = TargetLowering::C_RegisterClass; 195787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (ConstraintCode.size() == 1) // not a physreg name. 195887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner CTy = TLI.getConstraintType(ConstraintCode[0]); 19593d81fee8511536962543cbf420fd70ef15ae9c3aChris Lattner 196087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (CTy == TargetLowering::C_Other) { 196187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!TLI.isOperandValidForConstraint(InOperandVal, ConstraintCode[0])) 196287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 1963c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 196487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 196587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 3 /*IMM*/ | (1 << 3); 196687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 196787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 196887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner break; 196987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner } else if (CTy == TargetLowering::C_Memory) { 197087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Memory input. 197187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 197287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Check that the operand isn't a float. 197387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (!MVT::isInteger(InOperandVal.getValueType())) 197487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(0 && "MATCH FAIL!"); 1975c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner 197687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Extend/truncate to the right pointer type if needed. 197787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner MVT::ValueType PtrType = TLI.getPointerTy(); 197887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner if (InOperandVal.getValueType() < PtrType) 197987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::ZERO_EXTEND, PtrType, InOperandVal); 198087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner else if (InOperandVal.getValueType() > PtrType) 198187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InOperandVal = DAG.getNode(ISD::TRUNCATE, PtrType, InOperandVal); 198287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 198387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Add information to the INLINEASM node to know about this input. 198487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner unsigned ResOpType = 4/*MEM*/ | (1 << 3); 198587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(DAG.getConstant(ResOpType, MVT::i32)); 198687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner AsmNodeOperands.push_back(InOperandVal); 1987c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner break; 19882223aea6ed33e4261d506afdcfbf30ccd8f52bfbChris Lattner } 198987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 199087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(CTy == TargetLowering::C_RegisterClass && "Unknown op type!"); 199187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 199287bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // Copy the input into the appropriate registers. 199387bc3bd1213ced06eade93e3267178198d41a381Chris Lattner RegsForValue InRegs = 199487bc3bd1213ced06eade93e3267178198d41a381Chris Lattner GetRegistersForValue(ConstraintCode, ConstraintVTs[i], 199587bc3bd1213ced06eade93e3267178198d41a381Chris Lattner false, true, OutputRegs, InputRegs); 199687bc3bd1213ced06eade93e3267178198d41a381Chris Lattner // FIXME: should be match fail. 199787bc3bd1213ced06eade93e3267178198d41a381Chris Lattner assert(!InRegs.Regs.empty() && "Couldn't allocate input reg!"); 199887bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 199987bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.getCopyToRegs(InOperandVal, DAG, Chain, Flag); 200087bc3bd1213ced06eade93e3267178198d41a381Chris Lattner 200187bc3bd1213ced06eade93e3267178198d41a381Chris Lattner InRegs.AddInlineAsmOperands(1/*REGUSE*/, DAG, AsmNodeOperands); 20026656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 20036656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2004c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner case InlineAsm::isClobber: { 2005c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner RegsForValue ClobberedRegs = 2006c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner GetRegistersForValue(ConstraintCode, MVT::Other, false, false, 2007c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner OutputRegs, InputRegs); 2008c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Add the clobbered value to the operand list, so that the register 2009c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // allocator is aware that the physreg got clobbered. 2010c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (!ClobberedRegs.Regs.empty()) 2011c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner ClobberedRegs.AddInlineAsmOperands(2/*REGDEF*/, DAG, AsmNodeOperands); 20126656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner break; 20136656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2014c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 20156656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2016ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2017ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner // Finish up input operands. 2018ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner AsmNodeOperands[0] = Chain; 2019ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner if (Flag.Val) AsmNodeOperands.push_back(Flag); 2020ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2021ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner std::vector<MVT::ValueType> VTs; 2022ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner VTs.push_back(MVT::Other); 2023ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner VTs.push_back(MVT::Flag); 2024ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Chain = DAG.getNode(ISD::INLINEASM, VTs, AsmNodeOperands); 2025ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner Flag = Chain.getValue(1); 2026ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 20276656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // If this asm returns a register value, copy the result from that register 20286656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // and set it as the value of the call. 2029864635ad7b3046d3042311423071152c613961deChris Lattner if (!RetValRegs.Regs.empty()) 2030864635ad7b3046d3042311423071152c613961deChris Lattner setValue(&I, RetValRegs.getCopyFromRegs(DAG, Chain, Flag)); 20316656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 20326656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<std::pair<SDOperand, Value*> > StoresToEmit; 20336656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner 20346656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Process indirect outputs, first output all of the flagged copies out of 20356656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // physregs. 20366656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) { 2037864635ad7b3046d3042311423071152c613961deChris Lattner RegsForValue &OutRegs = IndirectStoresToEmit[i].first; 20386656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Value *Ptr = IndirectStoresToEmit[i].second; 2039864635ad7b3046d3042311423071152c613961deChris Lattner SDOperand OutVal = OutRegs.getCopyFromRegs(DAG, Chain, Flag); 2040864635ad7b3046d3042311423071152c613961deChris Lattner StoresToEmit.push_back(std::make_pair(OutVal, Ptr)); 20416656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner } 2042ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 20436656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner // Emit the non-flagged stores from the physregs. 20446656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner std::vector<SDOperand> OutChains; 20456656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) 20466656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner OutChains.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain, 20476656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner StoresToEmit[i].first, 20486656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner getValue(StoresToEmit[i].second), 20496656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner DAG.getSrcValue(StoresToEmit[i].second))); 20506656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner if (!OutChains.empty()) 20516656dd1a7888e6dabc82ebce734734127b1df6a7Chris Lattner Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains); 2052ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner DAG.setRoot(Chain); 2053ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner} 2054ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 2055ce7518ce92f45568dc7d4cbb863284afb962fec5Chris Lattner 20561c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitMalloc(MallocInst &I) { 20571c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDOperand Src = getValue(I.getOperand(0)); 20581c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 20591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 206068cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner 206168cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner if (IntPtr < Src.getValueType()) 206268cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src); 206368cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner else if (IntPtr > Src.getValueType()) 206468cd65ea689907fb8a4aa80d72d182921e94607fChris Lattner Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src); 20651c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 20661c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Scale the source by the type size. 20671c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType()); 20681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src = DAG.getNode(ISD::MUL, Src.getValueType(), 20691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Src, getIntPtrConstant(ElementSize)); 20701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 20711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 20721c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType())); 2073cf5734dddd66af9388a171b44996505ede47feedChris Lattner 2074cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2075adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true, 2076cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("malloc", IntPtr), 2077cf5734dddd66af9388a171b44996505ede47feedChris Lattner Args, DAG); 2078cf5734dddd66af9388a171b44996505ede47feedChris Lattner setValue(&I, Result.first); // Pointers always fit in registers 2079cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 20801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 20811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 20821c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitFree(FreeInst &I) { 20831c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::vector<std::pair<SDOperand, const Type*> > Args; 20841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner Args.push_back(std::make_pair(getValue(I.getOperand(0)), 20851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TLI.getTargetData().getIntPtrType())); 20861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MVT::ValueType IntPtr = TLI.getPointerTy(); 2087cf5734dddd66af9388a171b44996505ede47feedChris Lattner std::pair<SDOperand,SDOperand> Result = 2088adf6a965a321372c640845407195594835921eb4Chris Lattner TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true, 2089cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.getExternalSymbol("free", IntPtr), Args, DAG); 2090cf5734dddd66af9388a171b44996505ede47feedChris Lattner DAG.setRoot(Result.second); 20911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 20921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2093025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// InsertAtEndOfBasicBlock - This method should be implemented by targets that 2094025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// mark instructions with the 'usesCustomDAGSchedInserter' flag. These 2095025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// instructions are special in various ways, which require special support to 2096025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// insert. The specified MachineInstr is created but not inserted into any 2097025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner// basic blocks, and the scheduler passes ownership of it to this method. 2098025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris LattnerMachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI, 2099025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner MachineBasicBlock *MBB) { 2100025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner std::cerr << "If a target marks an instruction with " 2101025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "'usesCustomDAGSchedInserter', it must implement " 2102025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner "TargetLowering::InsertAtEndOfBasicBlock!\n"; 2103025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner abort(); 2104025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner return 0; 2105025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner} 2106025c39bf36b6bc2f35a5544338de6cf96fa511a9Chris Lattner 210739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitVAStart(CallInst &I) { 2108acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VASTART, MVT::Other, getRoot(), 2109acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2110acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 211139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 211239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner 21131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAArg(VAArgInst &I) { 2114acc398c195a697795bff3245943d104eb19192b9Nate Begeman SDOperand V = DAG.getVAArg(TLI.getValueType(I.getType()), getRoot(), 2115acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(0)), 2116acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(0))); 2117acc398c195a697795bff3245943d104eb19192b9Nate Begeman setValue(&I, V); 2118acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(V.getValue(1)); 21191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 21201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 21211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVAEnd(CallInst &I) { 2122acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VAEND, MVT::Other, getRoot(), 2123acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2124acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)))); 21251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 21261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 21271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnervoid SelectionDAGLowering::visitVACopy(CallInst &I) { 2128acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.setRoot(DAG.getNode(ISD::VACOPY, MVT::Other, getRoot(), 2129acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(1)), 2130acc398c195a697795bff3245943d104eb19192b9Nate Begeman getValue(I.getOperand(2)), 2131acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(1)), 2132acc398c195a697795bff3245943d104eb19192b9Nate Begeman DAG.getSrcValue(I.getOperand(2)))); 21331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 21341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 213539ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// It is always conservatively correct for llvm.returnaddress and 213639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner// llvm.frameaddress to return 0. 213739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnerstd::pair<SDOperand, SDOperand> 213839ae3622791986a0232f7e4797b633f8fa9e54d2Chris LattnerTargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain, 213939ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth, SelectionDAG &DAG) { 214039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain); 21411c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 21421c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 214350381b6c4180e9a2b983d4623da2e485cd768632Chris LattnerSDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) { 2144171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner assert(0 && "LowerOperation not implemented for this target!"); 2145171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner abort(); 2146d3f03e4b50feb6abfa9fec8b0aa705d45134c59eMisha Brukman return SDOperand(); 2147171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner} 2148171453a284b097f1ee89fb87ff495c3a6c7b6297Chris Lattner 21490aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate BegemanSDOperand TargetLowering::CustomPromoteOperation(SDOperand Op, 21500aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman SelectionDAG &DAG) { 21510aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman assert(0 && "CustomPromoteOperation not implemented for this target!"); 21520aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman abort(); 21530aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman return SDOperand(); 21540aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman} 21550aed7840ec8cc85f91b4aa6e69318bba0cbd1f03Nate Begeman 215639ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattnervoid SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) { 215739ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue(); 215839ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner std::pair<SDOperand,SDOperand> Result = 2159a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG); 216039ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner setValue(&I, Result.first); 216139ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner DAG.setRoot(Result.second); 216239ae3622791986a0232f7e4797b633f8fa9e54d2Chris Lattner} 21631c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 216474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetValue - Vectorized representation of the memset value 21651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// operand. 21661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemsetValue(SDOperand Value, MVT::ValueType VT, 2167a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SelectionDAG &DAG) { 21681db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType CurVT = VT; 21691db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) { 21701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng uint64_t Val = C->getValue() & 255; 21711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 21721db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 21731db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Val = (Val << Shift) | Val; 21741db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 21751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 21761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 21771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getConstant(Val, VT); 21781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 21791db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = DAG.getNode(ISD::ZERO_EXTEND, VT, Value); 21801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Shift = 8; 21811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (CurVT != MVT::i8) { 21821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Value = 21831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::OR, VT, 21841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getNode(ISD::SHL, VT, Value, 21851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng DAG.getConstant(Shift, MVT::i8)), Value); 21861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Shift <<= 1; 21871db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng CurVT = (MVT::ValueType)((unsigned)CurVT - 1); 21881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 21891db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 21901db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return Value; 21911db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 21921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 21931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 219474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// getMemsetStringVal - Similar to getMemsetValue. Except this is only 219574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// used when a memcpy is turned into a memset when the source is a constant 219674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng/// string ptr. 219774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Chengstatic SDOperand getMemsetStringVal(MVT::ValueType VT, 219874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SelectionDAG &DAG, TargetLowering &TLI, 219974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string &Str, unsigned Offset) { 220074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng MVT::ValueType CurVT = VT; 220174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng uint64_t Val = 0; 220274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng unsigned MSB = getSizeInBits(VT) / 8; 220374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (TLI.isLittleEndian()) 220474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset = Offset + MSB - 1; 220574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng for (unsigned i = 0; i != MSB; ++i) { 220674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Val = (Val << 8) | Str[Offset]; 220774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Offset += TLI.isLittleEndian() ? -1 : 1; 220874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 220974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng return DAG.getConstant(Val, VT); 221074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng} 221174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 22121db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng/// getMemBasePlusOffset - Returns base and offset node for the 22131db92f947cc600dee5edb9305a4e0f1c5c872965Evan Chengstatic SDOperand getMemBasePlusOffset(SDOperand Base, unsigned Offset, 22141db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SelectionDAG &DAG, TargetLowering &TLI) { 22151db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = Base.getValueType(); 22161db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng return DAG.getNode(ISD::ADD, VT, Base, DAG.getConstant(Offset, VT)); 22171db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 22181db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 2219c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng/// MeetsMaxMemopRequirement - Determines if the number of memory ops required 222080e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// to replace the memset / memcpy is below the threshold. It also returns the 222180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng/// types of the sequence of memory ops to perform memset / memcpy. 2222c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Chengstatic bool MeetsMaxMemopRequirement(std::vector<MVT::ValueType> &MemOps, 2223c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Limit, uint64_t Size, 2224c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng unsigned Align, TargetLowering &TLI) { 22251db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT; 22261db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 22271db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (TLI.allowsUnalignedMemoryAccesses()) { 22281db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 22291db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } else { 22301db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Align & 7) { 22311db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 0: 22321db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i64; 22331db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 22341db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 4: 22351db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i32; 22361db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 22371db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case 2: 22381db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i16; 22391db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 22401db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng default: 22411db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = MVT::i8; 22421db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng break; 22431db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 22441db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 22451db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 224680e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng MVT::ValueType LVT = MVT::i64; 224780e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng while (!TLI.isTypeLegal(LVT)) 224880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng LVT = (MVT::ValueType)((unsigned)LVT - 1); 224980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(LVT)); 22501db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 225180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (VT > LVT) 225280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng VT = LVT; 225380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 2254dea7245997f37972ed2f94d4ca1ec50c5af5000aEvan Cheng unsigned NumMemOps = 0; 22551db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (Size != 0) { 22561db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 22571db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng while (VTSize > Size) { 22581db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VT = (MVT::ValueType)((unsigned)VT - 1); 22591db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng VTSize >>= 1; 22601db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 226180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng assert(MVT::isInteger(VT)); 226280e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 226380e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng if (++NumMemOps > Limit) 226480e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return false; 22651db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MemOps.push_back(VT); 22661db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Size -= VTSize; 22671db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 226880e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng 226980e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng return true; 22701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng} 22711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 22727041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattnervoid SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) { 22731db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op1 = getValue(I.getOperand(1)); 22741db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op2 = getValue(I.getOperand(2)); 22751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op3 = getValue(I.getOperand(3)); 22761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng SDOperand Op4 = getValue(I.getOperand(4)); 22771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Align = (unsigned)cast<ConstantSDNode>(Op4)->getValue(); 22781db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (Align == 0) Align = 1; 22791db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 22801db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng if (ConstantSDNode *Size = dyn_cast<ConstantSDNode>(Op3)) { 22811db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<MVT::ValueType> MemOps; 22821db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 22831db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // Expand memset / memcpy to a series of load / store ops 22841db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng // if the size operand falls below a certain threshold. 22851db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng std::vector<SDOperand> OutChains; 22861db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng switch (Op) { 2287ac940ab1bf21be40f74a83b202419a20ad2e279fEvan Cheng default: break; // Do nothing for now. 22881db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng case ISD::MEMSET: { 2289c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemset(), 2290c4f8eee05447a1d7ead3deabbeb087e3e037f3f8Evan Cheng Size->getValue(), Align, TLI)) { 229180e89d7d6c02233a92d26bd4625e4188d48cbfa1Evan Cheng unsigned NumMemOps = MemOps.size(); 22921db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned Offset = 0; 22931db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 22941db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng MVT::ValueType VT = MemOps[i]; 22951db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 2296a47876d87a84fa94bf9f09cfef6756223575611dEvan Cheng SDOperand Value = getMemsetValue(Op2, VT, DAG); 2297c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, getRoot(), 2298c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Value, 2299864635ad7b3046d3042311423071152c613961deChris Lattner getMemBasePlusOffset(Op1, Offset, DAG, TLI), 2300864635ad7b3046d3042311423071152c613961deChris Lattner DAG.getSrcValue(I.getOperand(1), Offset)); 2301c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 2302c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Offset += VTSize; 2303c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2304c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2305c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 2306c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 2307c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng case ISD::MEMCPY: { 2308c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (MeetsMaxMemopRequirement(MemOps, TLI.getMaxStoresPerMemcpy(), 2309c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng Size->getValue(), Align, TLI)) { 2310c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned NumMemOps = MemOps.size(); 2311cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng unsigned SrcOff = 0, DstOff = 0, SrcDelta = 0; 231274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalAddressSDNode *G = NULL; 231374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng std::string Str; 2314cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng bool CopyFromStr = false; 231574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 231674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (Op2.getOpcode() == ISD::GlobalAddress) 231774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2); 231874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng else if (Op2.getOpcode() == ISD::ADD && 231974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(0).getOpcode() == ISD::GlobalAddress && 232074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Op2.getOperand(1).getOpcode() == ISD::Constant) { 232174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng G = cast<GlobalAddressSDNode>(Op2.getOperand(0)); 2322cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcDelta = cast<ConstantSDNode>(Op2.getOperand(1))->getValue(); 232374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 232474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng if (G) { 232574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng GlobalVariable *GV = dyn_cast<GlobalVariable>(G->getGlobal()); 2326cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (GV) { 23270937103368992af8d3d8032d31a7d152aeae32d5Evan Cheng Str = GV->getStringValue(false); 2328cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (!Str.empty()) { 2329cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng CopyFromStr = true; 2330cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng SrcOff += SrcDelta; 2331cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 2332cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng } 233374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 233474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 2335c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng for (unsigned i = 0; i < NumMemOps; i++) { 2336c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng MVT::ValueType VT = MemOps[i]; 2337c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng unsigned VTSize = getSizeInBits(VT) / 8; 233874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SDOperand Value, Chain, Store; 233974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng 2340cffbb5174f283d123d6bfc582292f4a9c84cb3edEvan Cheng if (CopyFromStr) { 234174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = getMemsetStringVal(VT, DAG, TLI, Str, SrcOff); 234274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = getRoot(); 234374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 234474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getNode(ISD::STORE, MVT::Other, Chain, Value, 234574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 234674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getSrcValue(I.getOperand(1), DstOff)); 234774d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } else { 234874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Value = DAG.getLoad(VT, getRoot(), 234974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op2, SrcOff, DAG, TLI), 235074d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getSrcValue(I.getOperand(2), SrcOff)); 235174d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Chain = Value.getValue(1); 235274d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng Store = 235374d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getNode(ISD::STORE, MVT::Other, Chain, Value, 235474d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng getMemBasePlusOffset(Op1, DstOff, DAG, TLI), 235574d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DAG.getSrcValue(I.getOperand(1), DstOff)); 235674d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng } 2357c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng OutChains.push_back(Store); 235874d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng SrcOff += VTSize; 235974d0aa9a4b1f5e021d2ce851a7af344e9b4ebb23Evan Cheng DstOff += VTSize; 23601db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 23611db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 2362c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng break; 23631db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 23641db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 2365c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng 2366c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng if (!OutChains.empty()) { 2367c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains)); 2368c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng return; 2369c080d6fb3dc7769c5a1e00c6a77cb415453b0b89Evan Cheng } 23701db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng } 23711db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng 23727041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner std::vector<SDOperand> Ops; 2373a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner Ops.push_back(getRoot()); 23741db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op1); 23751db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op2); 23761db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op3); 23771db92f947cc600dee5edb9305a4e0f1c5c872965Evan Cheng Ops.push_back(Op4); 23787041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops)); 23791c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23817041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 23827041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner// SelectionDAGISel code 23837041ee35adecb864e3e8df490aa73b0605fbfb5aChris Lattner//===----------------------------------------------------------------------===// 23841c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 23851c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerunsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) { 23861c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return RegMap->createVirtualRegister(TLI.getRegClassFor(VT)); 23871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 23881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2389495a0b51915eb763576874f29192820b731edc22Chris Lattnervoid SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { 239036b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // FIXME: we only modify the CFG to split critical edges. This 239136b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner // updates dom and loop info. 2392495a0b51915eb763576874f29192820b731edc22Chris Lattner} 23931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2394c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2395c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// InsertGEPComputeCode - Insert code into BB to compute Ptr+PtrOffset, 2396c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// casting to the type of GEPI. 2397c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattnerstatic Value *InsertGEPComputeCode(Value *&V, BasicBlock *BB, Instruction *GEPI, 2398c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr, Value *PtrOffset) { 2399c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (V) return V; // Already computed. 2400c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2401c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock::iterator InsertPt; 2402c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (BB == GEPI->getParent()) { 2403c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If insert into the GEP's block, insert right after the GEP. 2404c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner InsertPt = GEPI; 2405c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ++InsertPt; 2406c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 2407c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, insert at the top of BB, after any PHI nodes 2408c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner InsertPt = BB->begin(); 2409c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner while (isa<PHINode>(InsertPt)) ++InsertPt; 2410c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2411c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2412c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // If Ptr is itself a cast, but in some other BB, emit a copy of the cast into 2413c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // BB so that there is only one value live across basic blocks (the cast 2414c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // operand). 2415c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (CastInst *CI = dyn_cast<CastInst>(Ptr)) 2416c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (CI->getParent() != BB && isa<PointerType>(CI->getOperand(0)->getType())) 2417c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Ptr = new CastInst(CI->getOperand(0), CI->getType(), "", InsertPt); 2418c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 2419c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Add the offset, cast it to the right type. 2420c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, PtrOffset, "", InsertPt); 2421c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = new CastInst(Ptr, GEPI->getType(), "", InsertPt); 2422c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner return V = Ptr; 2423c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 2424c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2425c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2426c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// OptimizeGEPExpression - Since we are doing basic-block-at-a-time instruction 2427c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// selection, we want to be a bit careful about some things. In particular, if 2428c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// we have a GEP instruction that is used in a different block than it is 2429c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// defined, the addressing expression of the GEP cannot be folded into loads or 2430c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// stores that use it. In this case, decompose the GEP and move constant 2431c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner/// indices into blocks that use it. 2432c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattnerstatic void OptimizeGEPExpression(GetElementPtrInst *GEPI, 2433c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const TargetData &TD) { 2434c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP is only used inside the block it is defined in, there is no 2435c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // need to rewrite it. 2436c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool isUsedOutsideDefBB = false; 2437c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock *DefBB = GEPI->getParent(); 2438c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (Value::use_iterator UI = GEPI->use_begin(), E = GEPI->use_end(); 2439c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner UI != E; ++UI) { 2440c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (cast<Instruction>(*UI)->getParent() != DefBB) { 2441c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner isUsedOutsideDefBB = true; 2442c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 2443c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2444c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2445c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (!isUsedOutsideDefBB) return; 2446c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2447c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // If this GEP has no non-zero constant indices, there is nothing we can do, 2448c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // ignore it. 2449c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner bool hasConstantIndex = false; 2450c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 2451c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 2452c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(*OI)) 2453c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue()) { 2454c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner hasConstantIndex = true; 2455c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner break; 2456c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2457c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 24583802c2552fe4475418db3c948e7601d7259f996dChris Lattner // If this is a GEP &Alloca, 0, 0, forward subst the frame index into uses. 24593802c2552fe4475418db3c948e7601d7259f996dChris Lattner if (!hasConstantIndex && !isa<AllocaInst>(GEPI->getOperand(0))) return; 2460c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2461c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Otherwise, decompose the GEP instruction into multiplies and adds. Sum the 2462c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constant offset (which we now know is non-zero) and deal with it later. 2463c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ConstantOffset = 0; 2464c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *UIntPtrTy = TD.getIntPtrType(); 2465c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Ptr = new CastInst(GEPI->getOperand(0), UIntPtrTy, "", GEPI); 2466c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner const Type *Ty = GEPI->getOperand(0)->getType(); 2467c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2468c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (GetElementPtrInst::op_iterator OI = GEPI->op_begin()+1, 2469c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner E = GEPI->op_end(); OI != E; ++OI) { 2470c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Value *Idx = *OI; 2471c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (const StructType *StTy = dyn_cast<StructType>(Ty)) { 2472c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner unsigned Field = cast<ConstantUInt>(Idx)->getValue(); 2473c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (Field) 2474c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset += TD.getStructLayout(StTy)->MemberOffsets[Field]; 2475c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = StTy->getElementType(Field); 2476c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } else { 2477c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ty = cast<SequentialType>(Ty)->getElementType(); 2478c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2479c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Handle constant subscripts. 2480c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) { 2481c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (CI->getRawValue() == 0) continue; 2482c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2483c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI)) 2484c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset += (int64_t)TD.getTypeSize(Ty)*CSI->getValue(); 2485c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner else 2486c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset+=TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue(); 2487c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner continue; 2488c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2489c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2490c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Ptr = Ptr + Idx * ElementSize; 2491c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2492c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Cast Idx to UIntPtrTy if needed. 2493c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = new CastInst(Idx, UIntPtrTy, "", GEPI); 2494c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2495c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner uint64_t ElementSize = TD.getTypeSize(Ty); 2496c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Mask off bits that should not be set. 2497c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ElementSize &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 2498c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *SizeCst = ConstantUInt::get(UIntPtrTy, ElementSize); 2499c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2500c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Multiply by the element size and add to the base. 2501c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Idx = BinaryOperator::createMul(Idx, SizeCst, "", GEPI); 2502c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr = BinaryOperator::createAdd(Ptr, Idx, "", GEPI); 2503c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2504c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2505c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2506c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Make sure that the offset fits in uintptr_t. 2507c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner ConstantOffset &= ~0ULL >> (64-UIntPtrTy->getPrimitiveSizeInBits()); 2508c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Constant *PtrOffset = ConstantUInt::get(UIntPtrTy, ConstantOffset); 2509c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2510c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Okay, we have now emitted all of the variable index parts to the BB that 2511c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // the GEP is defined in. Loop over all of the using instructions, inserting 2512c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // an "add Ptr, ConstantOffset" into each block that uses it and update the 2513c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // instruction to use the newly computed value, making GEPI dead. When the 2514c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // user is a load or store instruction address, we emit the add into the user 2515c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // block, otherwise we use a canonical version right next to the gep (these 2516c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // won't be foldable as addresses, so we might as well share the computation). 2517c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 2518c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner std::map<BasicBlock*,Value*> InsertedExprs; 2519c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner while (!GEPI->use_empty()) { 2520c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Instruction *User = cast<Instruction>(GEPI->use_back()); 2521c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner 2522c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // If this use is not foldable into the addressing mode, use a version 2523c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // emitted in the GEP block. 2524c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Value *NewVal; 2525c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner if (!isa<LoadInst>(User) && 2526c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner (!isa<StoreInst>(User) || User->getOperand(0) == GEPI)) { 2527c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[DefBB], DefBB, GEPI, 2528c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner Ptr, PtrOffset); 2529c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner } else { 2530c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // Otherwise, insert the code in the User's block so it can be folded into 2531c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner // any users in that block. 2532c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner NewVal = InsertGEPComputeCode(InsertedExprs[User->getParent()], 2533c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner User->getParent(), GEPI, 2534c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner Ptr, PtrOffset); 2535c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner } 2536c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner User->replaceUsesOfWith(GEPI, NewVal); 2537c78b0b740bcf2e00a8871090709c3571fe442f07Chris Lattner } 2538c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2539c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // Finally, the GEP is dead, remove it. 2540c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner GEPI->eraseFromParent(); 2541c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner} 2542c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 25431c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattnerbool SelectionDAGISel::runOnFunction(Function &Fn) { 25441c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); 25451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner RegMap = MF.getSSARegMap(); 25461c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n"); 25471c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2548c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // First, split all critical edges for PHI nodes with incoming values that are 2549c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // constants, this way the load of the constant into a vreg will not be placed 2550c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // into MBBs that are used some other way. 2551c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 2552c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // In this pass we also look for GEP instructions that are used across basic 2553c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // blocks and rewrites them to improve basic-block-at-a-time selection. 2554c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner // 255536b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 255636b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner PHINode *PN; 2557c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner BasicBlock::iterator BBI; 2558c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (BBI = BB->begin(); (PN = dyn_cast<PHINode>(BBI)); ++BBI) 255936b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 256036b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner if (isa<Constant>(PN->getIncomingValue(i))) 256136b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner SplitCriticalEdge(PN->getIncomingBlock(i), BB); 2562c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner 2563c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner for (BasicBlock::iterator E = BB->end(); BBI != E; ) 2564c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(BBI++)) 2565c88d8e944dae71e31595b8ae264668e68db6b8edChris Lattner OptimizeGEPExpression(GEPI, TLI.getTargetData()); 256636b708f05720c407f5e5657f2fd4b0677702ad46Chris Lattner } 2567c9ea6fde305b35ab7c9f909ac390d4b53e33d536Chris Lattner 25681c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner FunctionLoweringInfo FuncInfo(TLI, Fn, MF); 25691c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) 25711c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SelectBasicBlock(I, MF, FuncInfo); 2572edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 25731c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner return true; 25741c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 25751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 25761c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2577ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerSDOperand SelectionDAGISel:: 2578ddb870b065984007a0df645ad97c6ad6a6f12de0Chris LattnerCopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) { 2579f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner SDOperand Op = SDL.getValue(V); 258018c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner assert((Op.getOpcode() != ISD::CopyFromReg || 2581d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) && 258218c2f13e0f9d0e5d6227cf6d1881e9ee3d1b6109Chris Lattner "Copy from a reg to the same reg!"); 2583d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner 2584d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // If this type is not legal, we must make sure to not create an invalid 2585d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // register use. 2586d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType SrcVT = Op.getValueType(); 2587d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT); 2588d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SelectionDAG &DAG = SDL.DAG; 2589d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner if (SrcVT == DestVT) { 2590d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 25911c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } else if (SrcVT == MVT::Vector) { 25921c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner // FIXME: THIS DOES NOT SUPPORT PROMOTED/EXPANDED ELEMENTS! 25931c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 25941c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner // Figure out the right, legal destination reg to copy into. 25951c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner const PackedType *PTy = cast<PackedType>(V->getType()); 25961c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner unsigned NumElts = PTy->getNumElements(); 25971c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner MVT::ValueType EltTy = TLI.getValueType(PTy->getElementType()); 25981c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 25991c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner unsigned NumVectorRegs = 1; 26001c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 26011c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner // Divide the input until we get to a supported size. This will always 26021c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner // end with a scalar if the target doesn't support vectors. 26031c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner while (NumElts > 1 && !TLI.isTypeLegal(getVectorType(EltTy, NumElts))) { 26041c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner NumElts >>= 1; 26051c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner NumVectorRegs <<= 1; 26061c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner } 26071c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 26081c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner MVT::ValueType VT; 26091c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner if (NumElts == 1) 26101c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner VT = EltTy; 26111c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner else 26121c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner VT = getVectorType(EltTy, NumElts); 26131c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner 26141c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner // FIXME: THIS ASSUMES THAT THE INPUT VECTOR WILL BE LEGAL! 26151c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner Op = DAG.getNode(ISD::BIT_CONVERT, VT, Op); 26161c6191ffe764f3294cc2dda2bb3703403a416414Chris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 2617d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else if (SrcVT < DestVT) { 2618d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is promoted to the register. 2619fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner if (MVT::isFloatingPoint(SrcVT)) 2620fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op); 2621fae59b99b8d1942f30a4be609423282c3fd62dd8Chris Lattner else 2622fab08875b73656f373b10a59aad475615df82bafChris Lattner Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op); 2623d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(SDL.getRoot(), Reg, Op); 2624d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } else { 2625d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner // The src value is expanded into multiple registers. 2626d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 2627d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(0, MVT::i32)); 2628d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT, 2629d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op, DAG.getConstant(1, MVT::i32)); 2630d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo); 2631d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner return DAG.getCopyToReg(Op, Reg+1, Hi); 2632d5d0f9bd20d9df07d6b4d41b7e8ed6d33b6a649dChris Lattner } 26331c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 26341c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2635068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel:: 2636068a81e9fca511b9a3b3a0f28a8988a57f994652Chris LattnerLowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL, 2637068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> &UnorderedChains) { 26381c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // If this is the entry block, emit arguments. 2639068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner Function &F = *BB->getParent(); 26400afa8e348eab21d3e09ae3240544886d61879266Chris Lattner FunctionLoweringInfo &FuncInfo = SDL.FuncInfo; 2641bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand OldRoot = SDL.DAG.getRoot(); 2642bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG); 2643bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2644bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner unsigned a = 0; 2645bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 2646bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner AI != E; ++AI, ++a) 2647bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (!AI->use_empty()) { 2648bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDL.setValue(AI, Args[a]); 2649fa57702388f139e964befecb4b98c7dfe836945fChris Lattner 2650bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // If this argument is live outside of the entry block, insert a copy from 2651bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // whereever we got it to the vreg that other BB's will reference it as. 2652bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (FuncInfo.ValueMap.count(AI)) { 2653bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SDOperand Copy = 2654bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]); 2655bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner UnorderedChains.push_back(Copy); 2656bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner } 26570afa8e348eab21d3e09ae3240544886d61879266Chris Lattner } 2658bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2659bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Next, if the function has live ins that need to be copied into vregs, 2660bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // emit the copies now, into the top of the block. 2661bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MachineFunction &MF = SDL.DAG.getMachineFunction(); 2662bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (MF.livein_begin() != MF.livein_end()) { 2663bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner SSARegMap *RegMap = MF.getSSARegMap(); 2664bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner const MRegisterInfo &MRI = *MF.getTarget().getRegisterInfo(); 2665bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner for (MachineFunction::livein_iterator LI = MF.livein_begin(), 2666bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner E = MF.livein_end(); LI != E; ++LI) 2667bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LI->second) 2668bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner MRI.copyRegToReg(*MF.begin(), MF.begin()->end(), LI->second, 2669bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LI->first, RegMap->getRegClass(LI->second)); 26701c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2671bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner 2672bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Finally, if the target has anything special to do, allow it to do so. 2673bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction()); 2674068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner} 2675068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 2676068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 2677068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattnervoid SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, 2678068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate, 2679f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 2680068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner SelectionDAGLowering SDL(DAG, TLI, FuncInfo); 2681068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner 2682068a81e9fca511b9a3b3a0f28a8988a57f994652Chris Lattner std::vector<SDOperand> UnorderedChains; 2683edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2684bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner // Lower any arguments needed in this block if this is the entry block. 2685bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner if (LLVMBB == &LLVMBB->getParent()->front()) 2686bf209489ad3f7a38ce6b2159b22d8727500e60c2Chris Lattner LowerArguments(LLVMBB, SDL, UnorderedChains); 26871c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 26881c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BB = FuncInfo.MBBMap[LLVMBB]; 26891c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.setCurrentBasicBlock(BB); 26901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 26911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower all of the non-terminator instructions. 26921c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end(); 26931c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner I != E; ++I) 26941c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*I); 2695f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 26961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Ensure that all instructions which are used outside of their defining 26971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // blocks are available as virtual registers. 26981c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I) 2699f1fdacae8c1bd9e5ff4619546b3a28e93fb75ab5Chris Lattner if (!I->use_empty() && !isa<PHINode>(I)) { 2700ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I); 27011c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner if (VMI != FuncInfo.ValueMap.end()) 2702ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 2703ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, I, VMI->second)); 27041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 27051c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27061c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to 27071c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // ensure constants are generated when needed. Remember the virtual registers 27081c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // that need to be added to the Machine PHI nodes as input. We cannot just 27091c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // directly add them, because expansion might result in multiple MBB's for one 27101c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // BB. As such, the start of the BB might correspond to a different MBB than 27111c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the end. 2712edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // 27131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27141c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Emit constants only once even if used by multiple PHI nodes. 27151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner std::map<Constant*, unsigned> ConstantsOut; 27161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27171c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Check successor nodes PHI nodes that expect a constant to be available from 27181c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // this block. 27191c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner TerminatorInst *TI = LLVMBB->getTerminator(); 27201c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) { 27211c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner BasicBlock *SuccBB = TI->getSuccessor(succ); 27221c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin(); 27231c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner PHINode *PN; 27241c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 27251c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // At this point we know that there is a 1-1 correspondence between LLVM PHI 27261c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // nodes and Machine PHI nodes, but the incoming operands have not been 27271c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // emitted yet. 27281c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner for (BasicBlock::iterator I = SuccBB->begin(); 2729f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner (PN = dyn_cast<PHINode>(I)); ++I) 2730f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (!PN->use_empty()) { 2731f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned Reg; 2732f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB); 2733f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (Constant *C = dyn_cast<Constant>(PHIOp)) { 2734f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned &RegOut = ConstantsOut[C]; 2735f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner if (RegOut == 0) { 2736f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner RegOut = FuncInfo.CreateRegForValue(C); 2737ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 2738ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, C, RegOut)); 2739f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } 2740f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = RegOut; 2741f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner } else { 2742f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner Reg = FuncInfo.ValueMap[PHIOp]; 2743ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner if (Reg == 0) { 2744edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(isa<AllocaInst>(PHIOp) && 2745ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) && 2746ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner "Didn't codegen value into a register!??"); 2747ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner Reg = FuncInfo.CreateRegForValue(PHIOp); 2748ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner UnorderedChains.push_back( 2749ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner CopyValueToVirtualRegister(SDL, PHIOp, Reg)); 2750ee749d7488bd42df0f67e2d80048c63415943785Chris Lattner } 27511c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2752edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 2753f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // Remember that this register needs to added to the machine PHI node as 2754f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner // the input for this MBB. 2755f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner unsigned NumElements = 2756f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner TLI.getNumElements(TLI.getValueType(PN->getType())); 2757f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) 2758f44fd88e9cdd7b47acb71ac78e3dccb91319c72dChris Lattner PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i)); 27591c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 27601c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 27611c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner ConstantsOut.clear(); 27621c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2763ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner // Turn all of the unordered chains into one factored node. 27645a6c6d98d561df671350a56c8031a3611f1c46faChris Lattner if (!UnorderedChains.empty()) { 27657436b57de32333cc337b8c7cea208c8863eee793Chris Lattner SDOperand Root = SDL.getRoot(); 27667436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (Root.getOpcode() != ISD::EntryToken) { 27677436b57de32333cc337b8c7cea208c8863eee793Chris Lattner unsigned i = 0, e = UnorderedChains.size(); 27687436b57de32333cc337b8c7cea208c8863eee793Chris Lattner for (; i != e; ++i) { 27697436b57de32333cc337b8c7cea208c8863eee793Chris Lattner assert(UnorderedChains[i].Val->getNumOperands() > 1); 27707436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (UnorderedChains[i].Val->getOperand(0) == Root) 27717436b57de32333cc337b8c7cea208c8863eee793Chris Lattner break; // Don't add the root if we already indirectly depend on it. 27727436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 27737436b57de32333cc337b8c7cea208c8863eee793Chris Lattner 27747436b57de32333cc337b8c7cea208c8863eee793Chris Lattner if (i == e) 27757436b57de32333cc337b8c7cea208c8863eee793Chris Lattner UnorderedChains.push_back(Root); 27767436b57de32333cc337b8c7cea208c8863eee793Chris Lattner } 2777ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains)); 2778ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner } 2779ddb870b065984007a0df645ad97c6ad6a6f12de0Chris Lattner 27801c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Lower the terminator after the copies are emitted. 27811c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner SDL.visit(*LLVMBB->getTerminator()); 2782a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner 2783f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Copy over any CaseBlock records that may now exist due to SwitchInst 2784f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // lowering. 2785f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases.clear(); 2786f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SwitchCases = SDL.SwitchCases; 2787f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2788a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner // Make sure the root of the DAG is up-to-date. 2789a651cf67b77cd477dd7da4baa8688af2ccd4f7f6Chris Lattner DAG.setRoot(SDL.getRoot()); 27901c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 27911c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2792f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::CodeGenAndEmitDAG(SelectionDAG &DAG) { 2793af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in pre-legalize mode. 2794af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(false); 27952300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 27961c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Lowered selection DAG:\n"); 27971c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 2798f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 27991c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // Second step, hack on the DAG until it only uses operations and types that 28001c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // the target supports. 2801ac9dc08c7f0ae60c125624d72c3022025d79ee9eChris Lattner DAG.Legalize(); 2802f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 28031c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Legalized selection DAG:\n"); 28041c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(DAG.dump()); 2805f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2806af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner // Run the DAG combiner in post-legalize mode. 2807af21d55aee8d6852fedfd630395a3c7c95df8f12Chris Lattner DAG.Combine(true); 28082300f5504643eaddc307d3db8a3ccd224c4fa251Nate Begeman 2809a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewISelDAGs) DAG.viewGraph(); 2810d48050aa1509130871b8bb2453270c92b969c2e7Chris Lattner 2811a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Third, instruction select all of the operations to machine code, adding the 2812a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // code to the MachineBasicBlock. 28131c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner InstructionSelectBasicBlock(DAG); 2814f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 28151c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(std::cerr << "Selected machine code:\n"); 28161c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner DEBUG(BB->dump()); 2817f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman} 2818f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2819f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begemanvoid SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, 2820f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman FunctionLoweringInfo &FuncInfo) { 2821f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate; 2822f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman { 2823f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG DAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 2824f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &DAG; 2825f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2826f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // First step, lower LLVM code to some DAG. This DAG may use operations and 2827f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // types that are not supported by the target. 2828f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo); 28291c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner 2830f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Second step, emit the lowered DAG as machine code. 2831f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(DAG); 2832f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 2833f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2834a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner // Next, now that we know what the last MBB the LLVM BB expanded is, update 28351c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner // PHI nodes in successors. 2836f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (SwitchCases.empty()) { 2837f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) { 2838f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[i].first; 2839f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 2840f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 2841f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addRegOperand(PHINodesToUpdate[i].second); 2842f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 2843f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 2844f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman return; 28451c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner } 2846f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman 2847f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // If we generated any switch lowering information, build and codegen any 2848f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // additional DAGs necessary. 2849f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for(unsigned i = 0, e = SwitchCases.size(); i != e; ++i) { 2850f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAG SDAG(TLI, MF, getAnalysisToUpdate<MachineDebugInfo>()); 2851f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CurDAG = &SDAG; 2852f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SelectionDAGLowering SDL(SDAG, TLI, FuncInfo); 2853f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Set the current basic block to the mbb we wish to insert the code into 2854f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman BB = SwitchCases[i].ThisBB; 2855f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.setCurrentBasicBlock(BB); 2856f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Emit the code 2857f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDL.visitSwitchCase(SwitchCases[i]); 2858f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman SDAG.setRoot(SDL.getRoot()); 2859f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman CodeGenAndEmitDAG(SDAG); 2860f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // Iterate over the phi nodes, if there is a phi node in a successor of this 2861f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // block (for instance, the default block), then add a pair of operands to 2862f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // the phi node for this block, as if we were coming from the original 2863f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman // BB before switch expansion. 2864f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman for (unsigned pi = 0, pe = PHINodesToUpdate.size(); pi != pe; ++pi) { 2865f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineInstr *PHI = PHINodesToUpdate[pi].first; 2866f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman MachineBasicBlock *PHIBB = PHI->getParent(); 2867f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman assert(PHI->getOpcode() == TargetInstrInfo::PHI && 2868f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman "This is not a machine PHI node that we are updating!"); 2869f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman if (PHIBB == SwitchCases[i].LHSBB || PHIBB == SwitchCases[i].RHSBB) { 2870f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addRegOperand(PHINodesToUpdate[pi].second); 2871f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman PHI->addMachineBasicBlockOperand(BB); 2872f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 2873f15485a8d0dff5f720b7ad27346129ac5c3ec503Nate Begeman } 2874a33ef4816d2c192e36e7c025d18c66e89ef9d311Chris Lattner } 28751c08c714bb3d07c3b39f06bfcbb4559fefca73f9Chris Lattner} 2876a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng 2877a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng//===----------------------------------------------------------------------===// 2878a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// ScheduleAndEmitDAG - Pick a safe ordering and emit instructions for each 2879a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng/// target node in the graph. 2880a9c2091cd38e401c846391c9951ff416e709b65eEvan Chengvoid SelectionDAGISel::ScheduleAndEmitDAG(SelectionDAG &DAG) { 2881a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng if (ViewSchedDAGs) DAG.viewGraph(); 28824ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng ScheduleDAG *SL = NULL; 28834ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng 28844ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng switch (ISHeuristic) { 28854ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng default: assert(0 && "Unrecognized scheduling heuristic"); 28863f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng case defaultScheduling: 28873f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng if (TLI.getSchedulingPreference() == TargetLowering::SchedulingForLatency) 28883f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng SL = createSimpleDAGScheduler(noScheduling, DAG, BB); 28893f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng else /* TargetLowering::SchedulingForRegPressure */ 28903f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng SL = createBURRListDAGScheduler(DAG, BB); 28913f23952404cd03a8ab934cedcef7916f52a796c0Evan Cheng break; 28924ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case noScheduling: 289320a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner SL = createBFS_DAGScheduler(DAG, BB); 289420a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner break; 28954ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case simpleScheduling: 289620a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner SL = createSimpleDAGScheduler(false, DAG, BB); 289720a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner break; 28984ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng case simpleNoItinScheduling: 289920a4921791eafc0cce00fb01dcacfcfc15a0d0fcChris Lattner SL = createSimpleDAGScheduler(true, DAG, BB); 29004ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng break; 2901f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng case listSchedulingBURR: 2902f0f9c90204c650b9f3c3feb02ccfcb1e40c6acddEvan Cheng SL = createBURRListDAGScheduler(DAG, BB); 2903a5de484bc7c8f896b5903999797c4d57f4e45185Chris Lattner break; 290403fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner case listSchedulingTD: 2905b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner SL = createTDListDAGScheduler(DAG, BB, CreateTargetHazardRecognizer()); 2906a5de484bc7c8f896b5903999797c4d57f4e45185Chris Lattner break; 29074ef10867499aa146cd819c78d8d37a8353d4f0ffEvan Cheng } 2908a3818e6f9a62db0c5b6aee28e44c30d5f96c9fa4Chris Lattner BB = SL->Run(); 2909cccf1232a69e2d78516c61a97e7bfa26acefb714Evan Cheng delete SL; 2910a9c2091cd38e401c846391c9951ff416e709b65eEvan Cheng} 29110e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 2912b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris LattnerHazardRecognizer *SelectionDAGISel::CreateTargetHazardRecognizer() { 2913b0d21ef20c29f4ea46d21b488f17feaa6a8760e1Chris Lattner return new HazardRecognizer(); 291403fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner} 291503fc53c174e654adae4e42a0c352c7937de2cd87Chris Lattner 29160e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// SelectInlineAsmMemoryOperands - Calls to this are automatically generated 29170e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner/// by tblgen. Others should not call it. 29180e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattnervoid SelectionDAGISel:: 29190e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris LattnerSelectInlineAsmMemoryOperands(std::vector<SDOperand> &Ops, SelectionDAG &DAG) { 29200e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> InOps; 29210e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::swap(InOps, Ops); 29220e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 29230e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[0]); // input chain. 29240e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps[1]); // input asm string. 29250e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 29260e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner const char *AsmStr = cast<ExternalSymbolSDNode>(InOps[1])->getSymbol(); 29270e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned i = 2, e = InOps.size(); 29280e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (InOps[e-1].getValueType() == MVT::Flag) 29290e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner --e; // Don't process a flag operand if it is here. 29300e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 29310e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner while (i != e) { 29320e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner unsigned Flags = cast<ConstantSDNode>(InOps[i])->getValue(); 29330e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if ((Flags & 7) != 4 /*MEM*/) { 29340e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Just skip over this operand, copying the operands verbatim. 29350e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), InOps.begin()+i, InOps.begin()+i+(Flags >> 3) + 1); 29360e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += (Flags >> 3) + 1; 29370e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } else { 29380e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner assert((Flags >> 3) == 1 && "Memory operand with multiple values?"); 29390e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Otherwise, this is a memory operand. Ask the target to select it. 29400e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::vector<SDOperand> SelOps; 29410e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (SelectInlineAsmMemoryOperand(InOps[i+1], 'm', SelOps, DAG)) { 29420e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner std::cerr << "Could not match memory address. Inline asm failure!\n"; 29430e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner exit(1); 29440e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 29450e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 29460e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add this to the output node. 29470e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(DAG.getConstant(4/*MEM*/ | (SelOps.size() << 3), MVT::i32)); 29480e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.insert(Ops.end(), SelOps.begin(), SelOps.end()); 29490e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner i += 2; 29500e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 29510e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner } 29520e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner 29530e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner // Add the flag input back if present. 29540e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner if (e != InOps.size()) 29550e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner Ops.push_back(InOps.back()); 29560e43f2ba114df7bfc1f70d0ef62b663f6ea4c09dChris Lattner} 2957