diff options
Diffstat (limited to 'lib')
-rw-r--r-- | lib/Bytecode/Reader/InstructionReader.cpp | 18 | ||||
-rw-r--r-- | lib/Bytecode/Reader/ReaderInternals.h | 7 | ||||
-rw-r--r-- | lib/Bytecode/Writer/ConstantWriter.cpp | 2 | ||||
-rw-r--r-- | lib/Bytecode/Writer/InstructionWriter.cpp | 36 | ||||
-rw-r--r-- | lib/Transforms/IPO/InlineSimple.cpp | 9 | ||||
-rw-r--r-- | lib/Transforms/Scalar/ConstantProp.cpp | 17 | ||||
-rw-r--r-- | lib/Transforms/Scalar/DCE.cpp | 2 | ||||
-rw-r--r-- | lib/Transforms/Scalar/SCCP.cpp | 8 | ||||
-rw-r--r-- | lib/VMCore/AsmWriter.cpp | 40 | ||||
-rw-r--r-- | lib/VMCore/ConstantPool.cpp | 52 | ||||
-rw-r--r-- | lib/VMCore/InstrTypes.cpp | 48 | ||||
-rw-r--r-- | lib/VMCore/Value.cpp | 7 | ||||
-rw-r--r-- | lib/VMCore/iBranch.cpp | 61 | ||||
-rw-r--r-- | lib/VMCore/iCall.cpp | 37 | ||||
-rw-r--r-- | lib/VMCore/iReturn.cpp | 22 | ||||
-rw-r--r-- | lib/VMCore/iSwitch.cpp | 74 |
16 files changed, 153 insertions, 287 deletions
diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp index fd919c9..dac7d37 100644 --- a/lib/Bytecode/Reader/InstructionReader.cpp +++ b/lib/Bytecode/Reader/InstructionReader.cpp @@ -80,8 +80,11 @@ bool BytecodeParser::ParseRawInst(const uchar *&Buf, const uchar *EndBuf, break; } - //cerr << "NO: " << Result.NumOperands << " opcode: " << Result.Opcode - // << " Ty: " << Result.Ty->getName() << " arg1: " << Result.Arg1 << endl; +#if 0 + cerr << "NO: " << Result.NumOperands << " opcode: " << Result.Opcode + << " Ty: " << Result.Ty->getName() << " arg1: " << Result.Arg1 + << " arg2: " << Result.Arg2 << " arg3: " << Result.Arg3 << endl; +#endif return false; } @@ -198,13 +201,13 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf, return false; } else if (Raw.Opcode == Instruction::Malloc) { if (Raw.NumOperands > 2) return true; - Value *Sz = (Raw.NumOperands == 2) ? getValue(Type::UIntTy, Raw.Arg2) : 0; - Res = new MallocInst((ConstPoolType*)getValue(Type::TypeTy, Raw.Arg1), Sz); + Value *Sz = Raw.NumOperands ? getValue(Type::UIntTy, Raw.Arg1) : 0; + Res = new MallocInst(Raw.Ty, Sz); return false; } else if (Raw.Opcode == Instruction::Alloca) { if (Raw.NumOperands > 2) return true; - Value *Sz = (Raw.NumOperands == 2) ? getValue(Type::UIntTy, Raw.Arg2) : 0; - Res = new AllocaInst((ConstPoolType*)getValue(Type::TypeTy, Raw.Arg1), Sz); + Value *Sz = Raw.NumOperands ? getValue(Type::UIntTy, Raw.Arg1) : 0; + Res = new AllocaInst(Raw.Ty, Sz); return false; } else if (Raw.Opcode == Instruction::Free) { Value *Val = getValue(Raw.Ty, Raw.Arg1); @@ -213,6 +216,7 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf, return false; } - cerr << "Unrecognized instruction! " << Raw.Opcode << endl; + cerr << "Unrecognized instruction! " << Raw.Opcode + << " ADDR = 0x" << (void*)Buf << endl; return true; } diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h index 3bb0472..fffcdb8 100644 --- a/lib/Bytecode/Reader/ReaderInternals.h +++ b/lib/Bytecode/Reader/ReaderInternals.h @@ -94,16 +94,9 @@ public: struct InstPlaceHolderHelper : public Instruction { InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {} - inline virtual void dropAllReferences() {} virtual string getOpcode() const { return "placeholder"; } virtual Instruction *clone() const { abort(); return 0; } - - // No "operands"... - virtual Value *getOperand(unsigned i) { return 0; } - virtual const Value *getOperand(unsigned i) const { return 0; } - virtual bool setOperand(unsigned i, Value *Val) { return false; } - virtual unsigned getNumOperands() const { return 0; } }; struct BBPlaceHolderHelper : public BasicBlock { diff --git a/lib/Bytecode/Writer/ConstantWriter.cpp b/lib/Bytecode/Writer/ConstantWriter.cpp index e65ea45..5ca0fca 100644 --- a/lib/Bytecode/Writer/ConstantWriter.cpp +++ b/lib/Bytecode/Writer/ConstantWriter.cpp @@ -128,7 +128,7 @@ bool BytecodeWriter::outputConstant(const ConstPoolVal *CPV) { case Type::StructTyID: { const ConstPoolStruct *CPS = (const ConstPoolStruct*)CPV; - const vector<ConstPoolUse> &Vals = CPS->getValues(); + const vector<Use> &Vals = CPS->getValues(); for (unsigned i = 0; i < Vals.size(); ++i) { int Slot = Table.getValSlot(Vals[i]); diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp index c7c04ef..0cd93c0 100644 --- a/lib/Bytecode/Writer/InstructionWriter.cpp +++ b/lib/Bytecode/Writer/InstructionWriter.cpp @@ -32,14 +32,13 @@ static void outputInstructionFormat0(const Instruction *I, output_vbr(I->getInstType(), Out); // Instruction Opcode ID output_vbr(Type, Out); // Result type - unsigned NumArgs; // Count the number of arguments to the instruction - for (NumArgs = 0; I->getOperand(NumArgs); NumArgs++) /*empty*/; + unsigned NumArgs = I->getNumOperands(); output_vbr(NumArgs, Out); - for (unsigned i = 0; const Value *N = I->getOperand(i); i++) { - assert(i < NumArgs && "Count of arguments failed!"); - + for (unsigned i = 0; i < NumArgs; ++i) { + const Value *N = I->getOperand(i); int Slot = Table.getValSlot(N); + assert(Slot >= 0 && "No slot number for value!?!?"); output_vbr((unsigned)Slot, Out); } align32(Out); // We must maintain correct alignment! @@ -110,25 +109,24 @@ static void outputInstructionFormat3(const Instruction *I, // unsigned Opcode = (3 << 30) | (IType << 24) | (Type << 18) | (Slots[0] << 12) | (Slots[1] << 6) | (Slots[2] << 0); - // cerr << "3 " << IType << " " << Type << " " << Slots[0] << " " - // << Slots[1] << " " << Slots[2] << endl; + //cerr << "3 " << IType << " " << Type << " " << Slots[0] << " " + // << Slots[1] << " " << Slots[2] << endl; output(Opcode, Out); } bool BytecodeWriter::processInstruction(const Instruction *I) { assert(I->getInstType() < 64 && "Opcode too big???"); - unsigned NumOperands = 0; + unsigned NumOperands = I->getNumOperands(); int MaxOpSlot = 0; - int Slots[3]; Slots[0] = (1 << 12)-1; + int Slots[3]; Slots[0] = (1 << 12)-1; // Marker to signify 0 operands - const Value *Def; - while ((Def = I->getOperand(NumOperands))) { + for (unsigned i = 0; i < NumOperands; ++i) { + const Value *Def = I->getOperand(i); int slot = Table.getValSlot(Def); assert(slot != -1 && "Broken bytecode!"); if (slot > MaxOpSlot) MaxOpSlot = slot; - if (NumOperands < 3) Slots[NumOperands] = slot; - NumOperands++; + if (i < 3) Slots[i] = slot; } // Figure out which type to encode with the instruction. Typically we want @@ -137,12 +135,10 @@ bool BytecodeWriter::processInstruction(const Instruction *I) { // the first param is actually interesting). But if we have no arguments // we take the type of the instruction itself. // - - const Type *Ty; - if (NumOperands) - Ty = I->getOperand(0)->getType(); - else - Ty = I->getType(); + const Type *Ty = NumOperands ? I->getOperand(0)->getType() : I->getType(); + if (I->getInstType() == Instruction::Malloc || + I->getInstType() == Instruction::Alloca) + Ty = I->getType(); // Malloc & Alloca ALWAYS want to encode the return type unsigned Type; int Slot = Table.getValSlot(Ty); @@ -179,6 +175,8 @@ bool BytecodeWriter::processInstruction(const Instruction *I) { break; } + // If we weren't handled before here, we either have a large number of operands + // or a large operand index that we are refering to. outputInstructionFormat0(I, Table, Type, Out); return false; } diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index d85b33d..de76dcd 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -37,7 +37,8 @@ using namespace opt; static inline void RemapInstruction(Instruction *I, map<const Value *, Value*> &ValueMap) { - for (unsigned op = 0; const Value *Op = I->getOperand(op); ++op) { + for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { + const Value *Op = I->getOperand(op); Value *V = ValueMap[Op]; if (!V && Op->isMethod()) continue; // Methods don't get relocated @@ -115,11 +116,9 @@ bool opt::InlineMethod(BasicBlock::iterator CIIt) { // Method::ArgumentListType::const_iterator PTI = CalledMeth->getArgumentList().begin(); - for (unsigned a = 1; Value *Operand = CI->getOperand(a); ++a, ++PTI) { - ValueMap[*PTI] = Operand; - } + for (unsigned a = 1, E = CI->getNumOperands(); a != E; ++a, ++PTI) + ValueMap[*PTI] = CI->getOperand(a); - ValueMap[NewBB] = NewBB; // Returns get converted to reference NewBB // Loop over all of the basic blocks in the method, inlining them as diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index 7a0254b..91a21c3 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -132,9 +132,9 @@ bool opt::ConstantFoldTerminator(TerminatorInst *T) { BasicBlock *Dest1 = BI->getOperand(0)->castBasicBlockAsserting(); BasicBlock *Dest2 = BI->getOperand(1)->castBasicBlockAsserting(); - if (BI->getOperand(2)->isConstant()) { // Are we branching on constant? + if (BI->getCondition()->isConstant()) { // Are we branching on constant? // YES. Change to unconditional branch... - ConstPoolBool *Cond = (ConstPoolBool*)BI->getOperand(2); + ConstPoolBool *Cond = (ConstPoolBool*)BI->getCondition(); BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2; BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1; @@ -147,9 +147,9 @@ bool opt::ConstantFoldTerminator(TerminatorInst *T) { assert(BI->getParent() && "Terminator not inserted in block!"); OldDest->removePredecessor(BI->getParent()); - BI->setOperand(0, Destination); // Set the unconditional destination - BI->setOperand(1, 0); // Clear the conditional destination - BI->setOperand(2, 0); // Clear the condition... + // Set the unconditional destination, and change the insn to be an + // unconditional branch. + BI->setUnconditionalDest(Destination); return true; } else if (Dest2 == Dest1) { // Conditional branch to same location? // This branch matches something like this: @@ -160,9 +160,8 @@ bool opt::ConstantFoldTerminator(TerminatorInst *T) { assert(BI->getParent() && "Terminator not inserted in block!"); Dest1->removePredecessor(BI->getParent()); - // Nuke the second destination, and the use of the condition variable - BI->setOperand(1, 0); // Clear the conditional destination - BI->setOperand(2, 0); // Clear the condition... + // Change a conditional branch to unconditional. + BI->setUnconditionalDest(Dest1); return true; } } @@ -192,7 +191,7 @@ ConstantFoldInstruction(Method *M, Method::inst_iterator &II) { PHINode *PN = (PHINode*)Inst; // If it's a PHI node and only has one operand // Then replace it directly with that operand. assert(PN->getOperand(0) && "PHI Node must have at least one operand!"); - if (PN->getOperand(1) == 0) { // If the PHI Node has exactly 1 operand + if (PN->getNumOperands() == 1) { // If the PHI Node has exactly 1 operand Value *V = PN->getOperand(0); PN->replaceAllUsesWith(V); // Replace all uses of this PHI // Unlink from basic block diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index 8e37279..fa2c9c7 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -91,7 +91,7 @@ static bool RemoveSingularPHIs(BasicBlock *BB) { do { PHINode *PN = (PHINode*)I; - assert(PN->getOperand(2) == 0 && "PHI node should only have one value!"); + assert(PN->getNumOperands() == 2 && "PHI node should only have one value!"); Value *V = PN->getOperand(0); PN->replaceAllUsesWith(V); // Replace PHI node with its single value. diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 8b59e19..5bb75c7 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -408,10 +408,10 @@ void SCCP::UpdateInstruction(Instruction *I) { markExecutable(Succ); } else if (SCValue.isConstant()) { ConstPoolVal *CPV = SCValue.getConstant(); - for (SwitchInst::dest_iterator I = SI->dest_begin(), E = SI->dest_end(); - I != E; ++I) { - if (I->first->equals(CPV)) { // Found the right branch... - markExecutable(I->second); + // Make sure to skip the "default value" which isn't a value + for (unsigned i = 1, E = SI->getNumSuccessors(); i != E; ++i) { + if (SI->getSuccessorValue(i)->equals(CPV)) {// Found the right branch... + markExecutable(SI->getSuccessor(i)); return; } } diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index c68cd79..e2b2495 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -157,10 +157,10 @@ bool AssemblyWriter::processInstruction(const Instruction *I) { Out << I->getOpcode(); // Print out the type of the operands... - const Value *Operand = I->getOperand(0); + const Value *Operand = I->getNumOperands() ? I->getOperand(0) : 0; // Special case conditional branches to swizzle the condition out to the front - if (I->getInstType() == Instruction::Br && I->getOperand(1)) { + if (I->getInstType() == Instruction::Br && I->getNumOperands() > 1) { writeOperand(I->getOperand(2), true); Out << ","; writeOperand(Operand, true); @@ -172,9 +172,9 @@ bool AssemblyWriter::processInstruction(const Instruction *I) { writeOperand(Operand , true); Out << ","; writeOperand(I->getOperand(1), true); Out << " ["; - for (unsigned op = 2; (Operand = I->getOperand(op)); op += 2) { + for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; op += 2) { Out << "\n\t\t"; - writeOperand(Operand, true); Out << ","; + writeOperand(I->getOperand(op ), true); Out << ","; writeOperand(I->getOperand(op+1), true); } Out << "\n\t]"; @@ -183,8 +183,9 @@ bool AssemblyWriter::processInstruction(const Instruction *I) { Out << " ["; writeOperand(Operand, false); Out << ","; writeOperand(I->getOperand(1), false); Out << " ]"; - for (unsigned op = 2; (Operand = I->getOperand(op)); op += 2) { - Out << ", ["; writeOperand(Operand, false); Out << ","; + for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; op += 2) { + Out << ", ["; + writeOperand(I->getOperand(op ), false); Out << ","; writeOperand(I->getOperand(op+1), false); Out << " ]"; } } else if (I->getInstType() == Instruction::Ret && !Operand) { @@ -192,20 +193,19 @@ bool AssemblyWriter::processInstruction(const Instruction *I) { } else if (I->getInstType() == Instruction::Call) { writeOperand(Operand, true); Out << "("; - Operand = I->getOperand(1); - if (Operand) writeOperand(Operand, true); - for (unsigned op = 2; (Operand = I->getOperand(op)); ++op) { + if (I->getNumOperands() > 1) writeOperand(I->getOperand(1), true); + for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; ++op) { Out << ","; - writeOperand(Operand, true); + writeOperand(I->getOperand(op), true); } Out << " )"; } else if (I->getInstType() == Instruction::Malloc || I->getInstType() == Instruction::Alloca) { - Out << " " << ((const PointerType*)((ConstPoolType*)Operand) - ->getValue())->getValueType(); - if ((Operand = I->getOperand(1))) { - Out << ","; writeOperand(Operand, true); + Out << " " << ((const PointerType*)I->getType())->getValueType(); + if (I->getNumOperands()) { + Out << ","; + writeOperand(I->getOperand(0), true); } } else if (Operand) { // Print the normal way... @@ -215,9 +215,9 @@ bool AssemblyWriter::processInstruction(const Instruction *I) { // different type operands (for example br), then they are all printed. bool PrintAllTypes = false; const Type *TheType = Operand->getType(); - unsigned i; - for (i = 1; (Operand = I->getOperand(i)); i++) { + for (unsigned i = 1, E = I->getNumOperands(); i != E; ++i) { + Operand = I->getOperand(i); if (Operand->getType() != TheType) { PrintAllTypes = true; // We have differing types! Print them all! break; @@ -227,9 +227,9 @@ bool AssemblyWriter::processInstruction(const Instruction *I) { if (!PrintAllTypes) Out << " " << I->getOperand(0)->getType(); - for (unsigned i = 0; (Operand = I->getOperand(i)); i++) { + for (unsigned i = 0, E = I->getNumOperands(); i != E; ++i) { if (i) Out << ","; - writeOperand(Operand, PrintAllTypes); + writeOperand(I->getOperand(i), PrintAllTypes); } } @@ -262,8 +262,8 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, } else { int Slot = Table.getValSlot(Operand); - if (Operand->isConstant()) { - Out << " " << ((ConstPoolVal*)Operand)->getStrValue(); + if (const ConstPoolVal *CPV = Operand->castConstant()) { + Out << " " << CPV->getStrValue(); } else { if (Slot >= 0) Out << " %" << Slot; else if (PrintName) diff --git a/lib/VMCore/ConstantPool.cpp b/lib/VMCore/ConstantPool.cpp index 77ed50a..13463a1 100644 --- a/lib/VMCore/ConstantPool.cpp +++ b/lib/VMCore/ConstantPool.cpp @@ -219,7 +219,7 @@ ConstPoolArray::ConstPoolArray(const ArrayType *T, : ConstPoolVal(T, Name) { for (unsigned i = 0; i < V.size(); i++) { assert(V[i]->getType() == T->getElementType()); - Val.push_back(ConstPoolUse(V[i], this)); + Operands.push_back(Use(V[i], this)); } } @@ -231,7 +231,7 @@ ConstPoolStruct::ConstPoolStruct(const StructType *T, for (unsigned i = 0; i < V.size(); i++) { assert(V[i]->getType() == ETypes[i]); - Val.push_back(ConstPoolUse(V[i], this)); + Operands.push_back(Use(V[i], this)); } } @@ -265,14 +265,14 @@ ConstPoolType::ConstPoolType(const ConstPoolType &CPT) ConstPoolArray::ConstPoolArray(const ConstPoolArray &CPA) : ConstPoolVal(CPA.getType()) { - for (unsigned i = 0; i < CPA.Val.size(); i++) - Val.push_back(ConstPoolUse((ConstPoolVal*)CPA.Val[i], this)); + for (unsigned i = 0; i < CPA.Operands.size(); i++) + Operands.push_back(Use(CPA.Operands[i], this)); } ConstPoolStruct::ConstPoolStruct(const ConstPoolStruct &CPS) : ConstPoolVal(CPS.getType()) { - for (unsigned i = 0; i < CPS.Val.size(); i++) - Val.push_back(ConstPoolUse((ConstPoolVal*)CPS.Val[i], this)); + for (unsigned i = 0; i < CPS.Operands.size(); i++) + Operands.push_back(Use(CPS.Operands[i], this)); } //===----------------------------------------------------------------------===// @@ -301,12 +301,12 @@ string ConstPoolType::getStrValue() const { string ConstPoolArray::getStrValue() const { string Result = "["; - if (Val.size()) { - Result += " " + Val[0]->getType()->getName() + - " " + Val[0]->getStrValue(); - for (unsigned i = 1; i < Val.size(); i++) - Result += ", " + Val[i]->getType()->getName() + - " " + Val[i]->getStrValue(); + if (Operands.size()) { + Result += " " + Operands[0]->getType()->getName() + + " " + Operands[0]->castConstantAsserting()->getStrValue(); + for (unsigned i = 1; i < Operands.size(); i++) + Result += ", " + Operands[i]->getType()->getName() + + " " + Operands[i]->castConstantAsserting()->getStrValue(); } return Result + " ]"; @@ -314,12 +314,12 @@ string ConstPoolArray::getStrValue() const { string ConstPoolStruct::getStrValue() const { string Result = "{"; - if (Val.size()) { - Result += " " + Val[0]->getType()->getName() + - " " + Val[0]->getStrValue(); - for (unsigned i = 1; i < Val.size(); i++) - Result += ", " + Val[i]->getType()->getName() + - " " + Val[i]->getStrValue(); + if (Operands.size()) { + Result += " " + Operands[0]->getType()->getName() + + " " + Operands[0]->castConstantAsserting()->getStrValue(); + for (unsigned i = 1; i < Operands.size(); i++) + Result += ", " + Operands[i]->getType()->getName() + + " " + Operands[i]->castConstantAsserting()->getStrValue(); } return Result + " }"; @@ -356,9 +356,11 @@ bool ConstPoolType::equals(const ConstPoolVal *V) const { bool ConstPoolArray::equals(const ConstPoolVal *V) const { assert(getType() == V->getType()); ConstPoolArray *AV = (ConstPoolArray*)V; - if (Val.size() != AV->Val.size()) return false; - for (unsigned i = 0; i < Val.size(); i++) - if (!Val[i]->equals(AV->Val[i])) return false; + if (Operands.size() != AV->Operands.size()) return false; + for (unsigned i = 0; i < Operands.size(); i++) + if (!Operands[i]->castConstantAsserting()->equals( + AV->Operands[i]->castConstantAsserting())) + return false; return true; } @@ -366,9 +368,11 @@ bool ConstPoolArray::equals(const ConstPoolVal *V) const { bool ConstPoolStruct::equals(const ConstPoolVal *V) const { assert(getType() == V->getType()); ConstPoolStruct *SV = (ConstPoolStruct*)V; - if (Val.size() != SV->Val.size()) return false; - for (unsigned i = 0; i < Val.size(); i++) - if (!Val[i]->equals(SV->Val[i])) return false; + if (Operands.size() != SV->Operands.size()) return false; + for (unsigned i = 0; i < Operands.size(); i++) + if (!Operands[i]->castConstantAsserting()->equals( + SV->Operands[i]->castConstantAsserting())) + return false; return true; } diff --git a/lib/VMCore/InstrTypes.cpp b/lib/VMCore/InstrTypes.cpp index baafe0b..cda99a9 100644 --- a/lib/VMCore/InstrTypes.cpp +++ b/lib/VMCore/InstrTypes.cpp @@ -9,7 +9,7 @@ #include "llvm/Method.h" #include "llvm/SymbolTable.h" #include "llvm/Type.h" -#include <algorithm> +#include <algorithm> // find // TODO: Move to getUnaryOperator iUnary.cpp when and if it exists! UnaryOperator *UnaryOperator::create(unsigned Op, Value *Source) { @@ -52,49 +52,25 @@ PHINode::PHINode(const Type *Ty, const string &name) PHINode::PHINode(const PHINode &PN) : Instruction(PN.getType(), Instruction::PHINode) { - - for (unsigned i = 0; i < PN.IncomingValues.size(); i++) - IncomingValues.push_back( - make_pair(Use(PN.IncomingValues[i].first, this), - BasicBlockUse(PN.IncomingValues[i].second, this))); -} - -void PHINode::dropAllReferences() { - IncomingValues.clear(); -} - -bool PHINode::setOperand(unsigned i, Value *Val) { - assert(Val && "PHI node must only reference nonnull definitions!"); - if (i >= IncomingValues.size()*2) return false; - - if (i & 1) { - IncomingValues[i/2].second = Val->castBasicBlockAsserting(); - } else { - IncomingValues[i/2].first = Val; + Operands.reserve(PN.Operands.size()); + for (unsigned i = 0; i < PN.Operands.size(); i+=2) { + Operands.push_back(Use(PN.Operands[i], this)); + Operands.push_back(Use(PN.Operands[i+1], this)); } - return true; } void PHINode::addIncoming(Value *D, BasicBlock *BB) { - IncomingValues.push_back(make_pair(Use(D, this), BasicBlockUse(BB, this))); + Operands.push_back(Use(D, this)); + Operands.push_back(Use(BB, this)); } -struct FindBBEntry { - const BasicBlock *BB; - inline FindBBEntry(const BasicBlock *bb) : BB(bb) {} - inline bool operator()(const pair<Use,BasicBlockUse> &Entry) { - return Entry.second == BB; - } -}; - - // removeIncomingValue - Remove an incoming value. This is useful if a // predecessor basic block is deleted. Value *PHINode::removeIncomingValue(const BasicBlock *BB) { - vector<PairTy>::iterator Idx = find_if(IncomingValues.begin(), - IncomingValues.end(), FindBBEntry(BB)); - assert(Idx != IncomingValues.end() && "BB not in PHI node!"); - Value *Removed = Idx->first; - IncomingValues.erase(Idx); + op_iterator Idx = find(Operands.begin(), Operands.end(), (const Value*)BB); + assert(Idx != Operands.end() && "BB not in PHI node!"); + --Idx; // Back up to value prior to Basic block + Value *Removed = *Idx; + Operands.erase(Idx, Idx+2); // Erase Value and BasicBlock return Removed; } diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index fa3c0f6..a051bcb 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -89,14 +89,13 @@ User::User(const Type *Ty, ValueTy vty, const string &name) void User::replaceUsesOfWith(Value *From, Value *To) { if (From == To) return; // Duh what? - for (unsigned OpNum = 0; Value *D = getOperand(OpNum); ++OpNum) { - if (D == From) { // Okay, this operand is pointing to our fake def. + for (unsigned i = 0, E = getNumOperands(); i != E; ++i) + if (getOperand(i) == From) { // Is This operand is pointing to oldval? // The side effects of this setOperand call include linking to // "To", adding "this" to the uses list of To, and // most importantly, removing "this" from the use list of "From". - setOperand(OpNum, To); // Fix it now... + setOperand(i, To); // Fix it now... } - } } diff --git a/lib/VMCore/iBranch.cpp b/lib/VMCore/iBranch.cpp index 05f3505..d0f437e 100644 --- a/lib/VMCore/iBranch.cpp +++ b/lib/VMCore/iBranch.cpp @@ -13,9 +13,17 @@ #endif BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond) - : TerminatorInst(Instruction::Br), TrueDest(True, this), - FalseDest(False, this), Condition(Cond, this) { + : TerminatorInst(Instruction::Br) { assert(True != 0 && "True branch destination may not be null!!!"); + Operands.reserve(False ? 3 : 1); + Operands.push_back(Use(True, this)); + if (False) { + Operands.push_back(Use(False, this)); + Operands.push_back(Use(Cond, this)); + } + + assert(!!False == !!Cond && + "Either both cond and false or neither can be specified!"); #ifndef NDEBUG if (Cond != 0 && Cond->getType() != Type::BoolTy) @@ -25,45 +33,12 @@ BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond) "May only branch on boolean predicates!!!!"); } -BranchInst::BranchInst(const BranchInst &BI) - : TerminatorInst(Instruction::Br), TrueDest(BI.TrueDest, this), - FalseDest(BI.FalseDest, this), Condition(BI.Condition, this) { -} - - -void BranchInst::dropAllReferences() { - Condition = 0; - TrueDest = FalseDest = 0; -} - -const Value *BranchInst::getOperand(unsigned i) const { - return (i == 0) ? (Value*)TrueDest : - ((i == 1) ? (Value*)FalseDest : - ((i == 2) ? (Value*)Condition : 0)); -} - -const BasicBlock *BranchInst::getSuccessor(unsigned i) const { - return (i == 0) ? (const BasicBlock*)TrueDest : - ((i == 1) ? (const BasicBlock*)FalseDest : 0); -} - -bool BranchInst::setOperand(unsigned i, Value *Val) { - switch (i) { - case 0: - assert(Val && "Can't change primary direction to 0!"); - assert(Val->getType() == Type::LabelTy); - TrueDest = (BasicBlock*)Val; - return true; - case 1: - assert(Val == 0 || Val->getType() == Type::LabelTy); - FalseDest = (BasicBlock*)Val; - return true; - case 2: - Condition = Val; - assert(!Condition || Condition->getType() == Type::BoolTy && - "Condition expr must be a boolean expression!"); - return true; - } - - return false; +BranchInst::BranchInst(const BranchInst &BI) : TerminatorInst(Instruction::Br) { + Operands.reserve(BI.Operands.size()); + Operands.push_back(Use(BI.Operands[0], this)); + if (BI.Operands.size() != 1) { + assert(BI.Operands.size() == 3 && "BR can have 1 or 3 operands!"); + Operands.push_back(Use(BI.Operands[1], this)); + Operands.push_back(Use(BI.Operands[2], this)); + } } diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp index 7632798..67826ff 100644 --- a/lib/VMCore/iCall.cpp +++ b/lib/VMCore/iCall.cpp @@ -1,6 +1,6 @@ -//===-- iCall.cpp - Implement the Call & Invoke instructions -----*- C++ -*--=// +//===-- iCall.cpp - Implement the call & icall instructions ------*- C++ -*--=// // -// This file implements the call and invoke instructions. +// This file implements the call and icall instructions. // //===----------------------------------------------------------------------===// @@ -8,9 +8,12 @@ #include "llvm/DerivedTypes.h" #include "llvm/Method.h" -CallInst::CallInst(Method *m, vector<Value*> ¶ms, +CallInst::CallInst(Method *M, vector<Value*> ¶ms, const string &Name) - : Instruction(m->getReturnType(), Instruction::Call, Name), M(m, this) { + : Instruction(M->getReturnType(), Instruction::Call, Name) { + + Operands.reserve(1+params.size()); + Operands.push_back(Use(M, this)); const MethodType* MT = M->getMethodType(); const MethodType::ParamTypes &PL = MT->getParamTypes(); @@ -19,29 +22,15 @@ CallInst::CallInst(Method *m, vector<Value*> ¶ms, MethodType::ParamTypes::const_iterator It = PL.begin(); #endif for (unsigned i = 0; i < params.size(); i++) { - assert(*It++ == params[i]->getType()); - Params.push_back(Use(params[i], this)); + assert(*It++ == params[i]->getType() && "Call Operands not correct type!"); + Operands.push_back(Use(params[i], this)); } } CallInst::CallInst(const CallInst &CI) - : Instruction(CI.getType(), Instruction::Call), M(CI.M, this) { - for (unsigned i = 0; i < CI.Params.size(); i++) - Params.push_back(Use(CI.Params[i], this)); -} - -void CallInst::dropAllReferences() { - M = 0; - Params.clear(); + : Instruction(CI.getType(), Instruction::Call) { + Operands.reserve(CI.Operands.size()); + for (unsigned i = 0; i < CI.Operands.size(); ++i) + Operands.push_back(Use(CI.Operands[i], this)); } -bool CallInst::setOperand(unsigned i, Value *Val) { - if (i > Params.size()) return false; - if (i == 0) { - M = Val->castMethodAsserting(); - } else { - // TODO: assert = method arg type - Params[i-1] = Val; - } - return true; -} diff --git a/lib/VMCore/iReturn.cpp b/lib/VMCore/iReturn.cpp index 7fa04fb..b28b04f 100644 --- a/lib/VMCore/iReturn.cpp +++ b/lib/VMCore/iReturn.cpp @@ -1,25 +1,3 @@ -//===-- iReturn.cpp - Implement the Return instruction -----------*- C++ -*--=// -// -// This file implements the Return instruction... -// -//===----------------------------------------------------------------------===// -#include "llvm/iTerminators.h" -ReturnInst::ReturnInst(Value *V) - : TerminatorInst(Instruction::Ret), Val(V, this) { -} -ReturnInst::ReturnInst(const ReturnInst &RI) - : TerminatorInst(Instruction::Ret), Val(RI.Val, this) { -} - -void ReturnInst::dropAllReferences() { - Val = 0; -} - -bool ReturnInst::setOperand(unsigned i, Value *V) { - if (i) return false; - Val = V; - return true; -} diff --git a/lib/VMCore/iSwitch.cpp b/lib/VMCore/iSwitch.cpp index 2a1eec2..e5e3c50 100644 --- a/lib/VMCore/iSwitch.cpp +++ b/lib/VMCore/iSwitch.cpp @@ -10,72 +10,24 @@ #include "llvm/Type.h" #endif -SwitchInst::SwitchInst(Value *V, BasicBlock *DefV) - : TerminatorInst(Instruction::Switch), - DefaultDest(DefV, this), Val(V, this) { - assert(Val && DefV); +SwitchInst::SwitchInst(Value *V, BasicBlock *DefDest) + : TerminatorInst(Instruction::Switch) { + assert(V && DefDest); + Operands.push_back(Use(V, this)); + Operands.push_back(Use(DefDest, this)); } SwitchInst::SwitchInst(const SwitchInst &SI) - : TerminatorInst(Instruction::Switch), DefaultDest(SI.DefaultDest), - Val(SI.Val) { + : TerminatorInst(Instruction::Switch) { + Operands.reserve(SI.Operands.size()); - for (dest_const_iterator I = SI.Destinations.begin(), - end = SI.Destinations.end(); I != end; ++I) - Destinations.push_back(dest_value(ConstPoolUse(I->first, this), - BasicBlockUse(I->second, this))); + for (unsigned i = 0, E = SI.Operands.size(); i != E; i+=2) { + Operands.push_back(Use(SI.Operands[i], this)); + Operands.push_back(Use(SI.Operands[i+1], this)); + } } - void SwitchInst::dest_push_back(ConstPoolVal *OnVal, BasicBlock *Dest) { - Destinations.push_back(dest_value(ConstPoolUse(OnVal, this), - BasicBlockUse(Dest, this))); -} - -void SwitchInst::dropAllReferences() { - Val = 0; - DefaultDest = 0; - Destinations.clear(); -} - -const BasicBlock *SwitchInst::getSuccessor(unsigned idx) const { - if (idx == 0) return DefaultDest; - if (idx > Destinations.size()) return 0; - return Destinations[idx-1].second; -} - -unsigned SwitchInst::getNumOperands() const { - return 2+Destinations.size(); -} - -const Value *SwitchInst::getOperand(unsigned i) const { - if (i == 0) return Val; - else if (i == 1) return DefaultDest; - - unsigned slot = (i-2) >> 1; - if (slot >= Destinations.size()) return 0; - - if (i & 1) return Destinations[slot].second; - return Destinations[slot].first; -} - -bool SwitchInst::setOperand(unsigned i, Value *V) { - if (i == 0) { Val = V; return true; } - else if (i == 1) { - assert(V->getType() == Type::LabelTy); - DefaultDest = (BasicBlock*)V; - return true; - } - - unsigned slot = (i-2) >> 1; - if (slot >= Destinations.size()) return 0; - - if (i & 1) { - assert(V->getType() == Type::LabelTy); - Destinations[slot].second = (BasicBlock*)V; - } else { - // TODO: assert constant - Destinations[slot].first = (ConstPoolVal*)V; - } - return true; + Operands.push_back(Use(OnVal, this)); + Operands.push_back(Use(Dest, this)); } |