16b9445389a226b4ac97ceb89a34ee1a5bf921714Chris Lattner//===-- MachineFunction.cpp -----------------------------------------------===// 276d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 776d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 976d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos// 106b9445389a226b4ac97ceb89a34ee1a5bf921714Chris Lattner// Collect native machine code information for a function. This allows 116b9445389a226b4ac97ceb89a34ee1a5bf921714Chris Lattner// target-specific information about the generated code to be stored with each 126b9445389a226b4ac97ceb89a34ee1a5bf921714Chris Lattner// function. 136b9445389a226b4ac97ceb89a34ee1a5bf921714Chris Lattner// 146b9445389a226b4ac97ceb89a34ee1a5bf921714Chris Lattner//===----------------------------------------------------------------------===// 15f2868ce228ca20f72d1c6fbe241de01975cfe609Chris Lattner 166b2760759b23b8b96beb43966b9b8088e832efc7Chris Lattner#include "llvm/CodeGen/MachineFunction.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/STLExtras.h" 18d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallString.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Analysis/ConstantFolding.h" 20f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar#include "llvm/Analysis/EHPersonalities.h" 2184bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 22eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 236948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar#include "llvm/CodeGen/MachineFunctionInitializer.h" 24d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/MachineFunctionPass.h" 2584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineInstr.h" 2637efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 27820e55e9ad3cb3b17780e84863648e431b571d25Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 2884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 2916c45e9de896ea37d48d093dbe02fc9a4c1b9f8fChris Lattner#include "llvm/CodeGen/Passes.h" 30f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar#include "llvm/CodeGen/PseudoSourceValue.h" 31f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar#include "llvm/CodeGen/WinEHFuncInfo.h" 320b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 3336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/DebugInfo.h" 340b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 35f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar#include "llvm/IR/Module.h" 36f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar#include "llvm/IR/ModuleSlotTracker.h" 37beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner#include "llvm/MC/MCAsmInfo.h" 38beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner#include "llvm/MC/MCContext.h" 39dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greene#include "llvm/Support/Debug.h" 40f28bbda2c6c965dbd28e73e06c9e09231a77b0dcChris Lattner#include "llvm/Support/GraphWriter.h" 41944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattner#include "llvm/Support/raw_ostream.h" 42d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetFrameLowering.h" 43d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetLowering.h" 44d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetMachine.h" 4537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines#include "llvm/Target/TargetSubtargetInfo.h" 4607f32d48f1e16bcdc621985549548a5849215238Chris Lattnerusing namespace llvm; 47f2868ce228ca20f72d1c6fbe241de01975cfe609Chris Lattner 48dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "codegen" 49dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 50de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarstatic cl::opt<unsigned> 51de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar AlignAllFunctions("align-all-functions", 52de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar cl::desc("Force the alignment of all functions."), 53de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar cl::init(0), cl::Hidden); 54de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 556948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarvoid MachineFunctionInitializer::anchor() {} 566948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 57de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarvoid MachineFunctionProperties::print(raw_ostream &ROS, bool OnlySet) const { 58de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Leave this function even in NDEBUG as an out-of-line anchor. 59de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 60de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (BitVector::size_type i = 0; i < Properties.size(); ++i) { 61de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool HasProperty = Properties[i]; 62de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (OnlySet && !HasProperty) 63de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 64de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar switch(static_cast<Property>(i)) { 65de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Property::IsSSA: 66de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ROS << (HasProperty ? "SSA, " : "Post SSA, "); 67de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar break; 68de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Property::TracksLiveness: 69de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ROS << (HasProperty ? "" : "not ") << "tracking liveness, "; 70de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar break; 71de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Property::AllVRegsAllocated: 72de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ROS << (HasProperty ? "AllVRegsAllocated" : "HasVRegs"); 73de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar break; 74de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar default: 75de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar break; 76de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 77de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 78de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#endif 79de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 80de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 81b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner//===----------------------------------------------------------------------===// 82227c3d355b017393963a690f9f27d1de7fa359bcChris Lattner// MachineFunction implementation 83b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner//===----------------------------------------------------------------------===// 849d5d7598db72c00a0fb89dc77198e4f6ebc5294dChris Lattner 856948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar// Out-of-line virtual method. 86a70e2e3d4831b8a39ea6bae5c62df29fa82a86f3Chris LattnerMachineFunctionInfo::~MachineFunctionInfo() {} 87a70e2e3d4831b8a39ea6bae5c62df29fa82a86f3Chris Lattner 88fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanvoid ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) { 898e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MBB->getParent()->DeleteMachineBasicBlock(MBB); 90792699c46ef9bfc47dd459bbfa7e71bcb2cee29aTanya Lattner} 91227c3d355b017393963a690f9f27d1de7fa359bcChris Lattner 92de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarstatic inline unsigned getFnStackAlignment(const TargetSubtargetInfo *STI, 93de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const Function *Fn) { 94de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Fn->hasFnAttribute(Attribute::StackAlignment)) 95de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return Fn->getFnStackAlignment(); 96de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return STI->getFrameLowering()->getStackAlignment(); 97de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 98de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 99ae541aad5c36cb3e4256514447d1f81e253079c7Dan GohmanMachineFunction::MachineFunction(const Function *F, const TargetMachine &TM, 10037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned FunctionNum, MachineModuleInfo &mmi) 1014c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar : Fn(F), Target(TM), STI(TM.getSubtargetImpl(*F)), Ctx(mmi.getContext()), 10237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MMI(mmi) { 103de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Assume the function starts in SSA form with correct liveness. 104de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Properties.set(MachineFunctionProperties::Property::IsSSA); 105de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Properties.set(MachineFunctionProperties::Property::TracksLiveness); 10637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (STI->getRegisterInfo()) 10737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RegInfo = new (Allocator) MachineRegisterInfo(this); 108e2b997b7b5360b4793c524a801e988fd37b80b93Matthijs Kooijman else 109dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RegInfo = nullptr; 110d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 111dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MFInfo = nullptr; 112de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // We can realign the stack if the target supports it and the user hasn't 113de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // explicitly asked us not to. 114de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() && 115de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar !F->hasFnAttribute("no-realign-stack"); 116de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar FrameInfo = new (Allocator) MachineFrameInfo( 117de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar getFnStackAlignment(STI, Fn), /*StackRealignable=*/CanRealignSP, 118de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar /*ForceRealign=*/CanRealignSP && 119de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar F->hasFnAttribute(Attribute::StackAlignment)); 120d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 121ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Fn->hasFnAttribute(Attribute::StackAlignment)) 122ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines FrameInfo->ensureMaxAlignment(Fn->getFnStackAlignment()); 123d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 124f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ConstantPool = new (Allocator) MachineConstantPool(getDataLayout()); 12537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Alignment = STI->getTargetLowering()->getMinFunctionAlignment(); 126d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 127fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman // FIXME: Shouldn't use pref alignment if explicit alignment is set on Fn. 128f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // FIXME: Use Function::optForSize(). 129ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!Fn->hasFnAttribute(Attribute::OptimizeForSize)) 130fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman Alignment = std::max(Alignment, 13137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines STI->getTargetLowering()->getPrefFunctionAlignment()); 132d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 133de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (AlignAllFunctions) 134de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Alignment = AlignAllFunctions; 135de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 136b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner FunctionNumber = FunctionNum; 137dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines JumpTableInfo = nullptr; 138f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 139f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (isFuncletEHPersonality(classifyEHPersonality( 140f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar F->hasPersonalityFn() ? F->getPersonalityFn() : nullptr))) { 141f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar WinEHInfo = new (Allocator) WinEHFuncInfo(); 142f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 143f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 144f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar assert(TM.isCompatibleDataLayout(getDataLayout()) && 145f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar "Can't create a MachineFunction using a Module with a " 146f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar "Target-incompatible DataLayout attached\n"); 147f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 148f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar PSVManager = llvm::make_unique<PseudoSourceValueManager>(); 149831fdcf0177a4eef66129cd6fb4138922c492bf0Chris Lattner} 150831fdcf0177a4eef66129cd6fb4138922c492bf0Chris Lattner 15176d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis EvlogimenosMachineFunction::~MachineFunction() { 15284be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // Don't call destructors on MachineInstr and MachineOperand. All of their 15384be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // memory comes from the BumpPtrAllocator which is about to be purged. 15484be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // 15584be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // Do call MachineBasicBlock destructors, it contains std::vectors. 15684be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I)) 15784be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen I->Insts.clearAndLeakNodesUnsafely(); 15884be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen 1598e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman InstructionRecycler.clear(Allocator); 160f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen OperandRecycler.clear(Allocator); 1618e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman BasicBlockRecycler.clear(Allocator); 162dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling if (RegInfo) { 163dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling RegInfo->~MachineRegisterInfo(); 164dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling Allocator.Deallocate(RegInfo); 165dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling } 1668e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman if (MFInfo) { 167dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling MFInfo->~MachineFunctionInfo(); 168dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling Allocator.Deallocate(MFInfo); 1698e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman } 1700c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 1710c1eac8129f7e4e637074a482a085448e1680199Chad Rosier FrameInfo->~MachineFrameInfo(); 1720c1eac8129f7e4e637074a482a085448e1680199Chad Rosier Allocator.Deallocate(FrameInfo); 1730c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 1740c1eac8129f7e4e637074a482a085448e1680199Chad Rosier ConstantPool->~MachineConstantPool(); 1750c1eac8129f7e4e637074a482a085448e1680199Chad Rosier Allocator.Deallocate(ConstantPool); 1760c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 177071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (JumpTableInfo) { 178071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner JumpTableInfo->~MachineJumpTableInfo(); 179071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner Allocator.Deallocate(JumpTableInfo); 180071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner } 181f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 182f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (WinEHInfo) { 183f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar WinEHInfo->~WinEHFuncInfo(); 184f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Allocator.Deallocate(WinEHInfo); 185f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 186f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 187f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 188f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarconst DataLayout &MachineFunction::getDataLayout() const { 189f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Fn->getParent()->getDataLayout(); 1901049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner} 1911049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner 1926948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Get the JumpTableInfo for this function. 1936948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// If it does not already exist, allocate one. 194071c62fad0b25ad4131e7f984173a796c1e63f61Chris LattnerMachineJumpTableInfo *MachineFunction:: 195071c62fad0b25ad4131e7f984173a796c1e63f61Chris LattnergetOrCreateJumpTableInfo(unsigned EntryKind) { 196071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (JumpTableInfo) return JumpTableInfo; 1970c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 1989553188fccbf0ae9c5b6bef26d0d2bd5feff8b59Dan Gohman JumpTableInfo = new (Allocator) 199071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind); 200071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return JumpTableInfo; 201071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 202e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 203dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines/// Should we be emitting segmented stack stuff for the function 204de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarbool MachineFunction::shouldSplitStack() const { 205dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return getFunction()->hasFnAttribute("split-stack"); 206dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines} 207dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 2086948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// This discards all of the MachineBasicBlock numbers and recomputes them. 2096948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// This guarantees that the MBB numbers are sequential, dense, and match the 2106948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// ordering of the blocks within the function. If a specific MachineBasicBlock 2116948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// is specified, only that block and those after it are renumbered. 212e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattnervoid MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { 213e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (empty()) { MBBNumbering.clear(); return; } 214e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MachineFunction::iterator MBBI, E = end(); 215dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (MBB == nullptr) 216e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBI = begin(); 217e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner else 218f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar MBBI = MBB->getIterator(); 2190c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 220e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // Figure out the block number this should have. 221e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner unsigned BlockNo = 0; 222f28bbda2c6c965dbd28e73e06c9e09231a77b0dcChris Lattner if (MBBI != begin()) 22336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines BlockNo = std::prev(MBBI)->getNumber() + 1; 2240c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 225e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner for (; MBBI != E; ++MBBI, ++BlockNo) { 226e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBBI->getNumber() != (int)BlockNo) { 227e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // Remove use of the old number. 228e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBBI->getNumber() != -1) { 229e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner assert(MBBNumbering[MBBI->getNumber()] == &*MBBI && 230e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner "MBB number mismatch!"); 231dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MBBNumbering[MBBI->getNumber()] = nullptr; 232e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner } 2330c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 234e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // If BlockNo is already taken, set that block's number to -1. 235e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBBNumbering[BlockNo]) 236e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBNumbering[BlockNo]->setNumber(-1); 237e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 238f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar MBBNumbering[BlockNo] = &*MBBI; 239e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBI->setNumber(BlockNo); 240e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner } 2410c1eac8129f7e4e637074a482a085448e1680199Chad Rosier } 242e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 243e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // Okay, all the blocks are renumbered. If we have compactified the block 244e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // numbering, shrink MBBNumbering now. 245e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner assert(BlockNo <= MBBNumbering.size() && "Mismatch!"); 246e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBNumbering.resize(BlockNo); 247e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner} 248e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 2496948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Allocate a new MachineInstr. Use this instead of `new MachineInstr'. 250de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarMachineInstr *MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID, 251de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const DebugLoc &DL, 252de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool NoImp) { 2538e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) 2549500e5d07ac9b94c8fed74150e444778a0dcb036Jakob Stoklund Olesen MachineInstr(*this, MCID, DL, NoImp); 2558e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 2568e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 2576948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a new MachineInstr which is a copy of the 'Orig' instruction, 2586948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// identical in all ways except the instruction has no parent, prev, or next. 2598e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineInstr * 2608e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::CloneMachineInstr(const MachineInstr *Orig) { 2618e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) 2628e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MachineInstr(*this, *Orig); 2638e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 2648e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 2656948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Delete the given MachineInstr. 2668e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// 26784be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen/// This function also serves as the MachineInstr destructor - the real 26884be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen/// ~MachineInstr() destructor must be empty. 2698e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohmanvoid 2708e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::DeleteMachineInstr(MachineInstr *MI) { 271f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen // Strip it for parts. The operand array and the MI object itself are 272f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen // independently recyclable. 273f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen if (MI->Operands) 274f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen deallocateOperandArray(MI->CapOperands, MI->Operands); 27584be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // Don't call ~MachineInstr() which must be trivial anyway because 27684be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // ~MachineFunction drops whole lists of MachineInstrs wihout calling their 27784be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // destructors. 2788e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman InstructionRecycler.Deallocate(Allocator, MI); 2798e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 2808e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 2816948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Allocate a new MachineBasicBlock. Use this instead of 2826948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// `new MachineBasicBlock'. 2838e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineBasicBlock * 2848e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) { 2858e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator)) 2868e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MachineBasicBlock(*this, bb); 2878e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 288e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 2896948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Delete the given MachineBasicBlock. 2908e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohmanvoid 2918e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) { 2928e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman assert(MBB->getParent() == this && "MBB parent mismatch!"); 2938e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MBB->~MachineBasicBlock(); 2948e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman BasicBlockRecycler.Deallocate(Allocator, MBB); 2958e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 2968e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 297c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineMemOperand * 298da39c3964423744b4d79aebef8bece3e9141d5fcChris LattnerMachineFunction::getMachineMemOperand(MachinePointerInfo PtrInfo, unsigned f, 299f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman uint64_t s, unsigned base_alignment, 30037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const AAMDNodes &AAInfo, 30195d594cac3737ae1594a391276942a443cac426bRafael Espindola const MDNode *Ranges) { 302de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // FIXME: Get rid of this static_cast and make getMachineOperand take a 303de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // MachineMemOperand::Flags param. 304de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return new (Allocator) 305de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar MachineMemOperand(PtrInfo, static_cast<MachineMemOperand::Flags>(f), s, 306de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar base_alignment, AAInfo, Ranges); 307c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 308c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 309c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineMemOperand * 310c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineFunction::getMachineMemOperand(const MachineMemOperand *MMO, 311c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman int64_t Offset, uint64_t Size) { 312dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (MMO->getValue()) 313dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return new (Allocator) 314dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineMemOperand(MachinePointerInfo(MMO->getValue(), 315dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MMO->getOffset()+Offset), 316dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MMO->getFlags(), Size, 31737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MMO->getBaseAlignment()); 3189553188fccbf0ae9c5b6bef26d0d2bd5feff8b59Dan Gohman return new (Allocator) 319dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineMemOperand(MachinePointerInfo(MMO->getPseudoValue(), 320da39c3964423744b4d79aebef8bece3e9141d5fcChris Lattner MMO->getOffset()+Offset), 321f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman MMO->getFlags(), Size, 32237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MMO->getBaseAlignment()); 323c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 324c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 325c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineInstr::mmo_iterator 326c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineFunction::allocateMemRefsArray(unsigned long Num) { 327c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return Allocator.Allocate<MachineMemOperand *>(Num); 328c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 329c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 33091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohmanstd::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator> 33191e69c37153eb7d8cd149d9c2484c3115027b90fDan GohmanMachineFunction::extractLoadMemRefs(MachineInstr::mmo_iterator Begin, 33291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator End) { 33391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Count the number of load mem refs. 33491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Num = 0; 33591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) 33691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isLoad()) 33791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Num; 33891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 33991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Allocate a new array and populate it with the load information. 34091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num); 34191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Index = 0; 34291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) { 34391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isLoad()) { 34491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if (!(*I)->isStore()) 34591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Reuse the MMO. 34691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = *I; 34791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman else { 34891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Clone the MMO and unset the store flag. 34991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineMemOperand *JustLoad = 35093a95ae8a9d8eb19dc0d90281473be2fb1c05a17Chris Lattner getMachineMemOperand((*I)->getPointerInfo(), 35191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman (*I)->getFlags() & ~MachineMemOperand::MOStore, 352f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman (*I)->getSize(), (*I)->getBaseAlignment(), 35337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines (*I)->getAAInfo()); 35491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = JustLoad; 35591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 35691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Index; 35791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 35891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 35991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman return std::make_pair(Result, Result + Num); 36091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman} 36191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 36291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohmanstd::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator> 36391e69c37153eb7d8cd149d9c2484c3115027b90fDan GohmanMachineFunction::extractStoreMemRefs(MachineInstr::mmo_iterator Begin, 36491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator End) { 36591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Count the number of load mem refs. 36691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Num = 0; 36791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) 36891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isStore()) 36991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Num; 37091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 37191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Allocate a new array and populate it with the store information. 37291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num); 37391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Index = 0; 37491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) { 37591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isStore()) { 37691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if (!(*I)->isLoad()) 37791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Reuse the MMO. 37891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = *I; 37991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman else { 38091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Clone the MMO and unset the load flag. 38191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineMemOperand *JustStore = 38293a95ae8a9d8eb19dc0d90281473be2fb1c05a17Chris Lattner getMachineMemOperand((*I)->getPointerInfo(), 38391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman (*I)->getFlags() & ~MachineMemOperand::MOLoad, 384f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman (*I)->getSize(), (*I)->getBaseAlignment(), 38537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines (*I)->getAAInfo()); 38691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = JustStore; 38791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 38891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Index; 38991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 39091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 39191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman return std::make_pair(Result, Result + Num); 39291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman} 39391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 394f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarconst char *MachineFunction::createExternalSymbolName(StringRef Name) { 395f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar char *Dest = Allocator.Allocate<char>(Name.size() + 1); 396f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar std::copy(Name.begin(), Name.end(), Dest); 397f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Dest[Name.size()] = 0; 398f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Dest; 399f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 400f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 401b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 402de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarLLVM_DUMP_METHOD void MachineFunction::dump() const { 403dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greene print(dbgs()); 4048e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 40577e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 4061049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner 40796601ca332ab388754ca4673be8973396fea2dddCraig TopperStringRef MachineFunction::getName() const { 40896601ca332ab388754ca4673be8973396fea2dddCraig Topper assert(getFunction() && "No function!"); 40996601ca332ab388754ca4673be8973396fea2dddCraig Topper return getFunction()->getName(); 41096601ca332ab388754ca4673be8973396fea2dddCraig Topper} 41196601ca332ab388754ca4673be8973396fea2dddCraig Topper 412de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarvoid MachineFunction::print(raw_ostream &OS, const SlotIndexes *Indexes) const { 413986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie OS << "# Machine code for function " << getName() << ": "; 414de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar OS << "Properties: <"; 415de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar getProperties().print(OS); 416de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar OS << ">\n"; 417955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 418955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner // Print Frame Information 4198e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman FrameInfo->print(*this, OS); 4200c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 42137efe6764568a3829fee26aba532283131d1a104Nate Begeman // Print JumpTable Information 422071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (JumpTableInfo) 423071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner JumpTableInfo->print(OS); 4244d149cdae1553426f49623fdae215d481d56d955Chris Lattner 4254d149cdae1553426f49623fdae215d481d56d955Chris Lattner // Print Constant Pool 426d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattner ConstantPool->print(OS); 4270c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 42837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const TargetRegisterInfo *TRI = getSubtarget().getRegisterInfo(); 4290c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 430e2b997b7b5360b4793c524a801e988fd37b80b93Matthijs Kooijman if (RegInfo && !RegInfo->livein_empty()) { 4310ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Function Live Ins: "; 43284bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner for (MachineRegisterInfo::livein_iterator 43384bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) { 434e2f669fb3fa7a6bee4196999b119a98f31c072a3Jakob Stoklund Olesen OS << PrintReg(I->first, TRI); 4354e92027837136233db0fc1c1a4fa2bc456d74de3Chris Lattner if (I->second) 436e2f669fb3fa7a6bee4196999b119a98f31c072a3Jakob Stoklund Olesen OS << " in " << PrintReg(I->second, TRI); 43736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (std::next(I) != E) 4380ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", "; 439a1f68ca94e763945f9accc75768a55a84bae6cfbChris Lattner } 440d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattner OS << '\n'; 441a1f68ca94e763945f9accc75768a55a84bae6cfbChris Lattner } 4420c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 443f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ModuleSlotTracker MST(getFunction()->getParent()); 444f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar MST.incorporateFunction(*getFunction()); 445dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (const auto &BB : *this) { 4460ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << '\n'; 447f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar BB.print(OS, MST, Indexes); 4480ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman } 44947b716483ef2d057c8a0015af20685755e606d0dBrian Gaeke 450986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie OS << "\n# End machine code for function " << getName() << ".\n\n"; 4511049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner} 4521049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner 45371bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenosnamespace llvm { 45476d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos template<> 45576d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits { 456a10d598602308549d87d2c5d9848f5a72fda2b43Tobias Grosser 457a10d598602308549d87d2c5d9848f5a72fda2b43Tobias Grosser DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {} 458a10d598602308549d87d2c5d9848f5a72fda2b43Tobias Grosser 45976d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos static std::string getGraphName(const MachineFunction *F) { 4600c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar return ("CFG for '" + F->getName() + "' function").str(); 46176d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 46271bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 46356f4ef3232850e29c4635d0923910acce8887bd0Tobias Grosser std::string getNodeLabel(const MachineBasicBlock *Node, 46456f4ef3232850e29c4635d0923910acce8887bd0Tobias Grosser const MachineFunction *Graph) { 465cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner std::string OutStr; 466cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner { 467cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner raw_string_ostream OSS(OutStr); 468e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen 469e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen if (isSimple()) { 470e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen OSS << "BB#" << Node->getNumber(); 471e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen if (const BasicBlock *BB = Node->getBasicBlock()) 472e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen OSS << ": " << BB->getName(); 473e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen } else 474cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner Node->print(OSS); 47576d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 47671bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 47776d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); 47871bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 47976d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos // Process string output to make it nicer... 48076d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos for (unsigned i = 0; i != OutStr.length(); ++i) 48176d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos if (OutStr[i] == '\n') { // Left justify 48276d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OutStr[i] = '\\'; 48376d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OutStr.insert(OutStr.begin()+i+1, 'l'); 48476d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 48576d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos return OutStr; 48676d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 48776d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos }; 48871bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos} 48971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 49071bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenosvoid MachineFunction::viewCFG() const 49171bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos{ 492851a22db2bdbcab1768a87c4f02b5972e48db5edJim Laskey#ifndef NDEBUG 493986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie ViewGraph(this, "mf" + getName()); 4949d5b532de9bdca37810a59a93a69128441b02c55Reid Spencer#else 495643fffe429cc467584c795f6177741944729e0a5Dan Gohman errs() << "MachineFunction::viewCFG is only available in debug builds on " 49643ed267db3512823a9698f810be4e64bee227270Daniel Dunbar << "systems with Graphviz or gv!\n"; 4979d5b532de9bdca37810a59a93a69128441b02c55Reid Spencer#endif // NDEBUG 49871bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos} 49971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 50071bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenosvoid MachineFunction::viewCFGOnly() const 50171bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos{ 5028cbc94afb71fd2da72d8f1284f7f53e39019fdecOwen Anderson#ifndef NDEBUG 503986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie ViewGraph(this, "mf" + getName(), true); 5048cbc94afb71fd2da72d8f1284f7f53e39019fdecOwen Anderson#else 505643fffe429cc467584c795f6177741944729e0a5Dan Gohman errs() << "MachineFunction::viewCFGOnly is only available in debug builds on " 50643ed267db3512823a9698f810be4e64bee227270Daniel Dunbar << "systems with Graphviz or gv!\n"; 5078cbc94afb71fd2da72d8f1284f7f53e39019fdecOwen Anderson#endif // NDEBUG 50871bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos} 50971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 5106948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Add the specified physical register as a live-in value and 511998e125a87d49f28c714d8223a37746850401057Bob Wilson/// create a corresponding virtual register for it. 512998e125a87d49f28c714d8223a37746850401057Bob Wilsonunsigned MachineFunction::addLiveIn(unsigned PReg, 51368e6beeccc0b9ac2e8d3687a8a5b7d4b172edca1Devang Patel const TargetRegisterClass *RC) { 5143946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng MachineRegisterInfo &MRI = getRegInfo(); 5153946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng unsigned VReg = MRI.getLiveInVirtReg(PReg); 5163946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng if (VReg) { 51736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const TargetRegisterClass *VRegRC = MRI.getRegClass(VReg); 51836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines (void)VRegRC; 51936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // A physical register can be added several times. 52036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Between two calls, the register class of the related virtual register 52136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // may have been constrained to match some operation constraints. 52236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // In that case, check that the current register class includes the 52336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // physical register and is a sub class of the specified RC. 52436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert((VRegRC == RC || (VRegRC->contains(PReg) && 52536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RC->hasSubClassEq(VRegRC))) && 52636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines "Register class mismatch!"); 5273946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng return VReg; 5283946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng } 5293946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng VReg = MRI.createVirtualRegister(RC); 5303946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng MRI.addLiveIn(PReg, VReg); 531998e125a87d49f28c714d8223a37746850401057Bob Wilson return VReg; 532998e125a87d49f28c714d8223a37746850401057Bob Wilson} 533998e125a87d49f28c714d8223a37746850401057Bob Wilson 5346948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Return the MCSymbol for the specified non-empty jump table. 53507d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a 53607d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling/// normal 'L' label is returned. 537c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen HinesMCSymbol *MachineFunction::getJTISymbol(unsigned JTI, MCContext &Ctx, 53807d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling bool isLinkerPrivate) const { 539f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const DataLayout &DL = getDataLayout(); 540589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner assert(JumpTableInfo && "No jump tables"); 541de4c08008a10aba59171c56086d96c760990a4cbChandler Carruth assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!"); 5420c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 543f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const char *Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix() 544f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar : DL.getPrivateGlobalPrefix(); 545589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner SmallString<60> Name; 546589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner raw_svector_ostream(Name) 547589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner << Prefix << "JTI" << getFunctionNumber() << '_' << JTI; 5486948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return Ctx.getOrCreateSymbol(Name); 549589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner} 550589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner 5516948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Return a function-local symbol to represent the PIC base. 552142b531e024c7b814df74951b378b9e3e11d0d42Chris LattnerMCSymbol *MachineFunction::getPICBaseSymbol() const { 553f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const DataLayout &DL = getDataLayout(); 554f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) + 555f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Twine(getFunctionNumber()) + "$pb"); 556142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner} 557589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner 558955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner//===----------------------------------------------------------------------===// 559eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner// MachineFrameInfo implementation 560955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner//===----------------------------------------------------------------------===// 561955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 5626948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Make sure the function is at least Align bytes aligned. 563dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Renvoid MachineFrameInfo::ensureMaxAlignment(unsigned Align) { 564de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!StackRealignable) 56537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines assert(Align <= StackAlignment && 56669261a644298bff1497d46c8cd38d688670f307bManman Ren "For targets without stack realignment, Align is out of limit!"); 567dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren if (MaxAlignment < Align) MaxAlignment = Align; 568dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 569dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 5706948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Clamp the alignment if requested and emit a warning. 5718f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilsonstatic inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align, 5728f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson unsigned StackAlign) { 5738f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson if (!ShouldClamp || Align <= StackAlign) 5748f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson return Align; 5758f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson DEBUG(dbgs() << "Warning: requested alignment " << Align 5768f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson << " exceeds the stack alignment " << StackAlign 5778f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson << " when stack realignment is off" << '\n'); 57869261a644298bff1497d46c8cd38d688670f307bManman Ren return StackAlign; 57969261a644298bff1497d46c8cd38d688670f307bManman Ren} 58069261a644298bff1497d46c8cd38d688670f307bManman Ren 5816948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a new statically sized stack object, returning a nonnegative 5826948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// identifier to represent it. 5838f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilsonint MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment, 58436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool isSS, const AllocaInst *Alloca) { 585dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren assert(Size != 0 && "Cannot allocate zero size stack objects!"); 586de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment); 58737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Objects.push_back(StackObject(Size, Alignment, 0, false, isSS, Alloca, 58837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines !isSS)); 589dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren int Index = (int)Objects.size() - NumFixedObjects - 1; 590dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren assert(Index >= 0 && "Bad frame index!"); 591dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren ensureMaxAlignment(Alignment); 592dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren return Index; 593dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 594dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 5956948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a new statically sized stack object that represents a spill slot, 5966948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// returning a nonnegative identifier to represent it. 597dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Renint MachineFrameInfo::CreateSpillStackObject(uint64_t Size, 598dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren unsigned Alignment) { 599de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment); 60036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CreateStackObject(Size, Alignment, true); 601dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren int Index = (int)Objects.size() - NumFixedObjects - 1; 602dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren ensureMaxAlignment(Alignment); 603dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren return Index; 604dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 605dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 6066948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Notify the MachineFrameInfo object that a variable sized object has been 6076948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// created. This must be created whenever a variable sized object is created, 6086948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// whether or not the index returned is actually used. 60936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesint MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment, 61036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const AllocaInst *Alloca) { 611dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren HasVarSizedObjects = true; 612de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment); 61337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true)); 614dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren ensureMaxAlignment(Alignment); 615dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren return (int)Objects.size()-NumFixedObjects-1; 616dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 617dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 6186948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a new object at a fixed location on the stack. 6191612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// All fixed objects should be created before other objects are created for 6201612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// efficiency. By default, fixed objects are immutable. This returns an 6211612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// index with a negative value. 6221612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattnerint MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset, 62337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool Immutable, bool isAliased) { 6241612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner assert(Size != 0 && "Cannot allocate zero size fixed stack objects!"); 625f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // The alignment of the frame index can be determined from its offset from 626f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // the incoming frame position. If the frame object is at offset 32 and 627f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // the stack is guaranteed to be 16-byte aligned, then we know that the 628de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // object is 16-byte aligned. Note that unlike the non-fixed case, if the 629de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // stack needs realignment, we can't assume that the stack will in fact be 630de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // aligned. 631de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned Align = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment); 632de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Align = clampStackAlignment(!StackRealignable, Align, StackAlignment); 633f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, Immutable, 634c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem /*isSS*/ false, 63537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines /*Alloca*/ nullptr, isAliased)); 6361612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner return -++NumFixedObjects; 6371612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner} 6381612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner 6396948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a spill slot at a fixed location on the stack. 6406948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Returns an index with a negative value. 641c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hinesint MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size, 642c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines int64_t SPOffset) { 643de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned Align = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment); 644de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Align = clampStackAlignment(!StackRealignable, Align, StackAlignment); 645c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, 646c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines /*Immutable*/ true, 647c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines /*isSS*/ true, 64837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines /*Alloca*/ nullptr, 64937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines /*isAliased*/ false)); 650c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return -++NumFixedObjects; 651c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines} 6521612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner 6536948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga NainarBitVector MachineFrameInfo::getPristineRegs(const MachineFunction &MF) const { 6546948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo(); 6554a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen BitVector BV(TRI->getNumRegs()); 6564a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 6574a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen // Before CSI is calculated, no registers are considered pristine. They can be 6584a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen // freely used and PEI will make sure they are saved. 6594a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen if (!isCalleeSavedInfoValid()) 6604a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen return BV; 6614a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 6626948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar for (const MCPhysReg *CSR = TRI->getCalleeSavedRegs(&MF); CSR && *CSR; ++CSR) 6634a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen BV.set(*CSR); 6644a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 6656948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // Saved CSRs are not pristine. 666f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (auto &I : getCalleeSavedInfo()) 667f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (MCSubRegIterator S(I.getReg(), TRI, true); S.isValid(); ++S) 668f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar BV.reset(*S); 6694a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 6704a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen return BV; 6714a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen} 6724a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 6730cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkelunsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const { 67437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering(); 67537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo(); 6760cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned MaxAlign = getMaxAlignment(); 6770cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel int Offset = 0; 6780cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6790cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // This code is very, very similar to PEI::calculateFrameObjectOffsets(). 6800cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // It really should be refactored to share code. Until then, changes 6810cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // should keep in mind that there's tight coupling between the two. 6820cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6830cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel for (int i = getObjectIndexBegin(); i != 0; ++i) { 6840cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel int FixedOff = -getObjectOffset(i); 6850cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (FixedOff > Offset) Offset = FixedOff; 6860cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel } 6870cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel for (unsigned i = 0, e = getObjectIndexEnd(); i != e; ++i) { 6880cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (isDeadObjectIndex(i)) 6890cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel continue; 6900cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset += getObjectSize(i); 6910cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned Align = getObjectAlignment(i); 6920cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // Adjust to alignment boundary 6930cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset = (Offset+Align-1)/Align*Align; 6940cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6950cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel MaxAlign = std::max(Align, MaxAlign); 6960cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel } 6970cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6980cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (adjustsStack() && TFI->hasReservedCallFrame(MF)) 6990cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset += getMaxCallFrameSize(); 7000cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 7010cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // Round up the size to a multiple of the alignment. If the function has 7020cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // any calls or alloca's, align to the target's StackAlignment value to 7030cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // ensure that the callee's frame or the alloca data is suitably aligned; 7040cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // otherwise, for leaf functions, align to the TransientStackAlignment 7050cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // value. 7060cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned StackAlign; 7070cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (adjustsStack() || hasVarSizedObjects() || 7080cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel (RegInfo->needsStackRealignment(MF) && getObjectIndexEnd() != 0)) 7090cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel StackAlign = TFI->getStackAlignment(); 7100cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel else 7110cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel StackAlign = TFI->getTransientStackAlignment(); 7120cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 7130cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // If the frame pointer is eliminated, all frame offsets will be relative to 7140cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // SP not FP. Align to MaxAlign so this works. 7150cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel StackAlign = std::max(StackAlign, MaxAlign); 7160cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned AlignMask = StackAlign - 1; 7170cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); 7180cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 7190cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel return (unsigned)Offset; 7200cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel} 7214a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 722d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattnervoid MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{ 7230ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman if (Objects.empty()) return; 7240ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 72537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering(); 72606140888b1fed24910031f23c302c6a3221f3c42Matthijs Kooijman int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0); 7279085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner 7280ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Frame Objects:\n"; 7290ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 730955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner for (unsigned i = 0, e = Objects.size(); i != e; ++i) { 731955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner const StackObject &SO = Objects[i]; 7320ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " fi#" << (int)(i-NumFixedObjects) << ": "; 733d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng if (SO.Size == ~0ULL) { 734d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng OS << "dead\n"; 735d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng continue; 736d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng } 737955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner if (SO.Size == 0) 738955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner OS << "variable sized"; 739955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner else 7400ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "size=" << SO.Size; 7410ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", align=" << SO.Alignment; 74276d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos 743955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner if (i < NumFixedObjects) 7440ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", fixed"; 745955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner if (i < NumFixedObjects || SO.SPOffset != -1) { 746a401b1e1c5eb9563617db8a2477b4c5f8b239521Chris Lattner int64_t Off = SO.SPOffset - ValOffset; 7470ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", at location [SP"; 7489085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner if (Off > 0) 74976d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OS << "+" << Off; 7509085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner else if (Off < 0) 75176d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OS << Off; 752955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner OS << "]"; 753955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner } 754955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner OS << "\n"; 755955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner } 756955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner} 757955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 758b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 7599085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattnervoid MachineFrameInfo::dump(const MachineFunction &MF) const { 760dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greene print(MF, dbgs()); 7619085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner} 76277e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 763955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 764955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner//===----------------------------------------------------------------------===// 76537efe6764568a3829fee26aba532283131d1a104Nate Begeman// MachineJumpTableInfo implementation 76637efe6764568a3829fee26aba532283131d1a104Nate Begeman//===----------------------------------------------------------------------===// 76737efe6764568a3829fee26aba532283131d1a104Nate Begeman 7686948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Return the size of each entry in the jump table. 7693574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmowunsigned MachineJumpTableInfo::getEntrySize(const DataLayout &TD) const { 770071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // The size of a jump table entry is 4 bytes unless the entry is just the 771071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // address of a block, in which case it is the pointer size. 772071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner switch (getEntryKind()) { 773071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_BlockAddress: 774426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth return TD.getPointerSize(); 7756c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka case MachineJumpTableInfo::EK_GPRel64BlockAddress: 7766c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka return 8; 777071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_GPRel32BlockAddress: 778071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_LabelDifference32: 77985fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner case MachineJumpTableInfo::EK_Custom32: 780071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return 4; 78195da605e15a6f108b551ecc6772823ea53de3007Richard Osborne case MachineJumpTableInfo::EK_Inline: 78295da605e15a6f108b551ecc6772823ea53de3007Richard Osborne return 0; 783071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner } 784aae875c27ce59e1c98dbc4a2358a006f2edef433Craig Topper llvm_unreachable("Unknown jump table encoding!"); 785071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 786071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 7876948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Return the alignment of each entry in the jump table. 7883574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmowunsigned MachineJumpTableInfo::getEntryAlignment(const DataLayout &TD) const { 789071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // The alignment of a jump table entry is the alignment of int32 unless the 790071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // entry is just the address of a block, in which case it is the pointer 791071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // alignment. 792071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner switch (getEntryKind()) { 793071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_BlockAddress: 794426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth return TD.getPointerABIAlignment(); 7956c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka case MachineJumpTableInfo::EK_GPRel64BlockAddress: 7966c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka return TD.getABIIntegerTypeAlignment(64); 797071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_GPRel32BlockAddress: 798071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_LabelDifference32: 79985fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner case MachineJumpTableInfo::EK_Custom32: 800071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return TD.getABIIntegerTypeAlignment(32); 80195da605e15a6f108b551ecc6772823ea53de3007Richard Osborne case MachineJumpTableInfo::EK_Inline: 80295da605e15a6f108b551ecc6772823ea53de3007Richard Osborne return 1; 803071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner } 804aae875c27ce59e1c98dbc4a2358a006f2edef433Craig Topper llvm_unreachable("Unknown jump table encoding!"); 805071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 806071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 8076948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a new jump table entry in the jump table info. 808d1ec31dca534a8816d7f2fcbfdc7ed4476b471d3Bob Wilsonunsigned MachineJumpTableInfo::createJumpTableIndex( 809a4eb44a285984ec999de632beb5145b099f5416dChris Lattner const std::vector<MachineBasicBlock*> &DestBBs) { 810e7251a0377334bdb57bd188828bf89c9e3980fadChris Lattner assert(!DestBBs.empty() && "Cannot create an empty jump table!"); 81137efe6764568a3829fee26aba532283131d1a104Nate Begeman JumpTables.push_back(MachineJumpTableEntry(DestBBs)); 81237efe6764568a3829fee26aba532283131d1a104Nate Begeman return JumpTables.size()-1; 81337efe6764568a3829fee26aba532283131d1a104Nate Begeman} 81437efe6764568a3829fee26aba532283131d1a104Nate Begeman 8156948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// If Old is the target of any jump tables, update the jump tables to branch 8166948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// to New instead. 817beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattnerbool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old, 818beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner MachineBasicBlock *New) { 819593ea05957b98472a916278d64229ceda223c50bDan Gohman assert(Old != New && "Not making a change?"); 820593ea05957b98472a916278d64229ceda223c50bDan Gohman bool MadeChange = false; 82168bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach for (size_t i = 0, e = JumpTables.size(); i != e; ++i) 82268bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach ReplaceMBBInJumpTable(i, Old, New); 82368bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach return MadeChange; 82468bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach} 82568bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach 8266948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// If Old is a target of the jump tables, update the jump table to branch to 8276948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// New instead. 828beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattnerbool MachineJumpTableInfo::ReplaceMBBInJumpTable(unsigned Idx, 829beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner MachineBasicBlock *Old, 830beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner MachineBasicBlock *New) { 83168bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach assert(Old != New && "Not making a change?"); 83268bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach bool MadeChange = false; 83368bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach MachineJumpTableEntry &JTE = JumpTables[Idx]; 83468bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j) 83568bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach if (JTE.MBBs[j] == Old) { 83668bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach JTE.MBBs[j] = New; 83768bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach MadeChange = true; 83868bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach } 839593ea05957b98472a916278d64229ceda223c50bDan Gohman return MadeChange; 840593ea05957b98472a916278d64229ceda223c50bDan Gohman} 84137efe6764568a3829fee26aba532283131d1a104Nate Begeman 842d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattnervoid MachineJumpTableInfo::print(raw_ostream &OS) const { 8430ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman if (JumpTables.empty()) return; 8440ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 8450ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Jump Tables:\n"; 8460ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 84737efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) { 8480ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " jt#" << i << ": "; 8490ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j) 8500ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " BB#" << JumpTables[i].MBBs[j]->getNumber(); 85137efe6764568a3829fee26aba532283131d1a104Nate Begeman } 8520ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 8530ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << '\n'; 85437efe6764568a3829fee26aba532283131d1a104Nate Begeman} 85537efe6764568a3829fee26aba532283131d1a104Nate Begeman 856b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 857de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarLLVM_DUMP_METHOD void MachineJumpTableInfo::dump() const { print(dbgs()); } 85877e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 85937efe6764568a3829fee26aba532283131d1a104Nate Begeman 86037efe6764568a3829fee26aba532283131d1a104Nate Begeman 86137efe6764568a3829fee26aba532283131d1a104Nate Begeman//===----------------------------------------------------------------------===// 8624d149cdae1553426f49623fdae215d481d56d955Chris Lattner// MachineConstantPool implementation 8634d149cdae1553426f49623fdae215d481d56d955Chris Lattner//===----------------------------------------------------------------------===// 8644d149cdae1553426f49623fdae215d481d56d955Chris Lattner 8652d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid MachineConstantPoolValue::anchor() { } 8662d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 867db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerType *MachineConstantPoolEntry::getType() const { 8689abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng if (isMachineConstantPoolEntry()) 869cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner return Val.MachineCPVal->getType(); 8709abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng return Val.ConstVal->getType(); 8719abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng} 8729abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng 873f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarbool MachineConstantPoolEntry::needsRelocation() const { 874cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner if (isMachineConstantPoolEntry()) 875f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return true; 876f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Val.ConstVal->needsRelocation(); 877cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner} 878cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner 87937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen HinesSectionKind 88037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen HinesMachineConstantPoolEntry::getSectionKind(const DataLayout *DL) const { 881f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (needsRelocation()) 882f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return SectionKind::getReadOnlyWithRel(); 883f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar switch (DL->getTypeAllocSize(getType())) { 884f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case 4: 885f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return SectionKind::getMergeableConst4(); 886f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case 8: 887f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return SectionKind::getMergeableConst8(); 888f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case 16: 889f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return SectionKind::getMergeableConst16(); 890de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case 32: 891de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return SectionKind::getMergeableConst32(); 89237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines default: 893f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return SectionKind::getReadOnly(); 89437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 89537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 89637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 897d6594ae54cfde4db4d30272192645c0a45fb9902Evan ChengMachineConstantPool::~MachineConstantPool() { 898d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng for (unsigned i = 0, e = Constants.size(); i != e; ++i) 899d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng if (Constants[i].isMachineConstantPoolEntry()) 900d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng delete Constants[i].Val.MachineCPVal; 9015567869637383969dced0b84dbd19da12682df6bCameron Zwarich for (DenseSet<MachineConstantPoolValue*>::iterator I = 9025567869637383969dced0b84dbd19da12682df6bCameron Zwarich MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end(); 9035567869637383969dced0b84dbd19da12682df6bCameron Zwarich I != E; ++I) 9045567869637383969dced0b84dbd19da12682df6bCameron Zwarich delete *I; 905d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 906d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 9076948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Test whether the given two constants can be allocated the same constant pool 9086948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// entry. 90946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanstatic bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, 910f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const DataLayout &DL) { 91183f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // Handle the trivial case quickly. 91283f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if (A == B) return true; 91383f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 91483f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // If they have the same type but weren't the same constant, quickly 91583f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // reject them. 91683f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if (A->getType() == B->getType()) return false; 91783f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 91873858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // We can't handle structs or arrays. 91973858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) || 92073858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner isa<StructType>(B->getType()) || isa<ArrayType>(B->getType())) 92173858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner return false; 922c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 92383f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // For now, only support constants with the same size. 924f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar uint64_t StoreSize = DL.getTypeStoreSize(A->getType()); 925f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128) 92683f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman return false; 92783f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 92873858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8); 92973858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner 93073858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // Try constant folding a bitcast of both instructions to an integer. If we 93173858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // get two identical ConstantInt's, then we are good to share them. We use 93273858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // the constant folding APIs to do this so that we get the benefit of 9333574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow // DataLayout. 93473858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner if (isa<PointerType>(A->getType())) 935de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar A = ConstantFoldCastOperand(Instruction::PtrToInt, 936de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const_cast<Constant *>(A), IntTy, DL); 93773858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner else if (A->getType() != IntTy) 938de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar A = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(A), 939de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar IntTy, DL); 94073858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner if (isa<PointerType>(B->getType())) 941de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar B = ConstantFoldCastOperand(Instruction::PtrToInt, 942de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const_cast<Constant *>(B), IntTy, DL); 94373858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner else if (B->getType() != IntTy) 944de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar B = ConstantFoldCastOperand(Instruction::BitCast, const_cast<Constant *>(B), 945de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar IntTy, DL); 9460c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 94773858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner return A == B; 94883f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman} 94983f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 9506948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// Create a new entry in the constant pool or return an existing one. 9516948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar/// User must specify the log2 of the minimum required alignment for the object. 952c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hinesunsigned MachineConstantPool::getConstantPoolIndex(const Constant *C, 9533029f920519e0871a5aad5d7c592281093953733Chris Lattner unsigned Alignment) { 9543029f920519e0871a5aad5d7c592281093953733Chris Lattner assert(Alignment && "Alignment must be specified!"); 9553029f920519e0871a5aad5d7c592281093953733Chris Lattner if (Alignment > PoolAlignment) PoolAlignment = Alignment; 95683f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 9573029f920519e0871a5aad5d7c592281093953733Chris Lattner // Check to see if we already have this constant. 9583029f920519e0871a5aad5d7c592281093953733Chris Lattner // 9593029f920519e0871a5aad5d7c592281093953733Chris Lattner // FIXME, this could be made much more efficient for large constant pools. 9603029f920519e0871a5aad5d7c592281093953733Chris Lattner for (unsigned i = 0, e = Constants.size(); i != e; ++i) 96183f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if (!Constants[i].isMachineConstantPoolEntry() && 962f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, DL)) { 96383f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if ((unsigned)Constants[i].getAlignment() < Alignment) 96483f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman Constants[i].Alignment = Alignment; 9653029f920519e0871a5aad5d7c592281093953733Chris Lattner return i; 96683f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman } 9670c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 9681606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Constants.push_back(MachineConstantPoolEntry(C, Alignment)); 9693029f920519e0871a5aad5d7c592281093953733Chris Lattner return Constants.size()-1; 9703029f920519e0871a5aad5d7c592281093953733Chris Lattner} 9713029f920519e0871a5aad5d7c592281093953733Chris Lattner 972d6594ae54cfde4db4d30272192645c0a45fb9902Evan Chengunsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, 973d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng unsigned Alignment) { 974d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert(Alignment && "Alignment must be specified!"); 975d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng if (Alignment > PoolAlignment) PoolAlignment = Alignment; 9760c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 977d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // Check to see if we already have this constant. 978d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // 979d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // FIXME, this could be made much more efficient for large constant pools. 980d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng int Idx = V->getExistingMachineCPValue(this, Alignment); 9815567869637383969dced0b84dbd19da12682df6bCameron Zwarich if (Idx != -1) { 9825567869637383969dced0b84dbd19da12682df6bCameron Zwarich MachineCPVsSharingEntries.insert(V); 983d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return (unsigned)Idx; 9845567869637383969dced0b84dbd19da12682df6bCameron Zwarich } 9851606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 9861606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Constants.push_back(MachineConstantPoolEntry(V, Alignment)); 987d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return Constants.size()-1; 988d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 989d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 99062ca32540f950d500227f1863b95cd08ad28099eChris Lattnervoid MachineConstantPool::print(raw_ostream &OS) const { 9910ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman if (Constants.empty()) return; 9920ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 9930ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Constant Pool:\n"; 994b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 9950ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " cp#" << i << ": "; 996d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng if (Constants[i].isMachineConstantPoolEntry()) 997d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Constants[i].Val.MachineCPVal->print(OS); 998d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng else 99936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constants[i].Val.ConstVal->printAsOperand(OS, /*PrintType=*/false); 10000ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", align=" << Constants[i].getAlignment(); 1001b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng OS << "\n"; 1002b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng } 10034d149cdae1553426f49623fdae215d481d56d955Chris Lattner} 10044d149cdae1553426f49623fdae215d481d56d955Chris Lattner 1005b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 1006de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarLLVM_DUMP_METHOD void MachineConstantPool::dump() const { print(dbgs()); } 100777e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 1008