#ifndef LLVM_INSTRUCTION_H
#define LLVM_INSTRUCTION_H
+#include <vector>
#include "llvm/User.h"
class Type;
class BasicBlock;
class Method;
+class MachineInstr; // do not include header file MachineInstr.h
+class MachineCodeForVMInstr;
class Instruction : public User {
BasicBlock *Parent;
unsigned iType; // InstructionType
+ MachineCodeForVMInstr* machineInstrVec;
friend class ValueHolder<Instruction,BasicBlock,Method>;
inline void setParent(BasicBlock *P) { Parent = P; }
// Specialize setName to handle symbol table majik...
virtual void setName(const string &name);
-
+
// clone() - Create a copy of 'this' instruction that is identical in all ways
// except the following:
// * The instruction has no parent
// * The instruction has no name
//
virtual Instruction *clone() const = 0;
-
+
+ // Add a machine instruction used to implement this instruction
+ //
+ void addMachineInstruction(MachineInstr* minstr);
+
// Accessor methods...
//
inline const BasicBlock *getParent() const { return Parent; }
inline BasicBlock *getParent() { return Parent; }
virtual bool hasSideEffects() const { return false; } // Memory & Call insts
-
+ inline MachineCodeForVMInstr&
+ getMachineInstrVec() { return *machineInstrVec; }
+ const vector<Value*>&
+ getTempValuesForMachineCode() const;
+
// ---------------------------------------------------------------------------
// Subclass classification... getInstType() returns a member of
// one of the enums that is coming soon (down below)...
// isPHINode() - This is used frequently enough to allow it to exist
inline bool isPHINode() const { return iType == PHINode; }
-
+ // dropAllReferences() - This function is in charge of "letting go" of all
+ // objects that this Instruction refers to. This first lets go of all
+ // references to hidden values generated code for this instruction,
+ // and then drops all references to its operands.
+ //
+ void dropAllReferences();
+
//----------------------------------------------------------------------
// Exported enumerations...
//
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
#include "llvm/SymbolTable.h"
+#include "llvm/Codegen/MachineInstr.h"
Instruction::Instruction(const Type *ty, unsigned it, const string &Name)
- : User(ty, Value::InstructionVal, Name) {
+ : User(ty, Value::InstructionVal, Name),
+ machineInstrVec(new MachineCodeForVMInstr)
+{
Parent = 0;
iType = it;
}
Instruction::~Instruction() {
- assert(getParent() == 0 && "Instruction still embeded in basic block!");
+ assert(getParent() == 0 && "Instruction still embedded in basic block!");
+ delete machineInstrVec;
}
// Specialize setName to take care of symbol table majik
Value::setName(name);
if (PP && hasName()) PP->getSymbolTableSure()->insert(this);
}
+
+void
+Instruction::addMachineInstruction(MachineInstr* minstr)
+{
+ machineInstrVec->push_back(minstr);
+}
+
+// Dont make this inline because you would need to include
+// MachineInstr.h in Instruction.h, which creates a circular
+// sequence of forward declarations. Trying to fix that will
+// cause a serious circularity in link order.
+//
+const vector<Value*>&
+Instruction::getTempValuesForMachineCode() const
+{
+ return machineInstrVec->getTempValues();
+}
+
+void
+Instruction::dropAllReferences() {
+ machineInstrVec->dropAllReferences();
+ User::dropAllReferences();
+}