6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-13 10:32:06 +00:00
Code Issues Projects Releases Wiki Activity

* Pull a bunch of frame and constant pool state out into a new

Browse Source 
MachineFunctionInfo class
* Add a new FunctionFrameInfo object


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@5163 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-12-28 20:04:31 +00:00
parent 2a4a095e57
commit cd0d1d1f0f
1 changed files with 30 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
include/llvm/CodeGen/MachineFunction.h
View File

@ -1,8 +1,10 @@
//===-- llvm/CodeGen/MachineFunction.h --------------------------*- C++ -*-===// //===-- llvm/CodeGen/MachineFunction.h --------------------------*- C++ -*-===//
// //
// Collect native machine code information for a method. This allows // Collect native machine code for a function. This class contains a list of
// target-specific information about the generated code to be stored with each // MachineBasicBlock instances that make up the current compiled function.
// method. //
// This class also contains pointers to various classes which hold
// target-specific information about the generated code.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -11,17 +13,14 @@
#include "llvm/CodeGen/MachineBasicBlock.h" #include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/Annotation.h" #include "llvm/Annotation.h"
#include "Support/HashExtras.h"
#include "Support/hash_set"
#include "Support/ilist" #include "Support/ilist"
class Value;
class Function; class Function;
class Constant;
class Type;
class TargetMachine; class TargetMachine;
class Pass; class Pass;
class SSARegMap; class SSARegMap;
class MachineFunctionInfo;
class FunctionFrameInfo;
Pass *createMachineCodeConstructionPass(TargetMachine &Target); Pass *createMachineCodeConstructionPass(TargetMachine &Target);
Pass *createMachineCodeDestructionPass(); Pass *createMachineCodeDestructionPass();
@ -37,19 +36,11 @@ class MachineFunction : private Annotation {
// Keeping track of mapping from SSA values to registers // Keeping track of mapping from SSA values to registers
SSARegMap *SSARegMapping; SSARegMap *SSARegMapping;
// FIXME: State should be held elsewhere... // Used to keep track of frame and constant area information for sparc be
hash_set<const Constant*> constantsForConstPool; MachineFunctionInfo *MFInfo;
hash_map<const Value*, int> offsets;
unsigned staticStackSize; // Keep track of objects allocated on the stack.
unsigned automaticVarsSize; FunctionFrameInfo *FrameInfo;
unsigned regSpillsSize;
unsigned maxOptionalArgsSize;
unsigned maxOptionalNumArgs;
unsigned currentTmpValuesSize;
unsigned maxTmpValuesSize;
bool compiledAsLeaf;
bool spillsAreaFrozen;
bool automaticVarsAreaFrozen;
public: public:
MachineFunction(const Function *Fn, const TargetMachine& target); MachineFunction(const Function *Fn, const TargetMachine& target);
@ -63,6 +54,24 @@ public:
/// ///
const TargetMachine &getTarget() const { return Target; } 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.
///
SSARegMap *getSSARegMap() const { return SSARegMapping; }
void clearSSARegMap();
/// getFrameInfo - Return the frame info object for the current function.
/// This object contains information about objects allocated on the stack
/// frame of the current function in an abstract way.
///
FunctionFrameInfo *getFrameInfo() const { return FrameInfo; }
/// MachineFunctionInfo - Keep track of various per-function pieces of
/// information for the sparc backend.
///
MachineFunctionInfo *getInfo() const { return MFInfo; }
/// print - Print out the MachineFunction in a format suitable for debugging /// print - Print out the MachineFunction in a format suitable for debugging
/// to the specified stream. /// to the specified stream.
/// ///
@ -116,91 +125,6 @@ public:
MachineBasicBlock &front() { return BasicBlocks.front(); } MachineBasicBlock &front() { return BasicBlocks.front(); }
const MachineBasicBlock & back() const { return BasicBlocks.back(); } const MachineBasicBlock & back() const { return BasicBlocks.back(); }
MachineBasicBlock & back() { return BasicBlocks.back(); } MachineBasicBlock & back() { return BasicBlocks.back(); }
//===--------------------------------------------------------------------===//
// SSARegMap Interface... Keep track of information about each SSA virtual
// register, such as which register class it belongs to.
//
SSARegMap *getSSARegMap() const { return SSARegMapping; }
void clearSSARegMap();
//===--------------------------------------------------------------------===//
//
// FIXME: Most of the following state should be moved into another class!
//
/// CalculateArgSize - Call this method to fill in the maxOptionalArgsSize &
/// staticStackSize fields...
///
void CalculateArgSize();
//
// Accessors for global information about generated code for a method.
//
inline bool isCompiledAsLeafMethod() const { return compiledAsLeaf; }
inline unsigned getStaticStackSize() const { return staticStackSize; }
inline unsigned getAutomaticVarsSize() const { return automaticVarsSize; }
inline unsigned getRegSpillsSize() const { return regSpillsSize; }
inline unsigned getMaxOptionalArgsSize() const { return maxOptionalArgsSize;}
inline unsigned getMaxOptionalNumArgs() const { return maxOptionalNumArgs;}
inline const hash_set<const Constant*>&
getConstantPoolValues() const {return constantsForConstPool;}
//
// Modifiers used during code generation
//
void initializeFrameLayout (const TargetMachine& target);
void addToConstantPool (const Constant* constVal)
{ constantsForConstPool.insert(constVal); }
inline void markAsLeafMethod() { compiledAsLeaf = true; }
int computeOffsetforLocalVar (const TargetMachine& target,
const Value* local,
unsigned int& getPaddedSize,
unsigned int sizeToUse = 0);
int allocateLocalVar (const TargetMachine& target,
const Value* local,
unsigned int sizeToUse = 0);
int allocateSpilledValue (const TargetMachine& target,
const Type* type);
int pushTempValue (const TargetMachine& target,
unsigned int size);
void popAllTempValues (const TargetMachine& target);
void freezeSpillsArea () { spillsAreaFrozen = true; }
void freezeAutomaticVarsArea () { automaticVarsAreaFrozen=true; }
int getOffset (const Value* val) const;
private:
inline void incrementAutomaticVarsSize(int incr) {
automaticVarsSize+= incr;
staticStackSize += incr;
}
inline void incrementRegSpillsSize(int incr) {
regSpillsSize+= incr;
staticStackSize += incr;
}
inline void incrementTmpAreaSize(int incr) {
currentTmpValuesSize += incr;
if (maxTmpValuesSize < currentTmpValuesSize)
{
staticStackSize += currentTmpValuesSize - maxTmpValuesSize;
maxTmpValuesSize = currentTmpValuesSize;
}
}
inline void resetTmpAreaSize() {
currentTmpValuesSize = 0;
}
int allocateOptionalArg (const TargetMachine& target,
const Type* type);
}; };
#endif #endif