aboutsummaryrefslogtreecommitdiff
path: root/lib/Bytecode
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Bytecode')
-rw-r--r--lib/Bytecode/Reader/ConstantReader.cpp32
-rw-r--r--lib/Bytecode/Reader/InstructionReader.cpp382
-rw-r--r--lib/Bytecode/Reader/Reader.cpp49
-rw-r--r--lib/Bytecode/Reader/ReaderInternals.h23
4 files changed, 171 insertions, 315 deletions
diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp
index 2f0e0b8e0f..4b6e998fed 100644
--- a/lib/Bytecode/Reader/ConstantReader.cpp
+++ b/lib/Bytecode/Reader/ConstantReader.cpp
@@ -27,7 +27,6 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
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 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
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 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
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 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
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 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
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 @@ Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
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 @@ void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
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);
}
}
}
diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp
index aee6ba34f4..b085581c60 100644
--- a/lib/Bytecode/Reader/InstructionReader.cpp
+++ b/lib/Bytecode/Reader/InstructionReader.cpp
@@ -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 @@ BytecodeParser::ParseRawInst(const unsigned char *&Buf,
// --------------------------
// 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 @@ BytecodeParser::ParseRawInst(const unsigned char *&Buf,
// 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 @@ BytecodeParser::ParseRawInst(const unsigned char *&Buf,
// 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 (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));
+ 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]));
- 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 @@ Instruction *BytecodeParser::ParseInstruction(const unsigned char *&Buf,
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 @@ Instruction *BytecodeParser::ParseInstruction(const unsigned char *&Buf,
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(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!");
+ Normal = getBasicBlock(Args[1]);
+ Except = getBasicBlock(Args[2]);
+
+ 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!");
-
- 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;
+
+ std::vector<Value*> Idx;
+
+ 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!");
}
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index 67726eb2c1..e649cdc08f 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -49,17 +49,15 @@ unsigned BytecodeParser::getTypeSlot(const Type *Ty) {
}
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 @@ const Type *BytecodeParser::getType(unsigned ID) {
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 @@ BasicBlock *BytecodeParser::ParseBasicBlock(const unsigned char *&Buf,
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 @@ void BytecodeParser::ParseSymbolTable(const unsigned char *&Buf,
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 @@ void BytecodeParser::materializeFunction(Function* F) {
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 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
}
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 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
// 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 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
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 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
// 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...
diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h
index 42f7e1b463..1fefe23faf 100644
--- a/lib/Bytecode/Reader/ReaderInternals.h
+++ b/lib/Bytecode/Reader/ReaderInternals.h
@@ -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 @@ class Module;
#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 @@ public:
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 @@ private:
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 @@ private:
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);
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-06-23 03:14:20 +0000