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" 20e5682816b7151b17331b0368c2c7bf19f6e3d661Dan Gohman#include "llvm/Assembly/Writer.h" 2184bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 22eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 23d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/MachineFunctionPass.h" 2484bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineInstr.h" 2537efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 26820e55e9ad3cb3b17780e84863648e431b571d25Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 2784bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 2816c45e9de896ea37d48d093dbe02fc9a4c1b9f8fChris Lattner#include "llvm/CodeGen/Passes.h" 29d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/DebugInfo.h" 300b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 310b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 32beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner#include "llvm/MC/MCAsmInfo.h" 33beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner#include "llvm/MC/MCContext.h" 34dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greene#include "llvm/Support/Debug.h" 35f28bbda2c6c965dbd28e73e06c9e09231a77b0dcChris Lattner#include "llvm/Support/GraphWriter.h" 36944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattner#include "llvm/Support/raw_ostream.h" 37d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetFrameLowering.h" 38d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetLowering.h" 39d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetMachine.h" 4007f32d48f1e16bcdc621985549548a5849215238Chris Lattnerusing namespace llvm; 41f2868ce228ca20f72d1c6fbe241de01975cfe609Chris Lattner 42b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner//===----------------------------------------------------------------------===// 43227c3d355b017393963a690f9f27d1de7fa359bcChris Lattner// MachineFunction implementation 44b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner//===----------------------------------------------------------------------===// 459d5d7598db72c00a0fb89dc77198e4f6ebc5294dChris Lattner 46a70e2e3d4831b8a39ea6bae5c62df29fa82a86f3Chris Lattner// Out of line virtual method. 47a70e2e3d4831b8a39ea6bae5c62df29fa82a86f3Chris LattnerMachineFunctionInfo::~MachineFunctionInfo() {} 48a70e2e3d4831b8a39ea6bae5c62df29fa82a86f3Chris Lattner 49fed90b6d097d50881afb45e4d79f430db66dd741Dan Gohmanvoid ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) { 508e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MBB->getParent()->DeleteMachineBasicBlock(MBB); 51792699c46ef9bfc47dd459bbfa7e71bcb2cee29aTanya Lattner} 52227c3d355b017393963a690f9f27d1de7fa359bcChris Lattner 53ae541aad5c36cb3e4256514447d1f81e253079c7Dan GohmanMachineFunction::MachineFunction(const Function *F, const TargetMachine &TM, 547a5a3f75eb6751c35682f506887c34bf57d6ea3eNicolas Geoffray unsigned FunctionNum, MachineModuleInfo &mmi, 557a5a3f75eb6751c35682f506887c34bf57d6ea3eNicolas Geoffray GCModuleInfo* gmi) 567a5a3f75eb6751c35682f506887c34bf57d6ea3eNicolas Geoffray : Fn(F), Target(TM), Ctx(mmi.getContext()), MMI(mmi), GMI(gmi) { 57e2b997b7b5360b4793c524a801e988fd37b80b93Matthijs Kooijman if (TM.getRegisterInfo()) 58d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling RegInfo = new (Allocator) MachineRegisterInfo(TM); 59e2b997b7b5360b4793c524a801e988fd37b80b93Matthijs Kooijman else 60e2b997b7b5360b4793c524a801e988fd37b80b93Matthijs Kooijman RegInfo = 0; 61d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 62ad8281607f066c2cce5c3625009d8ee0761dbf35Chris Lattner MFInfo = 0; 6361fc8d670f1e991804c2ab753e567981e60962cbBill Wendling FrameInfo = 6461fc8d670f1e991804c2ab753e567981e60962cbBill Wendling new (Allocator) MachineFrameInfo(TM,!F->hasFnAttribute("no-realign-stack")); 65d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 66831737d329a727f53a1fb0572f7b7a8127208881Bill Wendling if (Fn->getAttributes().hasAttribute(AttributeSet::FunctionIndex, 67831737d329a727f53a1fb0572f7b7a8127208881Bill Wendling Attribute::StackAlignment)) 68ef99fe8efaa6cb74c66e570a6ef467debca92911Bill Wendling FrameInfo->ensureMaxAlignment(Fn->getAttributes(). 69831737d329a727f53a1fb0572f7b7a8127208881Bill Wendling getStackAlignment(AttributeSet::FunctionIndex)); 70d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 71d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling ConstantPool = new (Allocator) MachineConstantPool(TM); 72fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman Alignment = TM.getTargetLowering()->getMinFunctionAlignment(); 73d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 74fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman // FIXME: Shouldn't use pref alignment if explicit alignment is set on Fn. 75831737d329a727f53a1fb0572f7b7a8127208881Bill Wendling if (!Fn->getAttributes().hasAttribute(AttributeSet::FunctionIndex, 76831737d329a727f53a1fb0572f7b7a8127208881Bill Wendling Attribute::OptimizeForSize)) 77fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman Alignment = std::max(Alignment, 78fc5d305597ea6336d75bd7f3b741e8d57d6a5105Eli Friedman TM.getTargetLowering()->getPrefFunctionAlignment()); 79d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 80b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner FunctionNumber = FunctionNum; 81071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner JumpTableInfo = 0; 82831fdcf0177a4eef66129cd6fb4138922c492bf0Chris Lattner} 83831fdcf0177a4eef66129cd6fb4138922c492bf0Chris Lattner 8476d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis EvlogimenosMachineFunction::~MachineFunction() { 8584be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // Don't call destructors on MachineInstr and MachineOperand. All of their 8684be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // memory comes from the BumpPtrAllocator which is about to be purged. 8784be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // 8884be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // Do call MachineBasicBlock destructors, it contains std::vectors. 8984be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen for (iterator I = begin(), E = end(); I != E; I = BasicBlocks.erase(I)) 9084be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen I->Insts.clearAndLeakNodesUnsafely(); 9184be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen 928e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman InstructionRecycler.clear(Allocator); 93f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen OperandRecycler.clear(Allocator); 948e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman BasicBlockRecycler.clear(Allocator); 95dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling if (RegInfo) { 96dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling RegInfo->~MachineRegisterInfo(); 97dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling Allocator.Deallocate(RegInfo); 98dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling } 998e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman if (MFInfo) { 100dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling MFInfo->~MachineFunctionInfo(); 101dd37b360d7ecc95b4a077bb64cca22b764788751Bill Wendling Allocator.Deallocate(MFInfo); 1028e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman } 1030c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 1040c1eac8129f7e4e637074a482a085448e1680199Chad Rosier FrameInfo->~MachineFrameInfo(); 1050c1eac8129f7e4e637074a482a085448e1680199Chad Rosier Allocator.Deallocate(FrameInfo); 1060c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 1070c1eac8129f7e4e637074a482a085448e1680199Chad Rosier ConstantPool->~MachineConstantPool(); 1080c1eac8129f7e4e637074a482a085448e1680199Chad Rosier Allocator.Deallocate(ConstantPool); 1090c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 110071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (JumpTableInfo) { 111071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner JumpTableInfo->~MachineJumpTableInfo(); 112071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner Allocator.Deallocate(JumpTableInfo); 113071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner } 1141049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner} 1151049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner 116071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it 117071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// does already exist, allocate one. 118071c62fad0b25ad4131e7f984173a796c1e63f61Chris LattnerMachineJumpTableInfo *MachineFunction:: 119071c62fad0b25ad4131e7f984173a796c1e63f61Chris LattnergetOrCreateJumpTableInfo(unsigned EntryKind) { 120071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (JumpTableInfo) return JumpTableInfo; 1210c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 1229553188fccbf0ae9c5b6bef26d0d2bd5feff8b59Dan Gohman JumpTableInfo = new (Allocator) 123071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind); 124071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return JumpTableInfo; 125071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 126e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 127e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and 128e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner/// recomputes them. This guarantees that the MBB numbers are sequential, 129e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner/// dense, and match the ordering of the blocks within the function. If a 130e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner/// specific MachineBasicBlock is specified, only that block and those after 131e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner/// it are renumbered. 132e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattnervoid MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { 133e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (empty()) { MBBNumbering.clear(); return; } 134e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MachineFunction::iterator MBBI, E = end(); 135e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBB == 0) 136e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBI = begin(); 137e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner else 138e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBI = MBB; 1390c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 140e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // Figure out the block number this should have. 141e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner unsigned BlockNo = 0; 142f28bbda2c6c965dbd28e73e06c9e09231a77b0dcChris Lattner if (MBBI != begin()) 143f28bbda2c6c965dbd28e73e06c9e09231a77b0dcChris Lattner BlockNo = prior(MBBI)->getNumber()+1; 1440c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 145e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner for (; MBBI != E; ++MBBI, ++BlockNo) { 146e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBBI->getNumber() != (int)BlockNo) { 147e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // Remove use of the old number. 148e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBBI->getNumber() != -1) { 149e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner assert(MBBNumbering[MBBI->getNumber()] == &*MBBI && 150e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner "MBB number mismatch!"); 151e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBNumbering[MBBI->getNumber()] = 0; 152e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner } 1530c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 154e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // If BlockNo is already taken, set that block's number to -1. 155e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner if (MBBNumbering[BlockNo]) 156e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBNumbering[BlockNo]->setNumber(-1); 157e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 158e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBNumbering[BlockNo] = MBBI; 159e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBI->setNumber(BlockNo); 160e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner } 1610c1eac8129f7e4e637074a482a085448e1680199Chad Rosier } 162e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 163e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // Okay, all the blocks are renumbered. If we have compactified the block 164e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner // numbering, shrink MBBNumbering now. 165e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner assert(BlockNo <= MBBNumbering.size() && "Mismatch!"); 166e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner MBBNumbering.resize(BlockNo); 167e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner} 168e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 1698e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// CreateMachineInstr - Allocate a new MachineInstr. Use this instead 1708e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// of `new MachineInstr'. 1718e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// 1728e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineInstr * 173e837dead3c8dc3445ef6a0e2322179c57e264a13Evan ChengMachineFunction::CreateMachineInstr(const MCInstrDesc &MCID, 1749bc96a57206cbebaa9b0ba9979f949eb10c1592cBill Wendling DebugLoc DL, bool NoImp) { 1758e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) 1769500e5d07ac9b94c8fed74150e444778a0dcb036Jakob Stoklund Olesen MachineInstr(*this, MCID, DL, NoImp); 1778e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 1788e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 1798e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// CloneMachineInstr - Create a new MachineInstr which is a copy of the 180f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman/// 'Orig' instruction, identical in all ways except the instruction 1818e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// has no parent, prev, or next. 1828e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// 1838e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineInstr * 1848e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::CloneMachineInstr(const MachineInstr *Orig) { 1858e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman return new (InstructionRecycler.Allocate<MachineInstr>(Allocator)) 1868e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MachineInstr(*this, *Orig); 1878e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 1888e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 1898e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// DeleteMachineInstr - Delete the given MachineInstr. 1908e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// 19184be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen/// This function also serves as the MachineInstr destructor - the real 19284be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen/// ~MachineInstr() destructor must be empty. 1938e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohmanvoid 1948e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::DeleteMachineInstr(MachineInstr *MI) { 195f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen // Strip it for parts. The operand array and the MI object itself are 196f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen // independently recyclable. 197f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen if (MI->Operands) 198f1d015f3429f611c423f943c75f86e6823810dc3Jakob Stoklund Olesen deallocateOperandArray(MI->CapOperands, MI->Operands); 19984be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // Don't call ~MachineInstr() which must be trivial anyway because 20084be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // ~MachineFunction drops whole lists of MachineInstrs wihout calling their 20184be3d5a73313eb19f2f9e0512153cd2e6f46c54Jakob Stoklund Olesen // destructors. 2028e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman InstructionRecycler.Deallocate(Allocator, MI); 2038e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 2048e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 2058e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this 2068e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// instead of `new MachineBasicBlock'. 2078e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// 2088e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineBasicBlock * 2098e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::CreateMachineBasicBlock(const BasicBlock *bb) { 2108e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman return new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator)) 2118e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MachineBasicBlock(*this, bb); 2128e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 213e70cab0ca4d7835c8e1e0ee6a125be8f2790a136Chris Lattner 2148e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// DeleteMachineBasicBlock - Delete the given MachineBasicBlock. 2158e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman/// 2168e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohmanvoid 2178e5f2c6f65841542e2a7092553fe42a00048e4c7Dan GohmanMachineFunction::DeleteMachineBasicBlock(MachineBasicBlock *MBB) { 2188e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman assert(MBB->getParent() == this && "MBB parent mismatch!"); 2198e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman MBB->~MachineBasicBlock(); 2208e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman BasicBlockRecycler.Deallocate(Allocator, MBB); 2218e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 2228e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman 223c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineMemOperand * 224da39c3964423744b4d79aebef8bece3e9141d5fcChris LattnerMachineFunction::getMachineMemOperand(MachinePointerInfo PtrInfo, unsigned f, 225f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman uint64_t s, unsigned base_alignment, 22695d594cac3737ae1594a391276942a443cac426bRafael Espindola const MDNode *TBAAInfo, 22795d594cac3737ae1594a391276942a443cac426bRafael Espindola const MDNode *Ranges) { 228f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman return new (Allocator) MachineMemOperand(PtrInfo, f, s, base_alignment, 22995d594cac3737ae1594a391276942a443cac426bRafael Espindola TBAAInfo, Ranges); 230c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 231c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 232c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineMemOperand * 233c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineFunction::getMachineMemOperand(const MachineMemOperand *MMO, 234c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman int64_t Offset, uint64_t Size) { 2359553188fccbf0ae9c5b6bef26d0d2bd5feff8b59Dan Gohman return new (Allocator) 236da39c3964423744b4d79aebef8bece3e9141d5fcChris Lattner MachineMemOperand(MachinePointerInfo(MMO->getValue(), 237da39c3964423744b4d79aebef8bece3e9141d5fcChris Lattner MMO->getOffset()+Offset), 238f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman MMO->getFlags(), Size, 239f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman MMO->getBaseAlignment(), 0); 240c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 241c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 242c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineInstr::mmo_iterator 243c76909abfec876c6b751d693ebd3df07df686aa0Dan GohmanMachineFunction::allocateMemRefsArray(unsigned long Num) { 244c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman return Allocator.Allocate<MachineMemOperand *>(Num); 245c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman} 246c76909abfec876c6b751d693ebd3df07df686aa0Dan Gohman 24791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohmanstd::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator> 24891e69c37153eb7d8cd149d9c2484c3115027b90fDan GohmanMachineFunction::extractLoadMemRefs(MachineInstr::mmo_iterator Begin, 24991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator End) { 25091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Count the number of load mem refs. 25191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Num = 0; 25291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) 25391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isLoad()) 25491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Num; 25591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 25691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Allocate a new array and populate it with the load information. 25791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num); 25891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Index = 0; 25991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) { 26091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isLoad()) { 26191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if (!(*I)->isStore()) 26291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Reuse the MMO. 26391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = *I; 26491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman else { 26591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Clone the MMO and unset the store flag. 26691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineMemOperand *JustLoad = 26793a95ae8a9d8eb19dc0d90281473be2fb1c05a17Chris Lattner getMachineMemOperand((*I)->getPointerInfo(), 26891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman (*I)->getFlags() & ~MachineMemOperand::MOStore, 269f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman (*I)->getSize(), (*I)->getBaseAlignment(), 270f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman (*I)->getTBAAInfo()); 27191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = JustLoad; 27291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 27391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Index; 27491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 27591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 27691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman return std::make_pair(Result, Result + Num); 27791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman} 27891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 27991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohmanstd::pair<MachineInstr::mmo_iterator, MachineInstr::mmo_iterator> 28091e69c37153eb7d8cd149d9c2484c3115027b90fDan GohmanMachineFunction::extractStoreMemRefs(MachineInstr::mmo_iterator Begin, 28191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator End) { 28291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Count the number of load mem refs. 28391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Num = 0; 28491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) 28591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isStore()) 28691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Num; 28791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 28891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Allocate a new array and populate it with the store information. 28991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineInstr::mmo_iterator Result = allocateMemRefsArray(Num); 29091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman unsigned Index = 0; 29191e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman for (MachineInstr::mmo_iterator I = Begin; I != End; ++I) { 29291e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if ((*I)->isStore()) { 29391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman if (!(*I)->isLoad()) 29491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Reuse the MMO. 29591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = *I; 29691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman else { 29791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman // Clone the MMO and unset the load flag. 29891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman MachineMemOperand *JustStore = 29993a95ae8a9d8eb19dc0d90281473be2fb1c05a17Chris Lattner getMachineMemOperand((*I)->getPointerInfo(), 30091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman (*I)->getFlags() & ~MachineMemOperand::MOLoad, 301f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman (*I)->getSize(), (*I)->getBaseAlignment(), 302f96e4bd2a3b11928af75fb7472288930d16fec0bDan Gohman (*I)->getTBAAInfo()); 30391e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman Result[Index] = JustStore; 30491e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 30591e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman ++Index; 30691e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 30791e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman } 30891e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman return std::make_pair(Result, Result + Num); 30991e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman} 31091e69c37153eb7d8cd149d9c2484c3115027b90fDan Gohman 311b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 3128e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohmanvoid MachineFunction::dump() const { 313dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greene print(dbgs()); 3148e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman} 31577e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 3161049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner 31796601ca332ab388754ca4673be8973396fea2dddCraig TopperStringRef MachineFunction::getName() const { 31896601ca332ab388754ca4673be8973396fea2dddCraig Topper assert(getFunction() && "No function!"); 31996601ca332ab388754ca4673be8973396fea2dddCraig Topper return getFunction()->getName(); 32096601ca332ab388754ca4673be8973396fea2dddCraig Topper} 32196601ca332ab388754ca4673be8973396fea2dddCraig Topper 322f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesenvoid MachineFunction::print(raw_ostream &OS, SlotIndexes *Indexes) const { 323986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie OS << "# Machine code for function " << getName() << ": "; 3241f141684cfe382b47db55b6ef1fb4fd62886b3c6Jakob Stoklund Olesen if (RegInfo) { 3251f141684cfe382b47db55b6ef1fb4fd62886b3c6Jakob Stoklund Olesen OS << (RegInfo->isSSA() ? "SSA" : "Post SSA"); 3261f141684cfe382b47db55b6ef1fb4fd62886b3c6Jakob Stoklund Olesen if (!RegInfo->tracksLiveness()) 3271f141684cfe382b47db55b6ef1fb4fd62886b3c6Jakob Stoklund Olesen OS << ", not tracking liveness"; 3281f141684cfe382b47db55b6ef1fb4fd62886b3c6Jakob Stoklund Olesen } 3291f141684cfe382b47db55b6ef1fb4fd62886b3c6Jakob Stoklund Olesen OS << '\n'; 330955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 331955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner // Print Frame Information 3328e5f2c6f65841542e2a7092553fe42a00048e4c7Dan Gohman FrameInfo->print(*this, OS); 3330c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 33437efe6764568a3829fee26aba532283131d1a104Nate Begeman // Print JumpTable Information 335071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner if (JumpTableInfo) 336071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner JumpTableInfo->print(OS); 3374d149cdae1553426f49623fdae215d481d56d955Chris Lattner 3384d149cdae1553426f49623fdae215d481d56d955Chris Lattner // Print Constant Pool 339d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattner ConstantPool->print(OS); 3400c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 3416f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *TRI = getTarget().getRegisterInfo(); 3420c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 343e2b997b7b5360b4793c524a801e988fd37b80b93Matthijs Kooijman if (RegInfo && !RegInfo->livein_empty()) { 3440ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Function Live Ins: "; 34584bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner for (MachineRegisterInfo::livein_iterator 34684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) { 347e2f669fb3fa7a6bee4196999b119a98f31c072a3Jakob Stoklund Olesen OS << PrintReg(I->first, TRI); 3484e92027837136233db0fc1c1a4fa2bc456d74de3Chris Lattner if (I->second) 349e2f669fb3fa7a6bee4196999b119a98f31c072a3Jakob Stoklund Olesen OS << " in " << PrintReg(I->second, TRI); 3507896c9f436a4eda5ec15e882a7505ba482a2fcd0Chris Lattner if (llvm::next(I) != E) 3510ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", "; 352a1f68ca94e763945f9accc75768a55a84bae6cfbChris Lattner } 353d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattner OS << '\n'; 354a1f68ca94e763945f9accc75768a55a84bae6cfbChris Lattner } 3550c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 3560ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman for (const_iterator BB = begin(), E = end(); BB != E; ++BB) { 3570ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << '\n'; 358f4a1e1a69f0727762a73ef0d551e3bbd16b7c04eJakob Stoklund Olesen BB->print(OS, Indexes); 3590ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman } 36047b716483ef2d057c8a0015af20685755e606d0dBrian Gaeke 361986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie OS << "\n# End machine code for function " << getName() << ".\n\n"; 3621049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner} 3631049164aa6b06d91d9b3b557a9a213eaf3f6319aChris Lattner 36471bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenosnamespace llvm { 36576d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos template<> 36676d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos struct DOTGraphTraits<const MachineFunction*> : public DefaultDOTGraphTraits { 367a10d598602308549d87d2c5d9848f5a72fda2b43Tobias Grosser 368a10d598602308549d87d2c5d9848f5a72fda2b43Tobias Grosser DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {} 369a10d598602308549d87d2c5d9848f5a72fda2b43Tobias Grosser 37076d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos static std::string getGraphName(const MachineFunction *F) { 37196601ca332ab388754ca4673be8973396fea2dddCraig Topper return "CFG for '" + F->getName().str() + "' function"; 37276d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 37371bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 37456f4ef3232850e29c4635d0923910acce8887bd0Tobias Grosser std::string getNodeLabel(const MachineBasicBlock *Node, 37556f4ef3232850e29c4635d0923910acce8887bd0Tobias Grosser const MachineFunction *Graph) { 376cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner std::string OutStr; 377cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner { 378cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner raw_string_ostream OSS(OutStr); 379e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen 380e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen if (isSimple()) { 381e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen OSS << "BB#" << Node->getNumber(); 382e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen if (const BasicBlock *BB = Node->getBasicBlock()) 383e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen OSS << ": " << BB->getName(); 384e5f4e9fb2be8525a8ca16bd4719665ed7402b55bJakob Stoklund Olesen } else 385cf143a4d917699f8f4202f331fa9e184070471fbChris Lattner Node->print(OSS); 38676d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 38771bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 38876d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); 38971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 39076d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos // Process string output to make it nicer... 39176d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos for (unsigned i = 0; i != OutStr.length(); ++i) 39276d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos if (OutStr[i] == '\n') { // Left justify 39376d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OutStr[i] = '\\'; 39476d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OutStr.insert(OutStr.begin()+i+1, 'l'); 39576d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 39676d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos return OutStr; 39776d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos } 39876d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos }; 39971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos} 40071bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 40171bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenosvoid MachineFunction::viewCFG() const 40271bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos{ 403851a22db2bdbcab1768a87c4f02b5972e48db5edJim Laskey#ifndef NDEBUG 404986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie ViewGraph(this, "mf" + getName()); 4059d5b532de9bdca37810a59a93a69128441b02c55Reid Spencer#else 406643fffe429cc467584c795f6177741944729e0a5Dan Gohman errs() << "MachineFunction::viewCFG is only available in debug builds on " 40743ed267db3512823a9698f810be4e64bee227270Daniel Dunbar << "systems with Graphviz or gv!\n"; 4089d5b532de9bdca37810a59a93a69128441b02c55Reid Spencer#endif // NDEBUG 40971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos} 41071bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 41171bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenosvoid MachineFunction::viewCFGOnly() const 41271bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos{ 4138cbc94afb71fd2da72d8f1284f7f53e39019fdecOwen Anderson#ifndef NDEBUG 414986d76d7b3844b9a2f3d01a48975952749267a93David Blaikie ViewGraph(this, "mf" + getName(), true); 4158cbc94afb71fd2da72d8f1284f7f53e39019fdecOwen Anderson#else 416643fffe429cc467584c795f6177741944729e0a5Dan Gohman errs() << "MachineFunction::viewCFGOnly is only available in debug builds on " 41743ed267db3512823a9698f810be4e64bee227270Daniel Dunbar << "systems with Graphviz or gv!\n"; 4188cbc94afb71fd2da72d8f1284f7f53e39019fdecOwen Anderson#endif // NDEBUG 41971bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos} 42071bf404e9b69122c276ad7ce66f38bf1e57cafebAlkis Evlogimenos 421998e125a87d49f28c714d8223a37746850401057Bob Wilson/// addLiveIn - Add the specified physical register as a live-in value and 422998e125a87d49f28c714d8223a37746850401057Bob Wilson/// create a corresponding virtual register for it. 423998e125a87d49f28c714d8223a37746850401057Bob Wilsonunsigned MachineFunction::addLiveIn(unsigned PReg, 42468e6beeccc0b9ac2e8d3687a8a5b7d4b172edca1Devang Patel const TargetRegisterClass *RC) { 4253946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng MachineRegisterInfo &MRI = getRegInfo(); 4263946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng unsigned VReg = MRI.getLiveInVirtReg(PReg); 4273946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng if (VReg) { 4283946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng assert(MRI.getRegClass(VReg) == RC && "Register class mismatch!"); 4293946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng return VReg; 4303946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng } 4313946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng VReg = MRI.createVirtualRegister(RC); 4323946043a80a043b3cf43b34bf068feaadc46485bEvan Cheng MRI.addLiveIn(PReg, VReg); 433998e125a87d49f28c714d8223a37746850401057Bob Wilson return VReg; 434998e125a87d49f28c714d8223a37746850401057Bob Wilson} 435998e125a87d49f28c714d8223a37746850401057Bob Wilson 436589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner/// getJTISymbol - Return the MCSymbol for the specified non-empty jump table. 43707d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a 43807d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling/// normal 'L' label is returned. 43907d317711781d8c9268f7d6afcf1ba7eadf1d127Bill WendlingMCSymbol *MachineFunction::getJTISymbol(unsigned JTI, MCContext &Ctx, 44007d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling bool isLinkerPrivate) const { 441589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner assert(JumpTableInfo && "No jump tables"); 442de4c08008a10aba59171c56086d96c760990a4cbChandler Carruth assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!"); 443589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner const MCAsmInfo &MAI = *getTarget().getMCAsmInfo(); 4440c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 44507d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling const char *Prefix = isLinkerPrivate ? MAI.getLinkerPrivateGlobalPrefix() : 44607d317711781d8c9268f7d6afcf1ba7eadf1d127Bill Wendling MAI.getPrivateGlobalPrefix(); 447589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner SmallString<60> Name; 448589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner raw_svector_ostream(Name) 449589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner << Prefix << "JTI" << getFunctionNumber() << '_' << JTI; 4509b97a73dedf736e14b04a3d1a153f10d25b2507bChris Lattner return Ctx.GetOrCreateSymbol(Name.str()); 451589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner} 452589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner 453142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner/// getPICBaseSymbol - Return a function-local symbol to represent the PIC 454142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner/// base. 455142b531e024c7b814df74951b378b9e3e11d0d42Chris LattnerMCSymbol *MachineFunction::getPICBaseSymbol() const { 456142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner const MCAsmInfo &MAI = *Target.getMCAsmInfo(); 457142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner return Ctx.GetOrCreateSymbol(Twine(MAI.getPrivateGlobalPrefix())+ 458142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner Twine(getFunctionNumber())+"$pb"); 459142b531e024c7b814df74951b378b9e3e11d0d42Chris Lattner} 460589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner 461955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner//===----------------------------------------------------------------------===// 462eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner// MachineFrameInfo implementation 463955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner//===----------------------------------------------------------------------===// 464955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 465d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendlingconst TargetFrameLowering *MachineFrameInfo::getFrameLowering() const { 466d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling return TM.getFrameLowering(); 467d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling} 468d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 469dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// ensureMaxAlignment - Make sure the function is at least Align bytes 470dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// aligned. 471dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Renvoid MachineFrameInfo::ensureMaxAlignment(unsigned Align) { 472d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling if (!getFrameLowering()->isStackRealignable() || !RealignOption) 473d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling assert(Align <= getFrameLowering()->getStackAlignment() && 47469261a644298bff1497d46c8cd38d688670f307bManman Ren "For targets without stack realignment, Align is out of limit!"); 475dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren if (MaxAlignment < Align) MaxAlignment = Align; 476dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 477dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 47869261a644298bff1497d46c8cd38d688670f307bManman Ren/// clampStackAlignment - Clamp the alignment if requested and emit a warning. 4798f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilsonstatic inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align, 4808f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson unsigned StackAlign) { 4818f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson if (!ShouldClamp || Align <= StackAlign) 4828f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson return Align; 4838f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson DEBUG(dbgs() << "Warning: requested alignment " << Align 4848f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson << " exceeds the stack alignment " << StackAlign 4858f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson << " when stack realignment is off" << '\n'); 48669261a644298bff1497d46c8cd38d688670f307bManman Ren return StackAlign; 48769261a644298bff1497d46c8cd38d688670f307bManman Ren} 48869261a644298bff1497d46c8cd38d688670f307bManman Ren 4898f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson/// CreateStackObject - Create a new statically sized stack object, returning 4908f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson/// a nonnegative identifier to represent it. 491dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// 4928f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilsonint MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment, 4938f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilson bool isSS, bool MayNeedSP, const AllocaInst *Alloca) { 494dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren assert(Size != 0 && "Cannot allocate zero size stack objects!"); 495d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Alignment = 496d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling clampStackAlignment(!getFrameLowering()->isStackRealignable() || 497d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling !RealignOption, 498d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Alignment, getFrameLowering()->getStackAlignment()); 499dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren Objects.push_back(StackObject(Size, Alignment, 0, false, isSS, MayNeedSP, 500dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren Alloca)); 501dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren int Index = (int)Objects.size() - NumFixedObjects - 1; 502dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren assert(Index >= 0 && "Bad frame index!"); 503dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren ensureMaxAlignment(Alignment); 504dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren return Index; 505dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 506dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 507dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// CreateSpillStackObject - Create a new statically sized stack object that 508dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// represents a spill slot, returning a nonnegative identifier to represent 509dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// it. 510dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// 511dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Renint MachineFrameInfo::CreateSpillStackObject(uint64_t Size, 512dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren unsigned Alignment) { 513d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Alignment = 514d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling clampStackAlignment(!getFrameLowering()->isStackRealignable() || 515d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling !RealignOption, 516d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Alignment, getFrameLowering()->getStackAlignment()); 517dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren CreateStackObject(Size, Alignment, true, false); 518dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren int Index = (int)Objects.size() - NumFixedObjects - 1; 519dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren ensureMaxAlignment(Alignment); 520dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren return Index; 521dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 522dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 523dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// CreateVariableSizedObject - Notify the MachineFrameInfo object that a 524dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// variable sized object has been created. This must be created whenever a 525dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// variable sized object is created, whether or not the index returned is 526dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// actually used. 527dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren/// 5288f637adbd383afc2defb5d3f75433b6f2c25d527Bob Wilsonint MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment) { 529dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren HasVarSizedObjects = true; 530d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Alignment = 531d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling clampStackAlignment(!getFrameLowering()->isStackRealignable() || 532d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling !RealignOption, 533d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Alignment, getFrameLowering()->getStackAlignment()); 534dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren Objects.push_back(StackObject(0, Alignment, 0, false, false, true, 0)); 535dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren ensureMaxAlignment(Alignment); 536dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren return (int)Objects.size()-NumFixedObjects-1; 537dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren} 538dc8126bbb89cda8c87bf324e3495ceb3164ae7cbManman Ren 5391612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// CreateFixedObject - Create a new object at a fixed location on the stack. 5401612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// All fixed objects should be created before other objects are created for 5411612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// efficiency. By default, fixed objects are immutable. This returns an 5421612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// index with a negative value. 5431612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner/// 5441612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattnerint MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset, 545ed2ae136d29dd36122d2476801e7d7a86e8301e3Evan Cheng bool Immutable) { 5461612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner assert(Size != 0 && "Cannot allocate zero size fixed stack objects!"); 547f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // The alignment of the frame index can be determined from its offset from 548f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // the incoming frame position. If the frame object is at offset 32 and 549f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // the stack is guaranteed to be 16-byte aligned, then we know that the 550f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng // object is 16-byte aligned. 551d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling unsigned StackAlign = getFrameLowering()->getStackAlignment(); 552f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng unsigned Align = MinAlign(SPOffset, StackAlign); 553d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Align = 554d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling clampStackAlignment(!getFrameLowering()->isStackRealignable() || 555d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling !RealignOption, 556d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling Align, getFrameLowering()->getStackAlignment()); 557f2f490368797fff899e8025133f10c37e3a2ebe5Evan Cheng Objects.insert(Objects.begin(), StackObject(Size, Align, SPOffset, Immutable, 558c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem /*isSS*/ false, 559c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem /*NeedSP*/ false, 560c05d30601ced172b55be81bb529df6be91d6ae15Nadav Rotem /*Alloca*/ 0)); 5611612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner return -++NumFixedObjects; 5621612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner} 5631612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner 5641612faae3cf7ecfaddba64f7064f0ce4b32dd471Chris Lattner 5654a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund OlesenBitVector 5664a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund OlesenMachineFrameInfo::getPristineRegs(const MachineBasicBlock *MBB) const { 5674a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen assert(MBB && "MBB must be valid"); 5684a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen const MachineFunction *MF = MBB->getParent(); 5694a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen assert(MF && "MBB must be part of a MachineFunction"); 5704a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen const TargetMachine &TM = MF->getTarget(); 5714a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen const TargetRegisterInfo *TRI = TM.getRegisterInfo(); 5724a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen BitVector BV(TRI->getNumRegs()); 5734a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 5744a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen // Before CSI is calculated, no registers are considered pristine. They can be 5754a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen // freely used and PEI will make sure they are saved. 5764a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen if (!isCalleeSavedInfoValid()) 5774a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen return BV; 5784a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 579015f228861ef9b337366f92f637d4e8d624bb006Craig Topper for (const uint16_t *CSR = TRI->getCalleeSavedRegs(MF); CSR && *CSR; ++CSR) 5804a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen BV.set(*CSR); 5814a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 5824a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen // The entry MBB always has all CSRs pristine. 5834a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen if (MBB == &MF->front()) 5844a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen return BV; 5854a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 5864a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen // On other MBBs the saved CSRs are not pristine. 5874a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen const std::vector<CalleeSavedInfo> &CSI = getCalleeSavedInfo(); 5884a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen for (std::vector<CalleeSavedInfo>::const_iterator I = CSI.begin(), 5894a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen E = CSI.end(); I != E; ++I) 5904a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen BV.reset(I->getReg()); 5914a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 5924a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen return BV; 5934a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen} 5944a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 5950cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkelunsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const { 5960cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel const TargetFrameLowering *TFI = MF.getTarget().getFrameLowering(); 5970cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel const TargetRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo(); 5980cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned MaxAlign = getMaxAlignment(); 5990cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel int Offset = 0; 6000cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6010cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // This code is very, very similar to PEI::calculateFrameObjectOffsets(). 6020cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // It really should be refactored to share code. Until then, changes 6030cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // should keep in mind that there's tight coupling between the two. 6040cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6050cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel for (int i = getObjectIndexBegin(); i != 0; ++i) { 6060cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel int FixedOff = -getObjectOffset(i); 6070cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (FixedOff > Offset) Offset = FixedOff; 6080cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel } 6090cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel for (unsigned i = 0, e = getObjectIndexEnd(); i != e; ++i) { 6100cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (isDeadObjectIndex(i)) 6110cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel continue; 6120cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset += getObjectSize(i); 6130cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned Align = getObjectAlignment(i); 6140cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // Adjust to alignment boundary 6150cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset = (Offset+Align-1)/Align*Align; 6160cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6170cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel MaxAlign = std::max(Align, MaxAlign); 6180cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel } 6190cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6200cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (adjustsStack() && TFI->hasReservedCallFrame(MF)) 6210cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset += getMaxCallFrameSize(); 6220cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6230cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // Round up the size to a multiple of the alignment. If the function has 6240cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // any calls or alloca's, align to the target's StackAlignment value to 6250cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // ensure that the callee's frame or the alloca data is suitably aligned; 6260cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // otherwise, for leaf functions, align to the TransientStackAlignment 6270cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // value. 6280cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned StackAlign; 6290cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel if (adjustsStack() || hasVarSizedObjects() || 6300cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel (RegInfo->needsStackRealignment(MF) && getObjectIndexEnd() != 0)) 6310cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel StackAlign = TFI->getStackAlignment(); 6320cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel else 6330cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel StackAlign = TFI->getTransientStackAlignment(); 6340cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6350cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // If the frame pointer is eliminated, all frame offsets will be relative to 6360cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel // SP not FP. Align to MaxAlign so this works. 6370cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel StackAlign = std::max(StackAlign, MaxAlign); 6380cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel unsigned AlignMask = StackAlign - 1; 6390cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); 6400cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel 6410cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel return (unsigned)Offset; 6420cc52c67dbc2e073e3f7f34e05e3e7cd17ba9745Hal Finkel} 6434a0f08c5fc14d840e4e411fade036f1cd815b795Jakob Stoklund Olesen 644d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattnervoid MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{ 6450ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman if (Objects.empty()) return; 6460ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 64716c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov const TargetFrameLowering *FI = MF.getTarget().getFrameLowering(); 64806140888b1fed24910031f23c302c6a3221f3c42Matthijs Kooijman int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0); 6499085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner 6500ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Frame Objects:\n"; 6510ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 652955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner for (unsigned i = 0, e = Objects.size(); i != e; ++i) { 653955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner const StackObject &SO = Objects[i]; 6540ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " fi#" << (int)(i-NumFixedObjects) << ": "; 655d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng if (SO.Size == ~0ULL) { 656d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng OS << "dead\n"; 657d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng continue; 658d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng } 659955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner if (SO.Size == 0) 660955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner OS << "variable sized"; 661955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner else 6620ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "size=" << SO.Size; 6630ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", align=" << SO.Alignment; 66476d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos 665955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner if (i < NumFixedObjects) 6660ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", fixed"; 667955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner if (i < NumFixedObjects || SO.SPOffset != -1) { 668a401b1e1c5eb9563617db8a2477b4c5f8b239521Chris Lattner int64_t Off = SO.SPOffset - ValOffset; 6690ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", at location [SP"; 6709085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner if (Off > 0) 67176d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OS << "+" << Off; 6729085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner else if (Off < 0) 67376d9daccebc589dbf0f9cbb23326c7d50a26f17dAlkis Evlogimenos OS << Off; 674955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner OS << "]"; 675955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner } 676955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner OS << "\n"; 677955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner } 678955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner} 679955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 680b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 6819085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattnervoid MachineFrameInfo::dump(const MachineFunction &MF) const { 682dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greene print(MF, dbgs()); 6839085d8a9a9000eeaa7cf337ccbdca41d528c99c2Chris Lattner} 68477e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 685955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner 686955fad1f99dd174023a1b2e6a1795958147b077dChris Lattner//===----------------------------------------------------------------------===// 68737efe6764568a3829fee26aba532283131d1a104Nate Begeman// MachineJumpTableInfo implementation 68837efe6764568a3829fee26aba532283131d1a104Nate Begeman//===----------------------------------------------------------------------===// 68937efe6764568a3829fee26aba532283131d1a104Nate Begeman 690071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// getEntrySize - Return the size of each entry in the jump table. 6913574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmowunsigned MachineJumpTableInfo::getEntrySize(const DataLayout &TD) const { 692071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // The size of a jump table entry is 4 bytes unless the entry is just the 693071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // address of a block, in which case it is the pointer size. 694071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner switch (getEntryKind()) { 695071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_BlockAddress: 696426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth return TD.getPointerSize(); 6976c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka case MachineJumpTableInfo::EK_GPRel64BlockAddress: 6986c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka return 8; 699071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_GPRel32BlockAddress: 700071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_LabelDifference32: 70185fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner case MachineJumpTableInfo::EK_Custom32: 702071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return 4; 70395da605e15a6f108b551ecc6772823ea53de3007Richard Osborne case MachineJumpTableInfo::EK_Inline: 70495da605e15a6f108b551ecc6772823ea53de3007Richard Osborne return 0; 705071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner } 706aae875c27ce59e1c98dbc4a2358a006f2edef433Craig Topper llvm_unreachable("Unknown jump table encoding!"); 707071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 708071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 709071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner/// getEntryAlignment - Return the alignment of each entry in the jump table. 7103574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmowunsigned MachineJumpTableInfo::getEntryAlignment(const DataLayout &TD) const { 711071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // The alignment of a jump table entry is the alignment of int32 unless the 712071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // entry is just the address of a block, in which case it is the pointer 713071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner // alignment. 714071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner switch (getEntryKind()) { 715071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_BlockAddress: 716426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth return TD.getPointerABIAlignment(); 7176c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka case MachineJumpTableInfo::EK_GPRel64BlockAddress: 7186c2cf8b1fbcf70fd9db6fe44032c1ceaa2299760Akira Hatanaka return TD.getABIIntegerTypeAlignment(64); 719071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_GPRel32BlockAddress: 720071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner case MachineJumpTableInfo::EK_LabelDifference32: 72185fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner case MachineJumpTableInfo::EK_Custom32: 722071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner return TD.getABIIntegerTypeAlignment(32); 72395da605e15a6f108b551ecc6772823ea53de3007Richard Osborne case MachineJumpTableInfo::EK_Inline: 72495da605e15a6f108b551ecc6772823ea53de3007Richard Osborne return 1; 725071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner } 726aae875c27ce59e1c98dbc4a2358a006f2edef433Craig Topper llvm_unreachable("Unknown jump table encoding!"); 727071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner} 728071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 729d1ec31dca534a8816d7f2fcbfdc7ed4476b471d3Bob Wilson/// createJumpTableIndex - Create a new jump table entry in the jump table info. 73037efe6764568a3829fee26aba532283131d1a104Nate Begeman/// 731d1ec31dca534a8816d7f2fcbfdc7ed4476b471d3Bob Wilsonunsigned MachineJumpTableInfo::createJumpTableIndex( 732a4eb44a285984ec999de632beb5145b099f5416dChris Lattner const std::vector<MachineBasicBlock*> &DestBBs) { 733e7251a0377334bdb57bd188828bf89c9e3980fadChris Lattner assert(!DestBBs.empty() && "Cannot create an empty jump table!"); 73437efe6764568a3829fee26aba532283131d1a104Nate Begeman JumpTables.push_back(MachineJumpTableEntry(DestBBs)); 73537efe6764568a3829fee26aba532283131d1a104Nate Begeman return JumpTables.size()-1; 73637efe6764568a3829fee26aba532283131d1a104Nate Begeman} 73737efe6764568a3829fee26aba532283131d1a104Nate Begeman 738593ea05957b98472a916278d64229ceda223c50bDan Gohman/// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update 739593ea05957b98472a916278d64229ceda223c50bDan Gohman/// the jump tables to branch to New instead. 740beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattnerbool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old, 741beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner MachineBasicBlock *New) { 742593ea05957b98472a916278d64229ceda223c50bDan Gohman assert(Old != New && "Not making a change?"); 743593ea05957b98472a916278d64229ceda223c50bDan Gohman bool MadeChange = false; 74468bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach for (size_t i = 0, e = JumpTables.size(); i != e; ++i) 74568bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach ReplaceMBBInJumpTable(i, Old, New); 74668bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach return MadeChange; 74768bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach} 74868bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach 74968bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach/// ReplaceMBBInJumpTable - If Old is a target of the jump tables, update 75068bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach/// the jump table to branch to New instead. 751beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattnerbool MachineJumpTableInfo::ReplaceMBBInJumpTable(unsigned Idx, 752beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner MachineBasicBlock *Old, 753beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner MachineBasicBlock *New) { 75468bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach assert(Old != New && "Not making a change?"); 75568bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach bool MadeChange = false; 75668bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach MachineJumpTableEntry &JTE = JumpTables[Idx]; 75768bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j) 75868bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach if (JTE.MBBs[j] == Old) { 75968bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach JTE.MBBs[j] = New; 76068bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach MadeChange = true; 76168bb60f6a4e0902769f72d1badda4e37cd873ffbJim Grosbach } 762593ea05957b98472a916278d64229ceda223c50bDan Gohman return MadeChange; 763593ea05957b98472a916278d64229ceda223c50bDan Gohman} 76437efe6764568a3829fee26aba532283131d1a104Nate Begeman 765d74c556e9aaad81a188158b7ba12d7ccffb30936Chris Lattnervoid MachineJumpTableInfo::print(raw_ostream &OS) const { 7660ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman if (JumpTables.empty()) return; 7670ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 7680ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Jump Tables:\n"; 7690ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 77037efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) { 7710ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " jt#" << i << ": "; 7720ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j) 7730ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " BB#" << JumpTables[i].MBBs[j]->getNumber(); 77437efe6764568a3829fee26aba532283131d1a104Nate Begeman } 7750ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 7760ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << '\n'; 77737efe6764568a3829fee26aba532283131d1a104Nate Begeman} 77837efe6764568a3829fee26aba532283131d1a104Nate Begeman 779b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 780dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greenevoid MachineJumpTableInfo::dump() const { print(dbgs()); } 78177e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 78237efe6764568a3829fee26aba532283131d1a104Nate Begeman 78337efe6764568a3829fee26aba532283131d1a104Nate Begeman 78437efe6764568a3829fee26aba532283131d1a104Nate Begeman//===----------------------------------------------------------------------===// 7854d149cdae1553426f49623fdae215d481d56d955Chris Lattner// MachineConstantPool implementation 7864d149cdae1553426f49623fdae215d481d56d955Chris Lattner//===----------------------------------------------------------------------===// 7874d149cdae1553426f49623fdae215d481d56d955Chris Lattner 7882d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid MachineConstantPoolValue::anchor() { } 7892d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 790d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendlingconst DataLayout *MachineConstantPool::getDataLayout() const { 791d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling return TM.getDataLayout(); 792d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling} 793d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling 794db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerType *MachineConstantPoolEntry::getType() const { 7959abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng if (isMachineConstantPoolEntry()) 796cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner return Val.MachineCPVal->getType(); 7979abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng return Val.ConstVal->getType(); 7989abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng} 7999abd7c38675ad305c733b7e90578255271afc6bdEvan Cheng 800cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner 801354c0165e755fd857bc89792243b82387ee3936dChris Lattnerunsigned MachineConstantPoolEntry::getRelocationInfo() const { 802cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner if (isMachineConstantPoolEntry()) 803354c0165e755fd857bc89792243b82387ee3936dChris Lattner return Val.MachineCPVal->getRelocationInfo(); 8047cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner return Val.ConstVal->getRelocationInfo(); 805cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner} 806cb4596364369ea36ff5675eb12fc62d0c6f1f0ddChris Lattner 807d6594ae54cfde4db4d30272192645c0a45fb9902Evan ChengMachineConstantPool::~MachineConstantPool() { 808d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng for (unsigned i = 0, e = Constants.size(); i != e; ++i) 809d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng if (Constants[i].isMachineConstantPoolEntry()) 810d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng delete Constants[i].Val.MachineCPVal; 8115567869637383969dced0b84dbd19da12682df6bCameron Zwarich for (DenseSet<MachineConstantPoolValue*>::iterator I = 8125567869637383969dced0b84dbd19da12682df6bCameron Zwarich MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end(); 8135567869637383969dced0b84dbd19da12682df6bCameron Zwarich I != E; ++I) 8145567869637383969dced0b84dbd19da12682df6bCameron Zwarich delete *I; 815d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 816d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 81783f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman/// CanShareConstantPoolEntry - Test whether the given two constants 81883f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman/// can be allocated the same constant pool entry. 81946510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanstatic bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, 8203574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD) { 82183f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // Handle the trivial case quickly. 82283f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if (A == B) return true; 82383f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 82483f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // If they have the same type but weren't the same constant, quickly 82583f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // reject them. 82683f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if (A->getType() == B->getType()) return false; 82783f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 82873858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // We can't handle structs or arrays. 82973858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) || 83073858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner isa<StructType>(B->getType()) || isa<ArrayType>(B->getType())) 83173858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner return false; 83273858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner 83383f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman // For now, only support constants with the same size. 8346b0dc92043ab1f63d78b8796098575e1d777b701Chris Lattner uint64_t StoreSize = TD->getTypeStoreSize(A->getType()); 8356b0dc92043ab1f63d78b8796098575e1d777b701Chris Lattner if (StoreSize != TD->getTypeStoreSize(B->getType()) || 8366b0dc92043ab1f63d78b8796098575e1d777b701Chris Lattner StoreSize > 128) 83783f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman return false; 83883f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 83973858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8); 84073858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner 84173858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // Try constant folding a bitcast of both instructions to an integer. If we 84273858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // get two identical ConstantInt's, then we are good to share them. We use 84373858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner // the constant folding APIs to do this so that we get the benefit of 8443574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow // DataLayout. 84573858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner if (isa<PointerType>(A->getType())) 84673858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner A = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy, 84773858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner const_cast<Constant*>(A), TD); 84873858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner else if (A->getType() != IntTy) 84973858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner A = ConstantFoldInstOperands(Instruction::BitCast, IntTy, 85073858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner const_cast<Constant*>(A), TD); 85173858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner if (isa<PointerType>(B->getType())) 85273858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner B = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy, 85373858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner const_cast<Constant*>(B), TD); 85473858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner else if (B->getType() != IntTy) 85573858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner B = ConstantFoldInstOperands(Instruction::BitCast, IntTy, 85673858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner const_cast<Constant*>(B), TD); 8570c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 85873858d16893e4cddd97f358a19b48bd4bc57ee97Chris Lattner return A == B; 85983f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman} 86083f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 8613029f920519e0871a5aad5d7c592281093953733Chris Lattner/// getConstantPoolIndex - Create a new entry in the constant pool or return 86205ae98346a190d74c2c8799c3af2f8ca23e47c27Dan Gohman/// an existing one. User must specify the log2 of the minimum required 86305ae98346a190d74c2c8799c3af2f8ca23e47c27Dan Gohman/// alignment for the object. 8643029f920519e0871a5aad5d7c592281093953733Chris Lattner/// 86546510a73e977273ec67747eb34cbdb43f815e451Dan Gohmanunsigned MachineConstantPool::getConstantPoolIndex(const Constant *C, 8663029f920519e0871a5aad5d7c592281093953733Chris Lattner unsigned Alignment) { 8673029f920519e0871a5aad5d7c592281093953733Chris Lattner assert(Alignment && "Alignment must be specified!"); 8683029f920519e0871a5aad5d7c592281093953733Chris Lattner if (Alignment > PoolAlignment) PoolAlignment = Alignment; 86983f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman 8703029f920519e0871a5aad5d7c592281093953733Chris Lattner // Check to see if we already have this constant. 8713029f920519e0871a5aad5d7c592281093953733Chris Lattner // 8723029f920519e0871a5aad5d7c592281093953733Chris Lattner // FIXME, this could be made much more efficient for large constant pools. 8733029f920519e0871a5aad5d7c592281093953733Chris Lattner for (unsigned i = 0, e = Constants.size(); i != e; ++i) 87483f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if (!Constants[i].isMachineConstantPoolEntry() && 875d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling CanShareConstantPoolEntry(Constants[i].Val.ConstVal, C, 876d10fa8b1caf010fe4943ae5526c2c3b921339f72Bill Wendling getDataLayout())) { 87783f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman if ((unsigned)Constants[i].getAlignment() < Alignment) 87883f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman Constants[i].Alignment = Alignment; 8793029f920519e0871a5aad5d7c592281093953733Chris Lattner return i; 88083f6120c9a1fe758b2502b060cd7ae9a981ecc39Dan Gohman } 8810c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 8821606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Constants.push_back(MachineConstantPoolEntry(C, Alignment)); 8833029f920519e0871a5aad5d7c592281093953733Chris Lattner return Constants.size()-1; 8843029f920519e0871a5aad5d7c592281093953733Chris Lattner} 8853029f920519e0871a5aad5d7c592281093953733Chris Lattner 886d6594ae54cfde4db4d30272192645c0a45fb9902Evan Chengunsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, 887d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng unsigned Alignment) { 888d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng assert(Alignment && "Alignment must be specified!"); 889d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng if (Alignment > PoolAlignment) PoolAlignment = Alignment; 8900c1eac8129f7e4e637074a482a085448e1680199Chad Rosier 891d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // Check to see if we already have this constant. 892d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // 893d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // FIXME, this could be made much more efficient for large constant pools. 894d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng int Idx = V->getExistingMachineCPValue(this, Alignment); 8955567869637383969dced0b84dbd19da12682df6bCameron Zwarich if (Idx != -1) { 8965567869637383969dced0b84dbd19da12682df6bCameron Zwarich MachineCPVsSharingEntries.insert(V); 897d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return (unsigned)Idx; 8985567869637383969dced0b84dbd19da12682df6bCameron Zwarich } 8991606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 9001606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Constants.push_back(MachineConstantPoolEntry(V, Alignment)); 901d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng return Constants.size()-1; 902d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 903d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 90462ca32540f950d500227f1863b95cd08ad28099eChris Lattnervoid MachineConstantPool::print(raw_ostream &OS) const { 9050ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman if (Constants.empty()) return; 9060ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman 9070ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << "Constant Pool:\n"; 908b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 9090ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << " cp#" << i << ": "; 910d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng if (Constants[i].isMachineConstantPoolEntry()) 911d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng Constants[i].Val.MachineCPVal->print(OS); 912d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng else 913e5682816b7151b17331b0368c2c7bf19f6e3d661Dan Gohman WriteAsOperand(OS, Constants[i].Val.ConstVal, /*PrintType=*/false); 9140ba90f3e34b826b039bdfece1415ef032c4ad3f5Dan Gohman OS << ", align=" << Constants[i].getAlignment(); 915b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng OS << "\n"; 916b8973bd8f50d7321635e1e07b81a880a0828d185Evan Cheng } 9174d149cdae1553426f49623fdae215d481d56d955Chris Lattner} 9184d149cdae1553426f49623fdae215d481d56d955Chris Lattner 919b720be6a50f4e1b3280d2b029ee38dda14577525Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 920dc55481841d5ac060c279a61c944f192ad9bb23eDavid Greenevoid MachineConstantPool::dump() const { print(dbgs()); } 92177e300e8f0b8db8eec448cae9c87d7c5bfad9757Manman Ren#endif 922