6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-03 13:31:05 +00:00
Code Issues Projects Releases Wiki Activity

* A bunch of functionality and data was removed from MachineFunction and put

Browse Source 
into a new MachineFunctionInfo class
* Implement new FunctionFrameInfo class


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@5193 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-12-28 20:37:16 +00:00
parent e90fcb739a
commit 955fad1f99
1 changed files with 84 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
lib/CodeGen/MachineFunction.cpp
View File

@ -10,6 +10,8 @@
#include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/SSARegMap.h" #include "llvm/CodeGen/SSARegMap.h"
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/CodeGen/FunctionFrameInfo.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineFrameInfo.h" #include "llvm/Target/MachineFrameInfo.h"
#include "llvm/Target/MachineCacheInfo.h" #include "llvm/Target/MachineCacheInfo.h"
@ -39,7 +41,7 @@ namespace {
} }
bool runOnFunction(Function &F) { bool runOnFunction(Function &F) {
MachineFunction::construct(&F, Target).CalculateArgSize(); MachineFunction::construct(&F, Target).getInfo()->CalculateArgSize();
return false; return false;
} }
}; };
@ -95,25 +97,27 @@ Pass *createMachineFunctionPrinterPass() {
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
MachineFunction::MachineFunction(const Function *F, MachineFunction::MachineFunction(const Function *F,
const TargetMachine& target) const TargetMachine &TM)
: Annotation(MF_AID), Fn(F), Target(target) { : Annotation(MF_AID), Fn(F), Target(TM) {
SSARegMapping = new SSARegMap(); SSARegMapping = new SSARegMap();
MFInfo = new MachineFunctionInfo(*this);
// FIXME: move state into another class FrameInfo = new FunctionFrameInfo();
staticStackSize = automaticVarsSize = regSpillsSize = 0;
maxOptionalArgsSize = maxOptionalNumArgs = currentTmpValuesSize = 0;
maxTmpValuesSize = 0;
compiledAsLeaf = spillsAreaFrozen = automaticVarsAreaFrozen = false;
} }
MachineFunction::~MachineFunction() { MachineFunction::~MachineFunction() {
delete SSARegMapping; delete SSARegMapping;
delete MFInfo;
delete FrameInfo;
} }
void MachineFunction::dump() const { print(std::cerr); } void MachineFunction::dump() const { print(std::cerr); }
void MachineFunction::print(std::ostream &OS) const { void MachineFunction::print(std::ostream &OS) const {
OS << "\n" << *(Value*)Fn->getReturnType() << " \"" << Fn->getName()<< "\"\n"; OS << "\n" << *(Value*)Fn->getFunctionType() << " \"" << Fn->getName()
<< "\"\n";
// Print Frame Information
getFrameInfo()->print(OS);
for (const_iterator BB = begin(); BB != end(); ++BB) { for (const_iterator BB = begin(); BB != end(); ++BB) {
BasicBlock *LBB = BB->getBasicBlock(); BasicBlock *LBB = BB->getBasicBlock();
@ -163,12 +167,48 @@ void MachineFunction::clearSSARegMap() {
SSARegMapping = 0; SSARegMapping = 0;
} }
//===----------------------------------------------------------------------===//
// FunctionFrameInfo implementation
//===----------------------------------------------------------------------===//
void FunctionFrameInfo::print(std::ostream &OS) const {
for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
const StackObject &SO = Objects[i];
OS << " <fi# " << (int)(i-NumFixedObjects) << "> is ";
if (SO.Size == 0)
OS << "variable sized";
else
OS << SO.Size << " byte" << (SO.Size != 1 ? "s" : " ");
if (i < NumFixedObjects)
OS << " fixed";
if (i < NumFixedObjects || SO.SPOffset != -1) {
OS << " at location [SP";
if (SO.SPOffset > 0)
OS << "+" << SO.SPOffset;
else if (SO.SPOffset < 0)
OS << SO.SPOffset;
OS << "]";
}
OS << "\n";
}
if (HasVarSizedObjects)
OS << " Stack frame contains variable sized objects\n";
}
void FunctionFrameInfo::dump() const { print(std::cerr); }
//===----------------------------------------------------------------------===//
// MachineFunctionInfo implementation
//===----------------------------------------------------------------------===//
static unsigned static unsigned
ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F, ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F,
unsigned &maxOptionalNumArgs) unsigned &maxOptionalNumArgs)
{ {
const MachineFrameInfo& frameInfo = target.getFrameInfo(); const TargetFrameInfo &frameInfo = target.getFrameInfo();
unsigned maxSize = 0; unsigned maxSize = 0;
@ -181,7 +221,7 @@ ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F,
if (numExtra <= 0) if (numExtra <= 0)
continue; continue;
unsigned int sizeForThisCall; unsigned sizeForThisCall;
if (frameInfo.argsOnStackHaveFixedSize()) if (frameInfo.argsOnStackHaveFixedSize())
{ {
int argSize = frameInfo.getSizeOfEachArgOnStack(); int argSize = frameInfo.getSizeOfEachArgOnStack();
@ -194,7 +234,7 @@ ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F,
"compute MaxOptionalArgsSize"); "compute MaxOptionalArgsSize");
sizeForThisCall = 0; sizeForThisCall = 0;
for (unsigned i = 0; i < numOperands; ++i) for (unsigned i = 0; i < numOperands; ++i)
sizeForThisCall += target.DataLayout.getTypeSize(callInst-> sizeForThisCall += target.getTargetData().getTypeSize(callInst->
getOperand(i)->getType()); getOperand(i)->getType());
} }
@ -217,52 +257,51 @@ ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F,
// but they are unrelated. This one does not align at more than a // but they are unrelated. This one does not align at more than a
// double-word boundary whereas that one might. // double-word boundary whereas that one might.
// //
inline unsigned int inline unsigned
SizeToAlignment(unsigned int size, const TargetMachine& target) SizeToAlignment(unsigned size, const TargetMachine& target)
{ {
unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1); unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1);
if (size > (unsigned) cacheLineSize / 2) if (size > (unsigned) cacheLineSize / 2)
return cacheLineSize; return cacheLineSize;
else else
for (unsigned sz=1; /*no condition*/; sz *= 2) for (unsigned sz=1; /*no condition*/; sz *= 2)
if (sz >= size || sz >= target.DataLayout.getDoubleAlignment()) if (sz >= size || sz >= target.getTargetData().getDoubleAlignment())
return sz; return sz;
} }
void MachineFunction::CalculateArgSize() { void MachineFunctionInfo::CalculateArgSize() {
maxOptionalArgsSize = ComputeMaxOptionalArgsSize(Target, Fn, maxOptionalArgsSize = ComputeMaxOptionalArgsSize(MF.getTarget(),
MF.getFunction(),
maxOptionalNumArgs); maxOptionalNumArgs);
staticStackSize = maxOptionalArgsSize staticStackSize = maxOptionalArgsSize
+ Target.getFrameInfo().getMinStackFrameSize(); + MF.getTarget().getFrameInfo().getMinStackFrameSize();
} }
int int
MachineFunction::computeOffsetforLocalVar(const TargetMachine& target, MachineFunctionInfo::computeOffsetforLocalVar(const Value* val,
const Value* val, unsigned &getPaddedSize,
unsigned int& getPaddedSize, unsigned sizeToUse)
unsigned int sizeToUse)
{ {
if (sizeToUse == 0) if (sizeToUse == 0)
sizeToUse = target.findOptimalStorageSize(val->getType()); sizeToUse = MF.getTarget().findOptimalStorageSize(val->getType());
unsigned int align = SizeToAlignment(sizeToUse, target); unsigned align = SizeToAlignment(sizeToUse, MF.getTarget());
bool growUp; bool growUp;
int firstOffset = target.getFrameInfo().getFirstAutomaticVarOffset(*this, int firstOffset = MF.getTarget().getFrameInfo().getFirstAutomaticVarOffset(MF,
growUp); growUp);
int offset = growUp? firstOffset + getAutomaticVarsSize() int offset = growUp? firstOffset + getAutomaticVarsSize()
: firstOffset - (getAutomaticVarsSize() + sizeToUse); : firstOffset - (getAutomaticVarsSize() + sizeToUse);
int aligned = target.getFrameInfo().adjustAlignment(offset, growUp, align); int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, align);
getPaddedSize = sizeToUse + abs(aligned - offset); getPaddedSize = sizeToUse + abs(aligned - offset);
return aligned; return aligned;
} }
int int
MachineFunction::allocateLocalVar(const TargetMachine& target, MachineFunctionInfo::allocateLocalVar(const Value* val,
const Value* val, unsigned sizeToUse)
unsigned int sizeToUse)
{ {
assert(! automaticVarsAreaFrozen && assert(! automaticVarsAreaFrozen &&
"Size of auto vars area has been used to compute an offset so " "Size of auto vars area has been used to compute an offset so "
@ -273,8 +312,8 @@ MachineFunction::allocateLocalVar(const TargetMachine& target,
int offset = getOffset(val); int offset = getOffset(val);
if (offset == INVALID_FRAME_OFFSET) if (offset == INVALID_FRAME_OFFSET)
{ {
unsigned int getPaddedSize; unsigned getPaddedSize;
offset = computeOffsetforLocalVar(target, val, getPaddedSize, sizeToUse); offset = computeOffsetforLocalVar(val, getPaddedSize, sizeToUse);
offsets[val] = offset; offsets[val] = offset;
incrementAutomaticVarsSize(getPaddedSize); incrementAutomaticVarsSize(getPaddedSize);
} }
@ -282,23 +321,22 @@ MachineFunction::allocateLocalVar(const TargetMachine& target,
} }
int int
MachineFunction::allocateSpilledValue(const TargetMachine& target, MachineFunctionInfo::allocateSpilledValue(const Type* type)
const Type* type)
{ {
assert(! spillsAreaFrozen && assert(! spillsAreaFrozen &&
"Size of reg spills area has been used to compute an offset so " "Size of reg spills area has been used to compute an offset so "
"no more register spill slots should be allocated!"); "no more register spill slots should be allocated!");
unsigned int size = target.DataLayout.getTypeSize(type); unsigned size = MF.getTarget().getTargetData().getTypeSize(type);
unsigned char align = target.DataLayout.getTypeAlignment(type); unsigned char align = MF.getTarget().getTargetData().getTypeAlignment(type);
bool growUp; bool growUp;
int firstOffset = target.getFrameInfo().getRegSpillAreaOffset(*this, growUp); int firstOffset = MF.getTarget().getFrameInfo().getRegSpillAreaOffset(MF, growUp);
int offset = growUp? firstOffset + getRegSpillsSize() int offset = growUp? firstOffset + getRegSpillsSize()
: firstOffset - (getRegSpillsSize() + size); : firstOffset - (getRegSpillsSize() + size);
int aligned = target.getFrameInfo().adjustAlignment(offset, growUp, align); int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, align);
size += abs(aligned - offset); // include alignment padding in size size += abs(aligned - offset); // include alignment padding in size
incrementRegSpillsSize(size); // update size of reg. spills area incrementRegSpillsSize(size); // update size of reg. spills area
@ -307,18 +345,18 @@ MachineFunction::allocateSpilledValue(const TargetMachine& target,
} }
int int
MachineFunction::pushTempValue(const TargetMachine& target, MachineFunctionInfo::pushTempValue(unsigned size)
unsigned int size)
{ {
unsigned int align = SizeToAlignment(size, target); unsigned align = SizeToAlignment(size, MF.getTarget());
bool growUp; bool growUp;
int firstOffset = target.getFrameInfo().getTmpAreaOffset(*this, growUp); int firstOffset = MF.getTarget().getFrameInfo().getTmpAreaOffset(MF, growUp);
int offset = growUp? firstOffset + currentTmpValuesSize int offset = growUp? firstOffset + currentTmpValuesSize
: firstOffset - (currentTmpValuesSize + size); : firstOffset - (currentTmpValuesSize + size);
int aligned = target.getFrameInfo().adjustAlignment(offset, growUp, align); int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp,
align);
size += abs(aligned - offset); // include alignment padding in size size += abs(aligned - offset); // include alignment padding in size
incrementTmpAreaSize(size); // update "current" size of tmp area incrementTmpAreaSize(size); // update "current" size of tmp area
@ -326,14 +364,12 @@ MachineFunction::pushTempValue(const TargetMachine& target,
return aligned; return aligned;
} }
void void MachineFunctionInfo::popAllTempValues() {
MachineFunction::popAllTempValues(const TargetMachine& target)
{
resetTmpAreaSize(); // clear tmp area to reuse resetTmpAreaSize(); // clear tmp area to reuse
} }
int int
MachineFunction::getOffset(const Value* val) const MachineFunctionInfo::getOffset(const Value* val) const
{ {
hash_map<const Value*, int>::const_iterator pair = offsets.find(val); hash_map<const Value*, int>::const_iterator pair = offsets.find(val);
return (pair == offsets.end()) ? INVALID_FRAME_OFFSET : pair->second; return (pair == offsets.end()) ? INVALID_FRAME_OFFSET : pair->second;