diff options
Diffstat (limited to 'lib/CodeGen')
| -rw-r--r-- | lib/CodeGen/MachineInstr.cpp | 35 | ||||
| -rw-r--r-- | lib/CodeGen/MachineInstrAnnot.cpp | 36 |
2 files changed, 55 insertions, 16 deletions
diff --git a/lib/CodeGen/MachineInstr.cpp b/lib/CodeGen/MachineInstr.cpp index 2d2487e868..91b5ce7728 100644 --- a/lib/CodeGen/MachineInstr.cpp +++ b/lib/CodeGen/MachineInstr.cpp @@ -19,24 +19,33 @@ extern const MachineInstrDescriptor *TargetInstrDescriptors; // Constructor for instructions with fixed #operands (nearly all) MachineInstr::MachineInstr(MachineOpCode _opCode) : opCode(_opCode), - operands(TargetInstrDescriptors[_opCode].numOperands, MachineOperand()) { + operands(TargetInstrDescriptors[_opCode].numOperands, MachineOperand()), + numImplicitRefs(0) +{ assert(TargetInstrDescriptors[_opCode].numOperands >= 0); } // Constructor for instructions with variable #operands MachineInstr::MachineInstr(MachineOpCode OpCode, unsigned numOperands) - : opCode(OpCode), operands(numOperands, MachineOperand()) { + : opCode(OpCode), + operands(numOperands, MachineOperand()), + numImplicitRefs(0) +{ } MachineInstr::MachineInstr(MachineOpCode Opcode, unsigned numOperands, - bool XX, bool YY) : opCode(Opcode) { + bool XX, bool YY) + : opCode(Opcode), + numImplicitRefs(0) +{ operands.reserve(numOperands); } // OperandComplete - Return true if it's illegal to add a new operand -bool MachineInstr::OperandsComplete() const { +bool MachineInstr::OperandsComplete() const +{ int NumOperands = TargetInstrDescriptors[opCode].numOperands; - if (NumOperands >= 0 && operands.size() >= (unsigned)NumOperands) + if (NumOperands >= 0 && getNumOperands() >= (unsigned)NumOperands) return true; // Broken! return false; } @@ -47,7 +56,10 @@ bool MachineInstr::OperandsComplete() const { // This only resets the size of the operand vector and initializes it. // The new operands must be set explicitly later. // -void MachineInstr::replace(MachineOpCode Opcode, unsigned numOperands) { +void MachineInstr::replace(MachineOpCode Opcode, unsigned numOperands) +{ + assert(getNumImplicitRefs() == 0 && + "This is probably broken because implicit refs are going to be lost."); opCode = Opcode; operands.clear(); operands.resize(numOperands, MachineOperand()); @@ -60,7 +72,7 @@ MachineInstr::SetMachineOperandVal(unsigned i, bool isdef, bool isDefAndUse) { - assert(i < operands.size()); + assert(i < operands.size()); // may be explicit or implicit op operands[i].opType = opType; operands[i].value = V; operands[i].regNum = -1; @@ -77,7 +89,7 @@ MachineInstr::SetMachineOperandConst(unsigned i, MachineOperand::MachineOperandType operandType, int64_t intValue) { - assert(i < operands.size()); + assert(i < getNumOperands()); // must be explicit op assert(TargetInstrDescriptors[opCode].resultPos != (int) i && "immed. constant cannot be defined"); @@ -92,7 +104,7 @@ void MachineInstr::SetMachineOperandReg(unsigned i, int regNum, bool isdef) { - assert(i < operands.size()); + assert(i < getNumOperands()); // must be explicit op operands[i].opType = MachineOperand::MO_MachineRegister; operands[i].value = NULL; @@ -107,6 +119,7 @@ MachineInstr::SetMachineOperandReg(unsigned i, void MachineInstr::SetRegForOperand(unsigned i, int regNum) { + assert(i < getNumOperands()); // must be explicit op operands[i].setRegForValue(regNum); insertUsedReg(regNum); } @@ -129,11 +142,11 @@ MachineInstr::substituteValue(const Value* oldVal, Value* newVal, bool defsOnly) } // Subsitute implicit refs - for (unsigned i=0, N=implicitRefs.size(); i < N; ++i) + for (unsigned i=0, N=getNumImplicitRefs(); i < N; ++i) if (getImplicitRef(i) == oldVal) if (!defsOnly || implicitRefIsDefined(i)) { - implicitRefs[i].Val = newVal; + getImplicitOp(i).value = newVal; ++numSubst; } diff --git a/lib/CodeGen/MachineInstrAnnot.cpp b/lib/CodeGen/MachineInstrAnnot.cpp index b4809a6be8..27cf7ad931 100644 --- a/lib/CodeGen/MachineInstrAnnot.cpp +++ b/lib/CodeGen/MachineInstrAnnot.cpp @@ -6,18 +6,17 @@ //===----------------------------------------------------------------------===// #include "llvm/CodeGen/MachineInstrAnnot.h" -#include "llvm/Annotation.h" +#include "llvm/CodeGen/InstrSelection.h" +#include "llvm/CodeGen/InstrSelectionSupport.h" +#include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/iOther.h" #include "llvm/Type.h" -AnnotationID CallArgsDescriptor::AID(AnnotationManager:: - getID("CodeGen::CallArgsDescriptor")); CallArgsDescriptor::CallArgsDescriptor(const CallInst* _callInstr, TmpInstruction* _retAddrReg, bool _isVarArgs, bool _noPrototype) - : Annotation(AID), - callInstr(_callInstr), + : callInstr(_callInstr), funcPtr(isa<Function>(_callInstr->getCalledValue()) ? NULL : _callInstr->getCalledValue()), retAddrReg(_retAddrReg), @@ -30,6 +29,10 @@ CallArgsDescriptor::CallArgsDescriptor(const CallInst* _callInstr, && "Operand 0 is ignored in the loop below!"); for (unsigned int i=1; i < numArgs; ++i) argInfoVec.push_back(CallArgInfo(callInstr->getOperand(i))); + + // Enter this object in the MachineCodeForInstr object of the CallInst. + // This transfers ownership of this object. + MachineCodeForInstruction::get(callInstr).setCallArgsDescriptor(this); } @@ -38,3 +41,26 @@ CallArgsDescriptor::getReturnValue() const { return (callInstr->getType() == Type::VoidTy? NULL : callInstr); } + + +// Mechanism to get the descriptor for a CALL MachineInstr. +// We get the LLVM CallInstr from the ret. addr. register argument +// of the CALL MachineInstr, then get the CallArgsDescriptor from the +// MachineCodeForInstruction object for the CallInstr. +// This is roundabout but avoids adding a new map or annotation just +// to keep track of CallArgsDescriptors. +// +CallArgsDescriptor *CallArgsDescriptor::get(const MachineInstr* MI) +{ + const TmpInstruction* retAddrReg = + cast<TmpInstruction>(MI->getImplicitRef(MI->getNumImplicitRefs()-1)); + assert(retAddrReg->getNumOperands() == 1 && + isa<CallInst>(retAddrReg->getOperand(0)) && + "Order of implicit args of CALL instr. changed. FIX THIS CODE!"); + const CallInst* callInstr = cast<CallInst>(retAddrReg->getOperand(0)); + + CallArgsDescriptor* desc = + MachineCodeForInstruction::get(callInstr).getCallArgsDescriptor(); + assert(desc->getCallInst()==callInstr && "Incorrect call args descriptor?"); + return desc; +} |