mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-04-04 10:30:01 +00:00
These files now live in lib/Target/SparcV9
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15831 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
parent
85015a0891
commit
5a6074053d
@ -1,97 +0,0 @@
|
||||
//===-- llvm/CodeGen/MachineCodeForInstruction.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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// FIXME: This file is SparcV9 specific. Do not rely on this class for new
|
||||
// targets, it will go away in the future.
|
||||
//
|
||||
// Representation of the sequence of machine instructions created for a single
|
||||
// VM instruction. Additionally records information about hidden and implicit
|
||||
// values used by the machine instructions: about hidden values used by the
|
||||
// machine instructions:
|
||||
//
|
||||
// "Temporary values" are intermediate values used in the machine instruction
|
||||
// sequence, but not in the VM instruction Note that such values should be
|
||||
// treated as pure SSA values with no interpretation of their operands (i.e., as
|
||||
// a TmpInstruction object which actually represents such a value).
|
||||
//
|
||||
// (2) "Implicit uses" are values used in the VM instruction but not in
|
||||
// the machine instruction sequence
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_CODEGEN_MACHINECODE_FOR_INSTRUCTION_H
|
||||
#define LLVM_CODEGEN_MACHINECODE_FOR_INSTRUCTION_H
|
||||
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class MachineInstr;
|
||||
class Instruction;
|
||||
class Value;
|
||||
class CallArgsDescriptor;
|
||||
|
||||
class MachineCodeForInstruction {
|
||||
std::vector<Value*> tempVec; // used by m/c instr but not VM instr
|
||||
std::vector<MachineInstr*> Contents; // the machine instr for this VM instr
|
||||
CallArgsDescriptor* callArgsDesc; // only used for CALL instructions
|
||||
public:
|
||||
MachineCodeForInstruction() : callArgsDesc(NULL) {}
|
||||
~MachineCodeForInstruction();
|
||||
|
||||
static MachineCodeForInstruction &get(const Instruction *I);
|
||||
static void destroy(const Instruction *I);
|
||||
|
||||
// Access to underlying machine instructions...
|
||||
typedef std::vector<MachineInstr*>::iterator iterator;
|
||||
typedef std::vector<MachineInstr*>::const_iterator const_iterator;
|
||||
|
||||
unsigned size() const { return Contents.size(); }
|
||||
bool empty() const { return Contents.empty(); }
|
||||
MachineInstr *front() const { return Contents.front(); }
|
||||
MachineInstr *back() const { return Contents.back(); }
|
||||
MachineInstr *&operator[](unsigned i) { return Contents[i]; }
|
||||
MachineInstr *operator[](unsigned i) const { return Contents[i]; }
|
||||
void pop_back() { Contents.pop_back(); }
|
||||
|
||||
iterator begin() { return Contents.begin(); }
|
||||
iterator end() { return Contents.end(); }
|
||||
const_iterator begin() const { return Contents.begin(); }
|
||||
const_iterator end() const { return Contents.end(); }
|
||||
|
||||
template<class InIt>
|
||||
void insert(iterator where, InIt first, InIt last) {
|
||||
Contents.insert(where, first, last);
|
||||
}
|
||||
iterator erase(iterator where) { return Contents.erase(where); }
|
||||
iterator erase(iterator s, iterator e) { return Contents.erase(s, e); }
|
||||
|
||||
|
||||
// dropAllReferences() - This function drops all references within
|
||||
// temporary (hidden) instructions created in implementing the original
|
||||
// VM intruction. This ensures there are no remaining "uses" within
|
||||
// these hidden instructions, before the values of a method are freed.
|
||||
//
|
||||
void dropAllReferences();
|
||||
|
||||
const std::vector<Value*> &getTempValues() const { return tempVec; }
|
||||
std::vector<Value*> &getTempValues() { return tempVec; }
|
||||
|
||||
MachineCodeForInstruction &addTemp(Value *tmp) {
|
||||
tempVec.push_back(tmp);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void setCallArgsDescriptor(CallArgsDescriptor* desc) { callArgsDesc = desc; }
|
||||
CallArgsDescriptor* getCallArgsDescriptor() const { return callArgsDesc; }
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
@ -1,124 +0,0 @@
|
||||
//===-- llvm/CodeGen/MachineFunctionInfo.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 class keeps track of information about the stack frame and about the
|
||||
// per-function constant pool.
|
||||
//
|
||||
// FIXME: This class is completely SparcV9 specific. Do not use it for future
|
||||
// targets. This file will be eliminated in future versions of LLVM.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_CODEGEN_MACHINEFUNCTIONINFO_H
|
||||
#define LLVM_CODEGEN_MACHINEFUNCTIONINFO_H
|
||||
|
||||
#include "llvm/CodeGen/MachineCodeForInstruction.h"
|
||||
#include "Support/HashExtras.h"
|
||||
#include "Support/hash_set"
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class MachineFunction;
|
||||
class Constant;
|
||||
class Type;
|
||||
|
||||
class MachineFunctionInfo {
|
||||
hash_set<const Constant*> constantsForConstPool;
|
||||
hash_map<const Value*, int> offsets;
|
||||
|
||||
unsigned staticStackSize;
|
||||
unsigned automaticVarsSize;
|
||||
unsigned regSpillsSize;
|
||||
unsigned maxOptionalArgsSize;
|
||||
unsigned maxOptionalNumArgs;
|
||||
unsigned currentTmpValuesSize;
|
||||
unsigned maxTmpValuesSize;
|
||||
bool compiledAsLeaf;
|
||||
bool spillsAreaFrozen;
|
||||
bool automaticVarsAreaFrozen;
|
||||
|
||||
MachineFunction &MF;
|
||||
public:
|
||||
hash_map<const Instruction*, MachineCodeForInstruction> MCFIEntries;
|
||||
|
||||
MachineFunctionInfo(MachineFunction &mf) : MF(mf) {
|
||||
staticStackSize = automaticVarsSize = regSpillsSize = 0;
|
||||
maxOptionalArgsSize = maxOptionalNumArgs = currentTmpValuesSize = 0;
|
||||
maxTmpValuesSize = 0;
|
||||
compiledAsLeaf = spillsAreaFrozen = automaticVarsAreaFrozen = false;
|
||||
}
|
||||
|
||||
/// CalculateArgSize - Call this method to fill in the maxOptionalArgsSize &
|
||||
/// staticStackSize fields...
|
||||
///
|
||||
void CalculateArgSize();
|
||||
|
||||
//
|
||||
// Accessors for global information about generated code for a method.
|
||||
//
|
||||
bool isCompiledAsLeafMethod() const { return compiledAsLeaf; }
|
||||
unsigned getStaticStackSize() const { return staticStackSize; }
|
||||
unsigned getAutomaticVarsSize() const { return automaticVarsSize; }
|
||||
unsigned getRegSpillsSize() const { return regSpillsSize; }
|
||||
unsigned getMaxOptionalArgsSize() const { return maxOptionalArgsSize;}
|
||||
unsigned getMaxOptionalNumArgs() const { return maxOptionalNumArgs;}
|
||||
const hash_set<const Constant*> &getConstantPoolValues() const {
|
||||
return constantsForConstPool;
|
||||
}
|
||||
|
||||
//
|
||||
// Modifiers used during code generation
|
||||
//
|
||||
void initializeFrameLayout ();
|
||||
|
||||
void addToConstantPool (const Constant* constVal) {
|
||||
constantsForConstPool.insert(constVal);
|
||||
}
|
||||
|
||||
void markAsLeafMethod() { compiledAsLeaf = true; }
|
||||
|
||||
int computeOffsetforLocalVar (const Value* local,
|
||||
unsigned& getPaddedSize,
|
||||
unsigned sizeToUse = 0);
|
||||
int allocateLocalVar (const Value* local,
|
||||
unsigned sizeToUse = 0);
|
||||
|
||||
int allocateSpilledValue (const Type* type);
|
||||
int pushTempValue (unsigned size);
|
||||
void popAllTempValues ();
|
||||
|
||||
void freezeSpillsArea () { spillsAreaFrozen = true; }
|
||||
void freezeAutomaticVarsArea () { automaticVarsAreaFrozen=true; }
|
||||
|
||||
private:
|
||||
void incrementAutomaticVarsSize(int incr) {
|
||||
automaticVarsSize+= incr;
|
||||
staticStackSize += incr;
|
||||
}
|
||||
void incrementRegSpillsSize(int incr) {
|
||||
regSpillsSize+= incr;
|
||||
staticStackSize += incr;
|
||||
}
|
||||
void incrementTmpAreaSize(int incr) {
|
||||
currentTmpValuesSize += incr;
|
||||
if (maxTmpValuesSize < currentTmpValuesSize)
|
||||
{
|
||||
staticStackSize += currentTmpValuesSize - maxTmpValuesSize;
|
||||
maxTmpValuesSize = currentTmpValuesSize;
|
||||
}
|
||||
}
|
||||
void resetTmpAreaSize() {
|
||||
currentTmpValuesSize = 0;
|
||||
}
|
||||
int allocateOptionalArg(const Type* type);
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
Loading…
x
Reference in New Issue
Block a user