Major overhaul of stack frame management.
llvm-svn: 1185
diff --git a/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp b/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp
index 199ed65..d460bb7 100644
--- a/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp
+++ b/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp
@@ -80,6 +80,15 @@
{
opLabel = opLabel + 100; // load/getElem with index vector
}
+ else if (opLabel == Instruction::And ||
+ opLabel == Instruction::Or ||
+ opLabel == Instruction::Xor ||
+ opLabel == Instruction::Not)
+ {
+ // Distinguish bitwise operators from logical operators!
+ if (I->getType() != Type::BoolTy)
+ opLabel = opLabel + 100; // bitwise operator
+ }
else if (opLabel == Instruction::Cast)
{
const Type *ITy = I->getType();
diff --git a/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp b/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
index abbd2f9..fafe023 100644
--- a/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -130,7 +130,7 @@
{
cout << endl
<< "*** Machine instructions after INSTRUCTION SELECTION" << endl;
- method->getMachineCode().dump();
+ MachineCodeForMethod::get(method).dump();
}
return false;
diff --git a/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp b/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
index 88fd4a4..0a6d7d3 100644
--- a/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
+++ b/llvm/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
@@ -337,7 +337,7 @@
if (constantThatMustBeLoaded)
{ // register the value so it is emitted in the assembly
- method->getMachineCode().addToConstantPool(
+ MachineCodeForMethod::get(method).addToConstantPool(
cast<ConstPoolVal>(opValue));
}
}
@@ -372,7 +372,7 @@
if (isa<ConstPoolVal>(oldVal))
{ // register the value so it is emitted in the assembly
- method->getMachineCode().addToConstantPool(
+ MachineCodeForMethod::get(method).addToConstantPool(
cast<ConstPoolVal>(oldVal));
}
}
diff --git a/llvm/lib/CodeGen/MachineInstr.cpp b/llvm/lib/CodeGen/MachineInstr.cpp
index b620fa4..46a8029 100644
--- a/llvm/lib/CodeGen/MachineInstr.cpp
+++ b/llvm/lib/CodeGen/MachineInstr.cpp
@@ -14,10 +14,14 @@
#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/Target/MachineFrameInfo.h"
#include "llvm/Target/MachineRegInfo.h"
#include "llvm/Method.h"
+#include "llvm/iOther.h"
#include "llvm/Instruction.h"
+AnnotationID MachineCodeForMethod::AID(
+ AnnotationManager::getID("MachineCodeForMethodAnnotation"));
//************************ Class Implementations **************************/
@@ -174,43 +178,169 @@
return os;
}
-
-void
-MachineCodeForMethod::putLocalVarAtOffsetFromFP(const Value* local,
- int offset,
- unsigned int size)
+static unsigned int
+ComputeMaxOptionalArgsSize(const TargetMachine& target, const Method* method)
{
- offsetsFromFP[local] = offset;
- incrementAutomaticVarsSize(size);
+ const MachineFrameInfo& frameInfo = target.getFrameInfo();
+
+ unsigned int maxSize = 0;
+
+ for (Method::inst_const_iterator I=method->inst_begin(),E=method->inst_end();
+ I != E; ++I)
+ if ((*I)->getOpcode() == Instruction::Call)
+ {
+ CallInst* callInst = cast<CallInst>(*I);
+ unsigned int numOperands = callInst->getNumOperands() - 1;
+ unsigned int numExtra = numOperands
+ - frameInfo.getNumFixedOutgoingArgs();
+
+ unsigned int sizeForThisCall;
+ if (frameInfo.argsOnStackHaveFixedSize())
+ {
+ int argSize = frameInfo.getSizeOfEachArgOnStack();
+ sizeForThisCall = numExtra * (unsigned) argSize;
+ }
+ else
+ {
+ assert(0 && "UNTESTED CODE: Size per stack argument is not fixed on this architecture: use actual arg sizes to compute MaxOptionalArgsSize");
+ sizeForThisCall = 0;
+ for (unsigned i=0; i < numOperands; ++i)
+ sizeForThisCall += target.findOptimalStorageSize(callInst->
+ getOperand(i)->getType());
+ }
+
+ if (maxSize < sizeForThisCall)
+ maxSize = sizeForThisCall;
+ }
+
+ return maxSize;
}
-void
-MachineCodeForMethod::putLocalVarAtOffsetFromSP(const Value* local,
- int offset,
- unsigned int size)
+/*ctor*/
+MachineCodeForMethod::MachineCodeForMethod(const Method* _M,
+ const TargetMachine& target)
+ : Annotation(AID),
+ method(_M), compiledAsLeaf(false), staticStackSize(0),
+ automaticVarsSize(0), regSpillsSize(0),
+ currentOptionalArgsSize(0), maxOptionalArgsSize(0),
+ currentTmpValuesSize(0)
{
- offsetsFromSP[local] = offset;
- incrementAutomaticVarsSize(size);
+ maxOptionalArgsSize = ComputeMaxOptionalArgsSize(target, method);
+ staticStackSize = maxOptionalArgsSize +
+ target.getFrameInfo().getMinStackFrameSize();
}
-
int
-MachineCodeForMethod::getOffsetFromFP(const Value* local) const
+MachineCodeForMethod::allocateLocalVar(const TargetMachine& target,
+ const Value* val)
{
- hash_map<const Value*, int>::const_iterator pair = offsetsFromFP.find(local);
- assert(pair != offsetsFromFP.end() && "Offset from FP unknown for Value");
- return (*pair).second;
+ // Check if we've allocated a stack slot for this value already
+ //
+ int offset = getOffset(val);
+ if (offset == INVALID_FRAME_OFFSET)
+ {
+ bool growUp;
+ int firstOffset =target.getFrameInfo().getFirstAutomaticVarOffset(*this,
+ growUp);
+ offset = growUp? firstOffset + getAutomaticVarsSize()
+ : firstOffset - getAutomaticVarsSize();
+ offsets[val] = offset;
+
+ unsigned int size = target.findOptimalStorageSize(val->getType());
+ incrementAutomaticVarsSize(size);
+ }
+ return offset;
}
-
int
-MachineCodeForMethod::getOffsetFromSP(const Value* local) const
+MachineCodeForMethod::allocateSpilledValue(const TargetMachine& target,
+ const Type* type)
{
- hash_map<const Value*, int>::const_iterator pair = offsetsFromSP.find(local);
- assert(pair != offsetsFromSP.end() && "Offset from SP unknown for Value");
- return (*pair).second;
+ bool growUp;
+ int firstOffset = target.getFrameInfo().getRegSpillAreaOffset(*this, growUp);
+ int offset = growUp? firstOffset + getRegSpillsSize()
+ : firstOffset - getRegSpillsSize();
+
+ unsigned int size = target.findOptimalStorageSize(type);
+ incrementRegSpillsSize(size);
+
+ return offset;
}
+
+int
+MachineCodeForMethod::allocateOptionalArg(const TargetMachine& target,
+ const Type* type)
+{
+ const MachineFrameInfo& frameInfo = target.getFrameInfo();
+ bool growUp;
+ int firstOffset = frameInfo.getFirstOptionalOutgoingArgOffset(*this, growUp);
+ int offset = growUp? firstOffset + getCurrentOptionalArgsSize()
+ : firstOffset - getCurrentOptionalArgsSize();
+
+ int size = MAXINT;
+ if (frameInfo.argsOnStackHaveFixedSize())
+ size = frameInfo.getSizeOfEachArgOnStack();
+ else
+ {
+ assert(0 && "UNTESTED CODE: Size per stack argument is not fixed on this architecture: use actual argument sizes for computing optional arg offsets");
+ size = target.findOptimalStorageSize(type);
+ }
+
+ incrementCurrentOptionalArgsSize(size);
+
+ return offset;
+}
+
+void
+MachineCodeForMethod::resetOptionalArgs(const TargetMachine& target)
+{
+ currentOptionalArgsSize = 0;
+}
+
+int
+MachineCodeForMethod::pushTempValue(const TargetMachine& target,
+ unsigned int size)
+{
+ bool growUp;
+ int firstTmpOffset = target.getFrameInfo().getTmpAreaOffset(*this, growUp);
+ int offset = growUp? firstTmpOffset + currentTmpValuesSize
+ : firstTmpOffset - currentTmpValuesSize;
+ currentTmpValuesSize += size;
+ return offset;
+}
+
+void
+MachineCodeForMethod::popAllTempValues(const TargetMachine& target)
+{
+ currentTmpValuesSize = 0;
+}
+
+
+// void
+// MachineCodeForMethod::putLocalVarAtOffsetFromSP(const Value* local,
+// int offset,
+// unsigned int size)
+// {
+// offsetsFromSP[local] = offset;
+// incrementAutomaticVarsSize(size);
+// }
+//
+
+int
+MachineCodeForMethod::getOffset(const Value* val) const
+{
+ hash_map<const Value*, int>::const_iterator pair = offsets.find(val);
+ return (pair == offsets.end())? INVALID_FRAME_OFFSET : (*pair).second;
+}
+
+
+// int
+// MachineCodeForMethod::getOffsetFromSP(const Value* local) const
+// {
+// hash_map<const Value*, int>::const_iterator pair = offsetsFromSP.find(local);
+// return (pair == offsetsFromSP.end())? INVALID_FRAME_OFFSET : (*pair).second;
+// }
void