MachineFunction.h revision 29626642271ae810dd526de8afa151484452abe0
1//===-- llvm/CodeGen/MachineFunction.h --------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Collect native machine code for a function. This class contains a list of 11// MachineBasicBlock instances that make up the current compiled function. 12// 13// This class also contains pointers to various classes which hold 14// target-specific information about the generated code. 15// 16//===----------------------------------------------------------------------===// 17 18#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H 19#define LLVM_CODEGEN_MACHINEFUNCTION_H 20 21#include <map> 22#include "llvm/ADT/ilist.h" 23#include "llvm/Support/DebugLoc.h" 24#include "llvm/CodeGen/Dump.h" 25#include "llvm/CodeGen/MachineBasicBlock.h" 26#include "llvm/Support/Allocator.h" 27#include "llvm/Support/Recycler.h" 28 29namespace llvm { 30 31class Function; 32class MachineRegisterInfo; 33class MachineFrameInfo; 34class MachineConstantPool; 35class MachineJumpTableInfo; 36class TargetMachine; 37class TargetRegisterClass; 38 39template <> 40struct ilist_traits<MachineBasicBlock> 41 : public ilist_default_traits<MachineBasicBlock> { 42 mutable ilist_node<MachineBasicBlock> Sentinel; 43public: 44 MachineBasicBlock *createSentinel() const { 45 return static_cast<MachineBasicBlock*>(&Sentinel); 46 } 47 void destroySentinel(MachineBasicBlock *) const {} 48 49 MachineBasicBlock *provideInitialHead() const { return createSentinel(); } 50 MachineBasicBlock *ensureHead(MachineBasicBlock*) const { 51 return createSentinel(); 52 } 53 static void noteHead(MachineBasicBlock*, MachineBasicBlock*) {} 54 55 void addNodeToList(MachineBasicBlock* MBB); 56 void removeNodeFromList(MachineBasicBlock* MBB); 57 void deleteNode(MachineBasicBlock *MBB); 58private: 59 void createNode(const MachineBasicBlock &); 60}; 61 62/// MachineFunctionInfo - This class can be derived from and used by targets to 63/// hold private target-specific information for each MachineFunction. Objects 64/// of type are accessed/created with MF::getInfo and destroyed when the 65/// MachineFunction is destroyed. 66struct MachineFunctionInfo { 67 virtual ~MachineFunctionInfo() {} 68}; 69 70class MachineFunction { 71 Function *Fn; 72 const TargetMachine &Target; 73 74 // RegInfo - Information about each register in use in the function. 75 MachineRegisterInfo *RegInfo; 76 77 // Used to keep track of target-specific per-machine function information for 78 // the target implementation. 79 MachineFunctionInfo *MFInfo; 80 81 // Keep track of objects allocated on the stack. 82 MachineFrameInfo *FrameInfo; 83 84 // Keep track of constants which are spilled to memory 85 MachineConstantPool *ConstantPool; 86 87 // Keep track of jump tables for switch instructions 88 MachineJumpTableInfo *JumpTableInfo; 89 90 // Function-level unique numbering for MachineBasicBlocks. When a 91 // MachineBasicBlock is inserted into a MachineFunction is it automatically 92 // numbered and this vector keeps track of the mapping from ID's to MBB's. 93 std::vector<MachineBasicBlock*> MBBNumbering; 94 95 // Pool-allocate MachineFunction-lifetime and IR objects. 96 BumpPtrAllocator Allocator; 97 98 // Allocation management for instructions in function. 99 Recycler<MachineInstr> InstructionRecycler; 100 101 // Allocation management for basic blocks in function. 102 Recycler<MachineBasicBlock> BasicBlockRecycler; 103 104 // List of machine basic blocks in function 105 typedef ilist<MachineBasicBlock> BasicBlockListType; 106 BasicBlockListType BasicBlocks; 107 108 // Default debug location. Used to print out the debug label at the beginning 109 // of a function. 110 DebugLoc DefaultDebugLoc; 111 112 // Tracks debug locations. 113 DebugLocTracker DebugLocInfo; 114 115 // The alignment of the function. 116 unsigned Alignment; 117 118public: 119 MachineFunction(Function *Fn, const TargetMachine &TM); 120 ~MachineFunction(); 121 122 /// getFunction - Return the LLVM function that this machine code represents 123 /// 124 Function *getFunction() const { return Fn; } 125 126 /// getTarget - Return the target machine this machine code is compiled with 127 /// 128 const TargetMachine &getTarget() const { return Target; } 129 130 /// getRegInfo - Return information about the registers currently in use. 131 /// 132 MachineRegisterInfo &getRegInfo() { return *RegInfo; } 133 const MachineRegisterInfo &getRegInfo() const { return *RegInfo; } 134 135 /// getFrameInfo - Return the frame info object for the current function. 136 /// This object contains information about objects allocated on the stack 137 /// frame of the current function in an abstract way. 138 /// 139 MachineFrameInfo *getFrameInfo() { return FrameInfo; } 140 const MachineFrameInfo *getFrameInfo() const { return FrameInfo; } 141 142 /// getJumpTableInfo - Return the jump table info object for the current 143 /// function. This object contains information about jump tables for switch 144 /// instructions in the current function. 145 /// 146 MachineJumpTableInfo *getJumpTableInfo() { return JumpTableInfo; } 147 const MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; } 148 149 /// getConstantPool - Return the constant pool object for the current 150 /// function. 151 /// 152 MachineConstantPool *getConstantPool() { return ConstantPool; } 153 const MachineConstantPool *getConstantPool() const { return ConstantPool; } 154 155 /// getAlignment - Return the alignment (log2, not bytes) of the function. 156 /// 157 unsigned getAlignment() const { return Alignment; } 158 159 /// setAlignment - Set the alignment (log2, not bytes) of the function. 160 /// 161 void setAlignment(unsigned A) { Alignment = A; } 162 163 /// MachineFunctionInfo - Keep track of various per-function pieces of 164 /// information for backends that would like to do so. 165 /// 166 template<typename Ty> 167 Ty *getInfo() { 168 if (!MFInfo) { 169 // This should be just `new (Allocator.Allocate<Ty>()) Ty(*this)', but 170 // that apparently breaks GCC 3.3. 171 Ty *Loc = static_cast<Ty*>(Allocator.Allocate(sizeof(Ty), 172 AlignOf<Ty>::Alignment)); 173 MFInfo = new (Loc) Ty(*this); 174 } 175 176 assert((void*)dynamic_cast<Ty*>(MFInfo) == (void*)MFInfo && 177 "Invalid concrete type or multiple inheritence for getInfo"); 178 return static_cast<Ty*>(MFInfo); 179 } 180 181 template<typename Ty> 182 const Ty *getInfo() const { 183 return const_cast<MachineFunction*>(this)->getInfo<Ty>(); 184 } 185 186 /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they 187 /// are inserted into the machine function. The block number for a machine 188 /// basic block can be found by using the MBB::getBlockNumber method, this 189 /// method provides the inverse mapping. 190 /// 191 MachineBasicBlock *getBlockNumbered(unsigned N) const { 192 assert(N < MBBNumbering.size() && "Illegal block number"); 193 assert(MBBNumbering[N] && "Block was removed from the machine function!"); 194 return MBBNumbering[N]; 195 } 196 197 /// getNumBlockIDs - Return the number of MBB ID's allocated. 198 /// 199 unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); } 200 201 /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and 202 /// recomputes them. This guarantees that the MBB numbers are sequential, 203 /// dense, and match the ordering of the blocks within the function. If a 204 /// specific MachineBasicBlock is specified, only that block and those after 205 /// it are renumbered. 206 void RenumberBlocks(MachineBasicBlock *MBBFrom = 0); 207 208 /// print - Print out the MachineFunction in a format suitable for debugging 209 /// to the specified stream. 210 /// 211 void print(std::ostream &OS, 212 const PrefixPrinter &prefix = PrefixPrinter()) const; 213 void print(std::ostream *OS, 214 const PrefixPrinter &prefix = PrefixPrinter()) const { 215 if (OS) print(*OS, prefix); 216 } 217 218 /// viewCFG - This function is meant for use from the debugger. You can just 219 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 220 /// program, displaying the CFG of the current function with the code for each 221 /// basic block inside. This depends on there being a 'dot' and 'gv' program 222 /// in your path. 223 /// 224 void viewCFG() const; 225 226 /// viewCFGOnly - This function is meant for use from the debugger. It works 227 /// just like viewCFG, but it does not include the contents of basic blocks 228 /// into the nodes, just the label. If you are only interested in the CFG 229 /// this can make the graph smaller. 230 /// 231 void viewCFGOnly() const; 232 233 /// dump - Print the current MachineFunction to cerr, useful for debugger use. 234 /// 235 void dump() const; 236 237 // Provide accessors for the MachineBasicBlock list... 238 typedef BasicBlockListType::iterator iterator; 239 typedef BasicBlockListType::const_iterator const_iterator; 240 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 241 typedef std::reverse_iterator<iterator> reverse_iterator; 242 243 /// addLiveIn - Add the specified physical register as a live-in value and 244 /// create a corresponding virtual register for it. 245 unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC); 246 247 //===--------------------------------------------------------------------===// 248 // BasicBlock accessor functions. 249 // 250 iterator begin() { return BasicBlocks.begin(); } 251 const_iterator begin() const { return BasicBlocks.begin(); } 252 iterator end () { return BasicBlocks.end(); } 253 const_iterator end () const { return BasicBlocks.end(); } 254 255 reverse_iterator rbegin() { return BasicBlocks.rbegin(); } 256 const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); } 257 reverse_iterator rend () { return BasicBlocks.rend(); } 258 const_reverse_iterator rend () const { return BasicBlocks.rend(); } 259 260 unsigned size() const { return (unsigned)BasicBlocks.size();} 261 bool empty() const { return BasicBlocks.empty(); } 262 const MachineBasicBlock &front() const { return BasicBlocks.front(); } 263 MachineBasicBlock &front() { return BasicBlocks.front(); } 264 const MachineBasicBlock & back() const { return BasicBlocks.back(); } 265 MachineBasicBlock & back() { return BasicBlocks.back(); } 266 267 void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (MBB); } 268 void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(MBB); } 269 void insert(iterator MBBI, MachineBasicBlock *MBB) { 270 BasicBlocks.insert(MBBI, MBB); 271 } 272 void splice(iterator InsertPt, iterator MBBI) { 273 BasicBlocks.splice(InsertPt, BasicBlocks, MBBI); 274 } 275 276 void remove(iterator MBBI) { 277 BasicBlocks.remove(MBBI); 278 } 279 void erase(iterator MBBI) { 280 BasicBlocks.erase(MBBI); 281 } 282 283 //===--------------------------------------------------------------------===// 284 // Internal functions used to automatically number MachineBasicBlocks 285 // 286 287 /// getNextMBBNumber - Returns the next unique number to be assigned 288 /// to a MachineBasicBlock in this MachineFunction. 289 /// 290 unsigned addToMBBNumbering(MachineBasicBlock *MBB) { 291 MBBNumbering.push_back(MBB); 292 return (unsigned)MBBNumbering.size()-1; 293 } 294 295 /// removeFromMBBNumbering - Remove the specific machine basic block from our 296 /// tracker, this is only really to be used by the MachineBasicBlock 297 /// implementation. 298 void removeFromMBBNumbering(unsigned N) { 299 assert(N < MBBNumbering.size() && "Illegal basic block #"); 300 MBBNumbering[N] = 0; 301 } 302 303 /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead 304 /// of `new MachineInstr'. 305 /// 306 MachineInstr *CreateMachineInstr(const TargetInstrDesc &TID, 307 DebugLoc DL, 308 bool NoImp = false); 309 310 /// CloneMachineInstr - Create a new MachineInstr which is a copy of the 311 /// 'Orig' instruction, identical in all ways except the the instruction 312 /// has no parent, prev, or next. 313 /// 314 MachineInstr *CloneMachineInstr(const MachineInstr *Orig); 315 316 /// DeleteMachineInstr - Delete the given MachineInstr. 317 /// 318 void DeleteMachineInstr(MachineInstr *MI); 319 320 /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this 321 /// instead of `new MachineBasicBlock'. 322 /// 323 MachineBasicBlock *CreateMachineBasicBlock(const BasicBlock *bb = 0); 324 325 /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock. 326 /// 327 void DeleteMachineBasicBlock(MachineBasicBlock *MBB); 328 329 //===--------------------------------------------------------------------===// 330 // Debug location. 331 // 332 333 /// getOrCreateDebugLocID - Look up the DebugLocTuple index with the given 334 /// source file, line, and column. If none currently exists, create a new 335 /// DebugLocTuple, and insert it into the DebugIdMap. 336 unsigned getOrCreateDebugLocID(GlobalVariable *CompileUnit, 337 unsigned Line, unsigned Col); 338 339 /// getDebugLocTuple - Get the DebugLocTuple for a given DebugLoc object. 340 DebugLocTuple getDebugLocTuple(DebugLoc DL) const; 341 342 /// getDefaultDebugLoc - Get the default debug location for the machine 343 /// function. 344 DebugLoc getDefaultDebugLoc() const { return DefaultDebugLoc; } 345 346 /// setDefaultDebugLoc - Get the default debug location for the machine 347 /// function. 348 void setDefaultDebugLoc(DebugLoc DL) { DefaultDebugLoc = DL; } 349 350 /// getDebugLocInfo - Get the debug info location tracker. 351 DebugLocTracker &getDebugLocInfo() { return DebugLocInfo; } 352}; 353 354//===--------------------------------------------------------------------===// 355// GraphTraits specializations for function basic block graphs (CFGs) 356//===--------------------------------------------------------------------===// 357 358// Provide specializations of GraphTraits to be able to treat a 359// machine function as a graph of machine basic blocks... these are 360// the same as the machine basic block iterators, except that the root 361// node is implicitly the first node of the function. 362// 363template <> struct GraphTraits<MachineFunction*> : 364 public GraphTraits<MachineBasicBlock*> { 365 static NodeType *getEntryNode(MachineFunction *F) { 366 return &F->front(); 367 } 368 369 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph 370 typedef MachineFunction::iterator nodes_iterator; 371 static nodes_iterator nodes_begin(MachineFunction *F) { return F->begin(); } 372 static nodes_iterator nodes_end (MachineFunction *F) { return F->end(); } 373}; 374template <> struct GraphTraits<const MachineFunction*> : 375 public GraphTraits<const MachineBasicBlock*> { 376 static NodeType *getEntryNode(const MachineFunction *F) { 377 return &F->front(); 378 } 379 380 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph 381 typedef MachineFunction::const_iterator nodes_iterator; 382 static nodes_iterator nodes_begin(const MachineFunction *F) { 383 return F->begin(); 384 } 385 static nodes_iterator nodes_end (const MachineFunction *F) { 386 return F->end(); 387 } 388}; 389 390 391// Provide specializations of GraphTraits to be able to treat a function as a 392// graph of basic blocks... and to walk it in inverse order. Inverse order for 393// a function is considered to be when traversing the predecessor edges of a BB 394// instead of the successor edges. 395// 396template <> struct GraphTraits<Inverse<MachineFunction*> > : 397 public GraphTraits<Inverse<MachineBasicBlock*> > { 398 static NodeType *getEntryNode(Inverse<MachineFunction*> G) { 399 return &G.Graph->front(); 400 } 401}; 402template <> struct GraphTraits<Inverse<const MachineFunction*> > : 403 public GraphTraits<Inverse<const MachineBasicBlock*> > { 404 static NodeType *getEntryNode(Inverse<const MachineFunction *> G) { 405 return &G.Graph->front(); 406 } 407}; 408 409} // End llvm namespace 410 411#endif 412