X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineFunction.h;h=46d14e148462e9cfc78fccd51316fefe1fe0089d;hb=1612faae3cf7ecfaddba64f7064f0ce4b32dd471;hp=94e9470b76792c175a73f6fcfaa8d22cf1509055;hpb=d6b210ca3808a0e0ab9e1e2aefb73d61462fff0a;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineFunction.h b/include/llvm/CodeGen/MachineFunction.h index 94e9470b767..46d14e14846 100644 --- a/include/llvm/CodeGen/MachineFunction.h +++ b/include/llvm/CodeGen/MachineFunction.h @@ -1,18 +1,18 @@ //===-- llvm/CodeGen/MachineFunction.h --------------------------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// -// +// // Collect native machine code for a function. This class contains a list of // MachineBasicBlock instances that make up the current compiled function. // // This class also contains pointers to various classes which hold // target-specific information about the generated code. -// +// //===----------------------------------------------------------------------===// #ifndef LLVM_CODEGEN_MACHINEFUNCTION_H @@ -25,9 +25,10 @@ namespace llvm { class Function; class TargetMachine; -class SSARegMap; +class MachineRegisterInfo; class MachineFrameInfo; class MachineConstantPool; +class MachineJumpTableInfo; // ilist_traits template <> @@ -35,19 +36,19 @@ struct ilist_traits { // this is only set by the MachineFunction owning the ilist friend class MachineFunction; MachineFunction* Parent; - + public: ilist_traits() : Parent(0) { } - + static MachineBasicBlock* getPrev(MachineBasicBlock* N) { return N->Prev; } static MachineBasicBlock* getNext(MachineBasicBlock* N) { return N->Next; } - + static const MachineBasicBlock* getPrev(const MachineBasicBlock* N) { return N->Prev; } - + static const MachineBasicBlock* getNext(const MachineBasicBlock* N) { return N->Next; } - + static void setPrev(MachineBasicBlock* N, MachineBasicBlock* prev) { N->Prev = prev; } @@ -55,13 +56,14 @@ public: N->Next = next; } - static MachineBasicBlock* createNode(); + static MachineBasicBlock* createSentinel(); + static void destroySentinel(MachineBasicBlock *MBB) { delete MBB; } void addNodeToList(MachineBasicBlock* N); void removeNodeFromList(MachineBasicBlock* N); void transferNodesFromList(iplist > &toList, - ilist_iterator first, - ilist_iterator last); + ilist_iterator first, + ilist_iterator last); }; /// MachineFunctionInfo - This class can be derived from and used by targets to @@ -69,7 +71,7 @@ public: /// of type are accessed/created with MF::getInfo and destroyed when the /// MachineFunction is destroyed. struct MachineFunctionInfo { - virtual ~MachineFunctionInfo() {}; + virtual ~MachineFunctionInfo() {} }; class MachineFunction : private Annotation { @@ -79,8 +81,8 @@ class MachineFunction : private Annotation { // List of machine basic blocks in function ilist BasicBlocks; - // Keeping track of mapping from SSA values to registers - SSARegMap *SSARegMapping; + // RegInfo - Information about each register in use in the function. + MachineRegisterInfo *RegInfo; // Used to keep track of target-specific per-machine function information for // the target implementation. @@ -91,19 +93,15 @@ class MachineFunction : private Annotation { // Keep track of constants which are spilled to memory MachineConstantPool *ConstantPool; + + // Keep track of jump tables for switch instructions + MachineJumpTableInfo *JumpTableInfo; // Function-level unique numbering for MachineBasicBlocks. When a // MachineBasicBlock is inserted into a MachineFunction is it automatically // numbered and this vector keeps track of the mapping from ID's to MBB's. std::vector MBBNumbering; - /// UsedPhysRegs - This is a new[]'d array of bools that is computed and set - /// by the register allocator, and must be kept up to date by passes that run - /// after register allocation (though most don't modify this). This is used - /// so that the code generator knows which callee save registers to save and - /// for other target specific uses. - bool *UsedPhysRegs; - public: MachineFunction(const Function *Fn, const TargetMachine &TM); ~MachineFunction(); @@ -116,11 +114,9 @@ public: /// const TargetMachine &getTarget() const { return Target; } - /// SSARegMap Interface... Keep track of information about each SSA virtual - /// register, such as which register class it belongs to. + /// getRegInfo - Return information about the registers currently in use. /// - SSARegMap *getSSARegMap() const { return SSARegMapping; } - void clearSSARegMap(); + MachineRegisterInfo &getRegInfo() const { return *RegInfo; } /// getFrameInfo - Return the frame info object for the current function. /// This object contains information about objects allocated on the stack @@ -128,13 +124,19 @@ public: /// MachineFrameInfo *getFrameInfo() const { return FrameInfo; } + /// getJumpTableInfo - Return the jump table info object for the current + /// function. This object contains information about jump tables for switch + /// instructions in the current function. + /// + MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; } + /// getConstantPool - Return the constant pool object for the current /// function. /// MachineConstantPool *getConstantPool() const { return ConstantPool; } /// MachineFunctionInfo - Keep track of various per-function pieces of - /// information for the sparc backend. + /// information for backends that would like to do so. /// template Ty *getInfo() { @@ -145,24 +147,10 @@ public: return static_cast(MFInfo); } - /// setUsedPhysRegs - The register allocator should call this to initialized - /// the UsedPhysRegs set. This should be passed a new[]'d array with entries - /// for all of the physical registers that the target supports. Each array - /// entry should be set to true iff the physical register is used within the - /// function. - void setUsedPhysRegs(bool *UPR) { UsedPhysRegs = UPR; } - - /// getUsedPhysregs - This returns the UsedPhysRegs array. This returns null - /// before register allocation. - const bool *getUsedPhysregs() { return UsedPhysRegs; } - - /// isPhysRegUsed - Return true if the specified register is used in this - /// function. This only works after register allocation. - bool isPhysRegUsed(unsigned Reg) { return UsedPhysRegs[Reg]; } - - /// changePhyRegUsed - This method allows code that runs after register - /// allocation to keep the PhysRegsUsed array up-to-date. - void changePhyRegUsed(unsigned Reg, bool State) { UsedPhysRegs[Reg] = State; } + template + const Ty *getInfo() const { + return const_cast(this)->getInfo(); + } /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they /// are inserted into the machine function. The block number for a machine @@ -175,18 +163,22 @@ public: return MBBNumbering[N]; } - /// getLastBlock - Returns the MachineBasicBlock with the greatest number - MachineBasicBlock *getLastBlock() { - return MBBNumbering.back(); - } - const MachineBasicBlock *getLastBlock() const { - return MBBNumbering.back(); - } - + /// getNumBlockIDs - Return the number of MBB ID's allocated. + /// + unsigned getNumBlockIDs() const { return MBBNumbering.size(); } + + /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and + /// recomputes them. This guarantees that the MBB numbers are sequential, + /// dense, and match the ordering of the blocks within the function. If a + /// specific MachineBasicBlock is specified, only that block and those after + /// it are renumbered. + void RenumberBlocks(MachineBasicBlock *MBBFrom = 0); + /// print - Print out the MachineFunction in a format suitable for debugging /// to the specified stream. /// void print(std::ostream &OS) const; + void print(std::ostream *OS) const { if (OS) print(*OS); } /// viewCFG - This function is meant for use from the debugger. You can just /// say 'call F->viewCFG()' and a ghostview window should pop up from the @@ -195,7 +187,7 @@ public: /// in your path. /// void viewCFG() const; - + /// viewCFGOnly - This function is meant for use from the debugger. It works /// just like viewCFG, but it does not include the contents of basic blocks /// into the nodes, just the label. If you are only interested in the CFG @@ -232,7 +224,7 @@ public: // Provide accessors for basic blocks... const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } BasicBlockListType &getBasicBlockList() { return BasicBlocks; } - + //===--------------------------------------------------------------------===// // BasicBlock iterator forwarding functions // @@ -307,7 +299,7 @@ template <> struct GraphTraits : }; -// Provide specializations of GraphTraits to be able to treat a function as a +// Provide specializations of GraphTraits to be able to treat a function as a // graph of basic blocks... and to walk it in inverse order. Inverse order for // a function is considered to be when traversing the predecessor edges of a BB // instead of the successor edges.