[llvm-commits] CVS: llvm/lib/Bytecode/Reader/ConstantReader.cpp InstructionReader.cpp Reader.cpp ReaderInternals.h
Chris Lattner
lattner at cs.uiuc.edu
Thu Oct 9 15:23:01 PDT 2003
Changes in directory llvm/lib/Bytecode/Reader:
ConstantReader.cpp updated: 1.55 -> 1.56
InstructionReader.cpp updated: 1.55 -> 1.56
Reader.cpp updated: 1.73 -> 1.74
ReaderInternals.h updated: 1.54 -> 1.55
---
Log message:
Major refactoring of the bytecode reader. This includes the following
changes:
* BytecodeReader::getType(...) used to return a null pointer
on error. This was only checked about half the time. Now we convert
it to throw an exception, and delete the half that checked for error.
This was checked in before, but psmith crashed and lost the change :(
* insertValue no longer returns -1 on error, so callers don't need to
check for it.
* Substantial rewrite of InstructionReader.cpp, to use more efficient,
simpler, data structures. This provides another 5% speedup. This also
makes the code much easier to read and understand.
---
Diffs of the changes: (+169 -313)
Index: llvm/lib/Bytecode/Reader/ConstantReader.cpp
diff -u llvm/lib/Bytecode/Reader/ConstantReader.cpp:1.55 llvm/lib/Bytecode/Reader/ConstantReader.cpp:1.56
--- llvm/lib/Bytecode/Reader/ConstantReader.cpp:1.55 Sat Oct 4 15:00:03 2003
+++ llvm/lib/Bytecode/Reader/ConstantReader.cpp Thu Oct 9 15:22:47 2003
@@ -27,7 +27,6 @@
unsigned Typ;
if (read_vbr(Buf, EndBuf, Typ)) return Val;
const Type *RetType = getType(Typ);
- if (RetType == 0) return Val;
unsigned NumParams;
if (read_vbr(Buf, EndBuf, NumParams)) return Val;
@@ -35,9 +34,7 @@
std::vector<const Type*> Params;
while (NumParams--) {
if (read_vbr(Buf, EndBuf, Typ)) return Val;
- const Type *Ty = getType(Typ);
- if (Ty == 0) return Val;
- Params.push_back(Ty);
+ Params.push_back(getType(Typ));
}
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
@@ -49,7 +46,6 @@
unsigned ElTyp;
if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
const Type *ElementType = getType(ElTyp);
- if (ElementType == 0) return Val;
unsigned NumElements;
if (read_vbr(Buf, EndBuf, NumElements)) return Val;
@@ -64,10 +60,7 @@
if (read_vbr(Buf, EndBuf, Typ)) return Val;
while (Typ) { // List is terminated by void/0 typeid
- const Type *Ty = getType(Typ);
- if (Ty == 0) return Val;
- Elements.push_back(Ty);
-
+ Elements.push_back(getType(Typ));
if (read_vbr(Buf, EndBuf, Typ)) return Val;
}
@@ -77,9 +70,7 @@
unsigned ElTyp;
if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
BCR_TRACE(5, "Pointer Type Constant #" << ElTyp << "\n");
- const Type *ElementType = getType(ElTyp);
- if (ElementType == 0) return Val;
- return PointerType::get(ElementType);
+ return PointerType::get(getType(ElTyp));
}
case Type::OpaqueTyID: {
@@ -169,9 +160,8 @@
if (read_vbr(Buf, EndBuf, ArgValSlot)) throw Error_readvbr;
if (read_vbr(Buf, EndBuf, ArgTypeSlot)) throw Error_readvbr;
const Type *ArgTy = getType(ArgTypeSlot);
- if (ArgTy == 0) throw std::string("Argument type slot not found.");
- BCR_TRACE(4, "CE Arg " << i << ": Type: '" << ArgTy << "' slot: "
+ BCR_TRACE(4, "CE Arg " << i << ": Type: '" << *ArgTy << "' slot: "
<< ArgValSlot << "\n");
// Get the arg value from its slot if it exists, otherwise a placeholder
@@ -355,27 +345,25 @@
if (read_vbr(Buf, EndBuf, NumEntries) ||
read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
- const Type *Ty = getType(Typ);
- if (Ty == 0) throw std::string("Invalid type read.");
- BCR_TRACE(3, "Type: '" << Ty << "' NumEntries: " << NumEntries << "\n");
-
if (Typ == Type::TypeTyID) {
+ BCR_TRACE(3, "Type: 'type' NumEntries: " << NumEntries << "\n");
parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
} else {
+ const Type *Ty = getType(Typ);
+ BCR_TRACE(3, "Type: '" << *Ty << "' NumEntries: " << NumEntries << "\n");
+
for (unsigned i = 0; i < NumEntries; ++i) {
Constant *C = parseConstantValue(Buf, EndBuf, Ty);
assert(C && "parseConstantValue returned NULL!");
BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
- int Slot;
- if ((Slot = insertValue(C, Tab)) == -1)
- throw std::string("Could not insert value into ValueTable.");
+ unsigned Slot = insertValue(C, Tab);
// If we are reading a function constant table, make sure that we adjust
// the slot number to be the real global constant number.
//
if (&Tab != &ModuleValues && Typ < ModuleValues.size())
Slot += ModuleValues[Typ]->size();
- ResolveReferencesToValue(C, (unsigned)Slot);
+ ResolveReferencesToValue(C, Slot);
}
}
}
Index: llvm/lib/Bytecode/Reader/InstructionReader.cpp
diff -u llvm/lib/Bytecode/Reader/InstructionReader.cpp:1.55 llvm/lib/Bytecode/Reader/InstructionReader.cpp:1.56
--- llvm/lib/Bytecode/Reader/InstructionReader.cpp:1.55 Thu Oct 9 13:25:19 2003
+++ llvm/lib/Bytecode/Reader/InstructionReader.cpp Thu Oct 9 15:22:47 2003
@@ -6,9 +6,6 @@
// Note that this library should be as fast as possible, reentrant, and
// threadsafe!!
//
-// TODO: Change from getValue(Raw.Arg1) etc, to getArg(Raw, 1)
-// Make it check type, so that casts are checked.
-//
//===----------------------------------------------------------------------===//
#include "ReaderInternals.h"
@@ -17,11 +14,21 @@
#include "llvm/iPHINode.h"
#include "llvm/iOther.h"
-std::auto_ptr<RawInst>
-BytecodeParser::ParseRawInst(const unsigned char *&Buf,
- const unsigned char *EndBuf) {
+struct RawInst { // The raw fields out of the bytecode stream...
+ unsigned NumOperands;
+ unsigned Opcode;
+ unsigned Type;
+
+ RawInst(const unsigned char *&Buf, const unsigned char *EndBuf,
+ std::vector<unsigned> &Args);
+
+};
+
+
+
+RawInst::RawInst(const unsigned char *&Buf, const unsigned char *EndBuf,
+ std::vector<unsigned> &Args) {
unsigned Op, Typ;
- std::auto_ptr<RawInst> Result = std::auto_ptr<RawInst>(new RawInst());
if (read(Buf, EndBuf, Op))
throw std::string("Error reading from buffer.");
@@ -29,20 +36,20 @@
// --------------------------
// 01-00: Opcode type, fixed to 1.
// 07-02: Opcode
- Result->NumOperands = (Op >> 0) & 03;
- Result->Opcode = (Op >> 2) & 63;
+ Opcode = (Op >> 2) & 63;
+ Args.resize((Op >> 0) & 03);
- switch (Result->NumOperands) {
+ switch (Args.size()) {
case 1:
// bits Instruction format:
// --------------------------
// 19-08: Resulting type plane
// 31-20: Operand #1 (if set to (2^12-1), then zero operands)
//
- Result->Ty = getType((Op >> 8) & 4095);
- Result->Arg1 = (Op >> 20) & 4095;
- if (Result->Arg1 == 4095) // Handle special encoding for 0 operands...
- Result->NumOperands = 0;
+ Type = (Op >> 8) & 4095;
+ Args[0] = (Op >> 20) & 4095;
+ if (Args[0] == 4095) // Handle special encoding for 0 operands...
+ Args.resize(0);
break;
case 2:
// bits Instruction format:
@@ -51,9 +58,9 @@
// 23-16: Operand #1
// 31-24: Operand #2
//
- Result->Ty = getType((Op >> 8) & 255);
- Result->Arg1 = (Op >> 16) & 255;
- Result->Arg2 = (Op >> 24) & 255;
+ Type = (Op >> 8) & 255;
+ Args[0] = (Op >> 16) & 255;
+ Args[1] = (Op >> 24) & 255;
break;
case 3:
// bits Instruction format:
@@ -63,159 +70,101 @@
// 25-20: Operand #2
// 31-26: Operand #3
//
- Result->Ty = getType((Op >> 8) & 63);
- Result->Arg1 = (Op >> 14) & 63;
- Result->Arg2 = (Op >> 20) & 63;
- Result->Arg3 = (Op >> 26) & 63;
+ Type = (Op >> 8) & 63;
+ Args[0] = (Op >> 14) & 63;
+ Args[1] = (Op >> 20) & 63;
+ Args[2] = (Op >> 26) & 63;
break;
case 0:
Buf -= 4; // Hrm, try this again...
- if (read_vbr(Buf, EndBuf, Result->Opcode))
+ if (read_vbr(Buf, EndBuf, Opcode))
throw std::string("Error reading from buffer.");
- Result->Opcode >>= 2;
- if (read_vbr(Buf, EndBuf, Typ))
+ Opcode >>= 2;
+ if (read_vbr(Buf, EndBuf, Type))
throw std::string("Error reading from buffer.");
- Result->Ty = getType(Typ);
- if (Result->Ty == 0)
- throw std::string("Invalid type read in instruction.");
- if (read_vbr(Buf, EndBuf, Result->NumOperands))
+
+ unsigned NumOperands;
+ if (read_vbr(Buf, EndBuf, NumOperands))
throw std::string("Error reading from buffer.");
+ Args.resize(NumOperands);
- switch (Result->NumOperands) {
- case 0:
+ if (NumOperands == 0)
throw std::string("Zero-argument instruction found; this is invalid.");
- case 1:
- if (read_vbr(Buf, EndBuf, Result->Arg1))
- throw std::string("Error reading from buffer");
- break;
- case 2:
- if (read_vbr(Buf, EndBuf, Result->Arg1) ||
- read_vbr(Buf, EndBuf, Result->Arg2))
- throw std::string("Error reading from buffer");
- break;
- case 3:
- if (read_vbr(Buf, EndBuf, Result->Arg1) ||
- read_vbr(Buf, EndBuf, Result->Arg2) ||
- read_vbr(Buf, EndBuf, Result->Arg3))
- throw std::string("Error reading from buffer");
- break;
- default:
- if (read_vbr(Buf, EndBuf, Result->Arg1) ||
- read_vbr(Buf, EndBuf, Result->Arg2))
- throw std::string("Error reading from buffer");
-
- // Allocate a vector to hold arguments 3, 4, 5, 6 ...
- Result->VarArgs = new std::vector<unsigned>(Result->NumOperands-2);
- for (unsigned a = 0; a < Result->NumOperands-2; a++)
- if (read_vbr(Buf, EndBuf, (*Result->VarArgs)[a]))
- throw std::string("Error reading from buffer");
- break;
- }
- if (align32(Buf, EndBuf))
+ for (unsigned i = 0; i != NumOperands; ++i)
+ if (read_vbr(Buf, EndBuf, Args[i]))
+ throw std::string("Error reading from buffer");
+ if (align32(Buf, EndBuf))
throw std::string("Unaligned bytecode buffer.");
break;
}
-
-#if 0
- std::cerr << "NO: " << Result->NumOperands << " opcode: " << Result->Opcode
- << " Ty: "<< Result->Ty->getDescription()<< " arg1: "<< Result->Arg1
- << " arg2: " << Result->Arg2 << " arg3: " << Result->Arg3 << "\n";
-#endif
- return Result;
}
Instruction *BytecodeParser::ParseInstruction(const unsigned char *&Buf,
const unsigned char *EndBuf) {
- std::auto_ptr<RawInst> Raw = ParseRawInst(Buf, EndBuf);
+ std::vector<unsigned> Args;
+ RawInst RI(Buf, EndBuf, Args);
+ const Type *InstTy = getType(RI.Type);
+
+ if (RI.Opcode >= Instruction::BinaryOpsBegin &&
+ RI.Opcode < Instruction::BinaryOpsEnd && Args.size() == 2)
+ return BinaryOperator::create((Instruction::BinaryOps)RI.Opcode,
+ getValue(InstTy, Args[0]),
+ getValue(InstTy, Args[1]));
- if (Raw->Opcode >= Instruction::BinaryOpsBegin &&
- Raw->Opcode < Instruction::BinaryOpsEnd && Raw->NumOperands == 2)
- return BinaryOperator::create((Instruction::BinaryOps)Raw->Opcode,
- getValue(Raw->Ty, Raw->Arg1),
- getValue(Raw->Ty, Raw->Arg2));
-
- switch (Raw->Opcode) {
+ switch (RI.Opcode) {
case Instruction::VarArg:
- case Instruction::Cast: {
- Value *V = getValue(Raw->Ty, Raw->Arg1);
- const Type *Ty = getType(Raw->Arg2);
- if (Ty == 0) throw std::string("Invalid cast!\n");
- if (Raw->Opcode == Instruction::Cast)
- return new CastInst(V, Ty);
- else
- return new VarArgInst(V, Ty);
- }
+ return new VarArgInst(getValue(InstTy, Args[0]), getType(Args[1]));
+ case Instruction::Cast:
+ return new CastInst(getValue(InstTy, Args[0]), getType(Args[1]));
case Instruction::PHINode: {
- PHINode *PN = new PHINode(Raw->Ty);
- switch (Raw->NumOperands) {
- case 0:
- case 1:
- case 3:
- delete PN;
+ if (Args.size() == 0 || (Args.size() & 1))
throw std::string("Invalid phi node encountered!\n");
- case 2:
- PN->addIncoming(getValue(Raw->Ty, Raw->Arg1), getBasicBlock(Raw->Arg2));
- break;
- default:
- PN->addIncoming(getValue(Raw->Ty, Raw->Arg1), getBasicBlock(Raw->Arg2));
- if (Raw->VarArgs->size() & 1) {
- delete PN;
- throw std::string("PHI Node with ODD number of arguments!\n");
- } else {
- std::vector<unsigned> &args = *Raw->VarArgs;
- for (unsigned i = 0; i < args.size(); i+=2)
- PN->addIncoming(getValue(Raw->Ty, args[i]), getBasicBlock(args[i+1]));
- }
- delete Raw->VarArgs;
- break;
- }
+
+ PHINode *PN = new PHINode(InstTy);
+ for (unsigned i = 0, e = Args.size(); i != e; i += 2)
+ PN->addIncoming(getValue(InstTy, Args[i]), getBasicBlock(Args[i+1]));
return PN;
}
case Instruction::Shl:
case Instruction::Shr:
- return new ShiftInst((Instruction::OtherOps)Raw->Opcode,
- getValue(Raw->Ty, Raw->Arg1),
- getValue(Type::UByteTyID, Raw->Arg2));
+ return new ShiftInst((Instruction::OtherOps)RI.Opcode,
+ getValue(InstTy, Args[0]),
+ getValue(Type::UByteTyID, Args[1]));
case Instruction::Ret:
- if (Raw->NumOperands == 0)
+ if (Args.size() == 0)
return new ReturnInst();
- else if (Raw->NumOperands == 1)
- return new ReturnInst(getValue(Raw->Ty, Raw->Arg1));
+ else if (Args.size() == 1)
+ return new ReturnInst(getValue(InstTy, Args[0]));
break;
case Instruction::Br:
- if (Raw->NumOperands == 1)
- return new BranchInst(getBasicBlock(Raw->Arg1));
- else if (Raw->NumOperands == 3)
- return new BranchInst(getBasicBlock(Raw->Arg1), getBasicBlock(Raw->Arg2),
- getValue(Type::BoolTyID , Raw->Arg3));
+ if (Args.size() == 1)
+ return new BranchInst(getBasicBlock(Args[0]));
+ else if (Args.size() == 3)
+ return new BranchInst(getBasicBlock(Args[0]), getBasicBlock(Args[1]),
+ getValue(Type::BoolTyID , Args[2]));
throw std::string("Invalid number of operands for a 'br' instruction!");
case Instruction::Switch: {
- SwitchInst *I = new SwitchInst(getValue(Raw->Ty, Raw->Arg1),
- getBasicBlock(Raw->Arg2));
- if (Raw->NumOperands < 3)
- return I;
-
- if (Raw->NumOperands == 3 || Raw->VarArgs->size() & 1) {
- delete I;
+ if (Args.size() & 1)
throw std::string("Switch statement with odd number of arguments!");
- }
-
- std::vector<unsigned> &args = *Raw->VarArgs;
- for (unsigned i = 0; i < args.size(); i += 2)
- I->addCase(cast<Constant>(getValue(Raw->Ty, args[i])),
- getBasicBlock(args[i+1]));
- delete Raw->VarArgs;
+ SwitchInst *I = new SwitchInst(getValue(InstTy, Args[0]),
+ getBasicBlock(Args[1]));
+ for (unsigned i = 2, e = Args.size(); i != e; i += 2)
+ I->addCase(cast<Constant>(getValue(InstTy, Args[i])),
+ getBasicBlock(Args[i+1]));
return I;
}
case Instruction::Call: {
- Value *F = getValue(Raw->Ty, Raw->Arg1);
+ if (Args.size() == 0)
+ throw std::string("Invalid call instruction encountered!");
+
+ Value *F = getValue(InstTy, Args[0]);
// Check to make sure we have a pointer to function type
const PointerType *PTy = dyn_cast<PointerType>(F->getType());
@@ -229,45 +178,26 @@
if (!FTy->isVarArg()) {
FunctionType::ParamTypes::const_iterator It = PL.begin();
- switch (Raw->NumOperands) {
- case 0: throw std::string("Invalid call instruction encountered!");
- case 1: break;
- case 2: Params.push_back(getValue(*It++, Raw->Arg2)); break;
- case 3: Params.push_back(getValue(*It++, Raw->Arg2));
- if (It == PL.end()) throw std::string("Invalid call instruction!");
- Params.push_back(getValue(*It++, Raw->Arg3)); break;
- default:
- Params.push_back(getValue(*It++, Raw->Arg2));
- {
- std::vector<unsigned> &args = *Raw->VarArgs;
- for (unsigned i = 0; i < args.size(); i++) {
- if (It == PL.end()) throw std::string("Invalid call instruction!");
- Params.push_back(getValue(*It++, args[i]));
- }
- }
- delete Raw->VarArgs;
+ for (unsigned i = 1, e = Args.size(); i != e; ++i) {
+ if (It == PL.end()) throw std::string("Invalid call instruction!");
+ Params.push_back(getValue(*It++, Args[i]));
}
if (It != PL.end()) throw std::string("Invalid call instruction!");
} else {
- if (Raw->NumOperands > 2) {
- std::vector<unsigned> &args = *Raw->VarArgs;
- if (args.size() < 1) throw std::string("Invalid call instruction!");
-
- if ((args.size() & 1) != 0) // Must be pairs of type/value
- throw std::string("Invalid call instruction!");
- for (unsigned i = 0; i < args.size(); i+=2) {
- const Type *Ty = getType(args[i]);
- if (Ty == 0) throw std::string("Invalid call instruction!");
- Params.push_back(getValue(Ty, args[i+1]));
- }
- delete Raw->VarArgs;
- }
+ // FIXME: Args[1] is currently just a dummy padding field!
+
+ if (Args.size() & 1) // Must be pairs of type/value
+ throw std::string("Invalid call instruction!");
+
+ for (unsigned i = 2, e = Args.size(); i != e; i += 2)
+ Params.push_back(getValue(getType(Args[i]), Args[i+1]));
}
return new CallInst(F, Params);
}
case Instruction::Invoke: {
- Value *F = getValue(Raw->Ty, Raw->Arg1);
+ if (Args.size() < 3) throw std::string("Invalid invoke instruction!");
+ Value *F = getValue(InstTy, Args[0]);
// Check to make sure we have a pointer to function type
const PointerType *PTy = dyn_cast<PointerType>(F->getType());
@@ -276,131 +206,99 @@
if (FTy == 0) throw std::string("Invoke to non function pointer value!");
std::vector<Value *> Params;
- const FunctionType::ParamTypes &PL = FTy->getParamTypes();
- std::vector<unsigned> &args = *Raw->VarArgs;
-
BasicBlock *Normal, *Except;
+ const FunctionType::ParamTypes &PL = FTy->getParamTypes();
+
if (!FTy->isVarArg()) {
- if (Raw->NumOperands < 3) throw std::string("Invalid call instruction!");
+ Normal = getBasicBlock(Args[1]);
+ Except = getBasicBlock(Args[2]);
- Normal = getBasicBlock(Raw->Arg2);
- if (Raw->NumOperands == 3)
- Except = getBasicBlock(Raw->Arg3);
- else {
- Except = getBasicBlock(args[0]);
-
- FunctionType::ParamTypes::const_iterator It = PL.begin();
- for (unsigned i = 1; i < args.size(); i++) {
- if (It == PL.end()) throw std::string("Invalid invoke instruction!");
- Params.push_back(getValue(*It++, args[i]));
- }
- if (It != PL.end()) throw std::string("Invalid invoke instruction!");
+ FunctionType::ParamTypes::const_iterator It = PL.begin();
+ for (unsigned i = 3, e = Args.size(); i != e; ++i) {
+ if (It == PL.end()) throw std::string("Invalid invoke instruction!");
+ Params.push_back(getValue(*It++, Args[i]));
}
+ if (It != PL.end()) throw std::string("Invalid invoke instruction!");
} else {
- if (args.size() < 4) throw std::string("Invalid invoke instruction!");
- if (args[0] != Type::LabelTyID || args[2] != Type::LabelTyID)
+ // FIXME: Args[1] is a dummy padding field
+
+ if (Args.size() < 6) throw std::string("Invalid invoke instruction!");
+ if (Args[2] != Type::LabelTyID || Args[4] != Type::LabelTyID)
throw std::string("Invalid invoke instruction!");
- Normal = getBasicBlock(args[1]);
- Except = getBasicBlock(args[3]);
+ Normal = getBasicBlock(Args[3]);
+ Except = getBasicBlock(Args[5]);
- if ((args.size() & 1) != 0) // Must be pairs of type/value
+ if (Args.size() & 1) // Must be pairs of type/value
throw std::string("Invalid invoke instruction!");
- for (unsigned i = 4; i < args.size(); i += 2)
- Params.push_back(getValue(args[i], args[i+1]));
+ for (unsigned i = 6; i < Args.size(); i += 2)
+ Params.push_back(getValue(Args[i], Args[i+1]));
}
- if (Raw->NumOperands > 3)
- delete Raw->VarArgs;
return new InvokeInst(F, Normal, Except, Params);
}
case Instruction::Malloc:
- if (Raw->NumOperands > 2) throw std::string("Invalid malloc instruction!");
- if (!isa<PointerType>(Raw->Ty))
+ if (Args.size() > 2) throw std::string("Invalid malloc instruction!");
+ if (!isa<PointerType>(InstTy))
throw std::string("Invalid malloc instruction!");
- return new MallocInst(cast<PointerType>(Raw->Ty)->getElementType(),
- Raw->NumOperands ? getValue(Type::UIntTyID,
- Raw->Arg1) : 0);
+ return new MallocInst(cast<PointerType>(InstTy)->getElementType(),
+ Args.size() ? getValue(Type::UIntTyID,
+ Args[0]) : 0);
case Instruction::Alloca:
- if (Raw->NumOperands > 2) throw std::string("Invalid alloca instruction!");
- if (!isa<PointerType>(Raw->Ty))
+ if (Args.size() > 2) throw std::string("Invalid alloca instruction!");
+ if (!isa<PointerType>(InstTy))
throw std::string("Invalid alloca instruction!");
- return new AllocaInst(cast<PointerType>(Raw->Ty)->getElementType(),
- Raw->NumOperands ? getValue(Type::UIntTyID,
- Raw->Arg1) : 0);
+ return new AllocaInst(cast<PointerType>(InstTy)->getElementType(),
+ Args.size() ? getValue(Type::UIntTyID,
+ Args[0]) : 0);
case Instruction::Free:
- if (!isa<PointerType>(Raw->Ty))
+ if (!isa<PointerType>(InstTy))
throw std::string("Invalid free instruction!");
- return new FreeInst(getValue(Raw->Ty, Raw->Arg1));
+ return new FreeInst(getValue(InstTy, Args[0]));
case Instruction::GetElementPtr: {
- std::vector<Value*> Idx;
- if (!isa<PointerType>(Raw->Ty))
+ if (Args.size() == 0 || !isa<PointerType>(InstTy))
throw std::string("Invalid getelementptr instruction!");
- const CompositeType *TopTy = dyn_cast<CompositeType>(Raw->Ty);
- switch (Raw->NumOperands) {
- case 0: throw std::string("Invalid getelementptr instruction!");
- case 1: break;
- case 2:
- if (!TopTy) throw std::string("Invalid getelementptr instruction!");
- Idx.push_back(getValue(TopTy->getIndexType(), Raw->Arg2));
- break;
- case 3: {
- if (!TopTy) throw std::string("Invalid getelementptr instruction!");
- Idx.push_back(getValue(TopTy->getIndexType(), Raw->Arg2));
-
- const Type *ETy = GetElementPtrInst::getIndexedType(TopTy, Idx, true);
- const CompositeType *ElTy = dyn_cast_or_null<CompositeType>(ETy);
- if (!ElTy) throw std::string("Invalid getelementptr instruction!");
+ std::vector<Value*> Idx;
- Idx.push_back(getValue(ElTy->getIndexType(), Raw->Arg3));
- break;
- }
- default:
- if (!TopTy) throw std::string("Invalid getelementptr instruction!");
- Idx.push_back(getValue(TopTy->getIndexType(), Raw->Arg2));
-
- std::vector<unsigned> &args = *Raw->VarArgs;
- for (unsigned i = 0, E = args.size(); i != E; ++i) {
- const Type *ETy = GetElementPtrInst::getIndexedType(Raw->Ty, Idx, true);
- const CompositeType *ElTy = dyn_cast_or_null<CompositeType>(ETy);
- if (!ElTy) throw std::string("Invalid getelementptr instruction!");
- Idx.push_back(getValue(ElTy->getIndexType(), args[i]));
- }
- delete Raw->VarArgs;
- break;
+ const Type *NextTy = InstTy;
+ for (unsigned i = 1, e = Args.size(); i != e; ++i) {
+ const CompositeType *TopTy = dyn_cast_or_null<CompositeType>(NextTy);
+ if (!TopTy) throw std::string("Invalid getelementptr instruction!");
+ Idx.push_back(getValue(TopTy->getIndexType(), Args[i]));
+ NextTy = GetElementPtrInst::getIndexedType(InstTy, Idx, true);
}
- return new GetElementPtrInst(getValue(Raw->Ty, Raw->Arg1), Idx);
+ return new GetElementPtrInst(getValue(InstTy, Args[0]), Idx);
}
case 62: // volatile load
case Instruction::Load:
- if (Raw->NumOperands != 1 || !isa<PointerType>(Raw->Ty))
+ if (Args.size() != 1 || !isa<PointerType>(InstTy))
throw std::string("Invalid load instruction!");
- return new LoadInst(getValue(Raw->Ty, Raw->Arg1), "", Raw->Opcode == 62);
+ return new LoadInst(getValue(InstTy, Args[0]), "", RI.Opcode == 62);
case 63: // volatile store
case Instruction::Store: {
- if (!isa<PointerType>(Raw->Ty) || Raw->NumOperands != 2)
+ if (!isa<PointerType>(InstTy) || Args.size() != 2)
throw std::string("Invalid store instruction!");
- Value *Ptr = getValue(Raw->Ty, Raw->Arg2);
+ Value *Ptr = getValue(InstTy, Args[1]);
const Type *ValTy = cast<PointerType>(Ptr->getType())->getElementType();
- return new StoreInst(getValue(ValTy, Raw->Arg1), Ptr, Raw->Opcode == 63);
+ return new StoreInst(getValue(ValTy, Args[0]), Ptr, RI.Opcode == 63);
}
case Instruction::Unwind:
- if (Raw->NumOperands != 0) throw std::string("Invalid unwind instruction!");
+ if (Args.size() != 0) throw std::string("Invalid unwind instruction!");
return new UnwindInst();
- } // end switch(Raw->Opcode)
+ } // end switch(RI.Opcode)
- std::cerr << "Unrecognized instruction! " << Raw->Opcode
+ std::cerr << "Unrecognized instruction! " << RI.Opcode
<< " ADDR = 0x" << (void*)Buf << "\n";
throw std::string("Unrecognized instruction!");
}
Index: llvm/lib/Bytecode/Reader/Reader.cpp
diff -u llvm/lib/Bytecode/Reader/Reader.cpp:1.73 llvm/lib/Bytecode/Reader/Reader.cpp:1.74
--- llvm/lib/Bytecode/Reader/Reader.cpp:1.73 Thu Oct 9 13:25:19 2003
+++ llvm/lib/Bytecode/Reader/Reader.cpp Thu Oct 9 15:22:47 2003
@@ -49,17 +49,15 @@
}
const Type *BytecodeParser::getType(unsigned ID) {
- if (ID < Type::NumPrimitiveIDs) {
- const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID);
- if (T) return T;
- }
+ if (ID < Type::NumPrimitiveIDs)
+ if (const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID))
+ return T;
//cerr << "Looking up Type ID: " << ID << "\n";
- if (ID < Type::NumPrimitiveIDs) {
- const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID);
- if (T) return T; // Asked for a primitive type...
- }
+ if (ID < Type::NumPrimitiveIDs)
+ if (const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID))
+ return T; // Asked for a primitive type...
// Otherwise, derived types need offset...
ID -= FirstDerivedTyID;
@@ -73,10 +71,10 @@
if (ID < FunctionTypeValues.size())
return FunctionTypeValues[ID].get();
- return 0;
+ throw std::string("Illegal type reference!");
}
-int BytecodeParser::insertValue(Value *Val, ValueTable &ValueTab) {
+unsigned BytecodeParser::insertValue(Value *Val, ValueTable &ValueTab) {
assert((!HasImplicitZeroInitializer || !isa<Constant>(Val) ||
Val->getType()->isPrimitiveType() ||
!cast<Constant>(Val)->isNullValue()) &&
@@ -200,10 +198,7 @@
while (Buf < EndBuf) {
Instruction *Inst = ParseInstruction(Buf, EndBuf);
- if (insertValue(Inst, Values) == -1) {
- throw std::string("Could not insert value.");
- }
-
+ insertValue(Inst, Values);
BB->getInstList().push_back(Inst);
BCR_TRACE(4, Inst);
}
@@ -221,9 +216,7 @@
if (read_vbr(Buf, EndBuf, NumEntries) ||
read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
const Type *Ty = getType(Typ);
- if (Ty == 0) throw std::string("Invalid type read in symbol table.");
-
- BCR_TRACE(3, "Plane Type: '" << Ty << "' with " << NumEntries <<
+ BCR_TRACE(3, "Plane Type: '" << *Ty << "' with " << NumEntries <<
" entries\n");
for (unsigned i = 0; i < NumEntries; ++i) {
@@ -328,10 +321,8 @@
const FunctionType::ParamTypes &Params =F->getFunctionType()->getParamTypes();
Function::aiterator AI = F->abegin();
for (FunctionType::ParamTypes::const_iterator It = Params.begin();
- It != Params.end(); ++It, ++AI) {
- if (insertValue(AI, Values) == -1)
- throw std::string("Error reading function arguments!");
- }
+ It != Params.end(); ++It, ++AI)
+ insertValue(AI, Values);
// Keep track of how many basic blocks we have read in...
unsigned BlockNum = 0;
@@ -435,7 +426,7 @@
}
const Type *Ty = getType(SlotNo);
- if (!Ty || !isa<PointerType>(Ty))
+ if (!isa<PointerType>(Ty))
throw std::string("Global not pointer type! Ty = " +
Ty->getDescription());
@@ -444,10 +435,8 @@
// Create the global variable...
GlobalVariable *GV = new GlobalVariable(ElTy, VarType & 1, Linkage,
0, "", TheModule);
- int DestSlot = insertValue(GV, ModuleValues);
- if (DestSlot == -1) throw Error_DestSlot;
BCR_TRACE(2, "Global Variable of type: " << *Ty << "\n");
- ResolveReferencesToValue(GV, (unsigned)DestSlot);
+ ResolveReferencesToValue(GV, insertValue(GV, ModuleValues));
if (VarType & 2) { // Does it have an initializer?
unsigned InitSlot;
@@ -462,11 +451,10 @@
if (read_vbr(Buf, End, FnSignature)) throw Error_readvbr;
while (FnSignature != Type::VoidTyID) { // List is terminated by Void
const Type *Ty = getType(FnSignature);
- if (!Ty || !isa<PointerType>(Ty) ||
- !isa<FunctionType>(cast<PointerType>(Ty)->getElementType())) {
+ if (!isa<PointerType>(Ty) ||
+ !isa<FunctionType>(cast<PointerType>(Ty)->getElementType()))
throw std::string("Function not ptr to func type! Ty = " +
Ty->getDescription());
- }
// We create functions by passing the underlying FunctionType to create...
Ty = cast<PointerType>(Ty)->getElementType();
@@ -479,9 +467,8 @@
// Insert the placeholder...
Function *Func = new Function(cast<FunctionType>(Ty),
GlobalValue::InternalLinkage, "", TheModule);
- int DestSlot = insertValue(Func, ModuleValues);
- if (DestSlot == -1) throw Error_DestSlot;
- ResolveReferencesToValue(Func, (unsigned)DestSlot);
+ unsigned DestSlot = insertValue(Func, ModuleValues);
+ ResolveReferencesToValue(Func, DestSlot);
// Keep track of this information in a list that is emptied as functions are
// loaded...
Index: llvm/lib/Bytecode/Reader/ReaderInternals.h
diff -u llvm/lib/Bytecode/Reader/ReaderInternals.h:1.54 llvm/lib/Bytecode/Reader/ReaderInternals.h:1.55
--- llvm/lib/Bytecode/Reader/ReaderInternals.h:1.54 Thu Oct 9 13:25:19 2003
+++ llvm/lib/Bytecode/Reader/ReaderInternals.h Thu Oct 9 15:22:47 2003
@@ -14,8 +14,6 @@
#include "llvm/Bytecode/Primitives.h"
#include <utility>
#include <map>
-#include <memory>
-class Module;
// Enable to trace to figure out what the heck is going on when parsing fails
//#define TRACE_LEVEL 10
@@ -27,17 +25,6 @@
#define BCR_TRACE(n, X)
#endif
-struct RawInst { // The raw fields out of the bytecode stream...
- unsigned NumOperands;
- unsigned Opcode;
- const Type *Ty;
- unsigned Arg1, Arg2;
- union {
- unsigned Arg3;
- std::vector<unsigned> *VarArgs; // Contains arg #3,4,5... if NumOperands > 3
- };
-};
-
struct LazyFunctionInfo {
const unsigned char *Buf, *EndBuf;
unsigned FunctionSlot;
@@ -62,11 +49,9 @@
Module* releaseModule() {
// Since we're losing control of this Module, we must hand it back complete
- materializeModule();
+ Module *M = ModuleProvider::releaseModule();
freeState();
- Module *tempM = TheModule;
- TheModule = 0;
- return tempM;
+ return M;
}
void ParseBytecode(const unsigned char *Buf, unsigned Length,
@@ -165,8 +150,6 @@
Instruction *ParseInstruction(const unsigned char *&Buf,
const unsigned char *End);
- std::auto_ptr<RawInst> ParseRawInst(const unsigned char *&Buf,
- const unsigned char *End);
void ParseConstantPool(const unsigned char *&Buf, const unsigned char *EndBuf,
ValueTable &Tab, TypeValuesListTy &TypeTab);
@@ -185,7 +168,7 @@
BasicBlock *getBasicBlock(unsigned ID);
Constant *getConstantValue(const Type *Ty, unsigned num);
- int insertValue(Value *V, ValueTable &Table); // -1 = Failure
+ unsigned insertValue(Value *V, ValueTable &Table);
unsigned getTypeSlot(const Type *Ty);
More information about the llvm-commits
mailing list