From 927b185c175a8eb6d64ea97e1735fc6102114766 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 9 Oct 2003 20:22:47 +0000 Subject: [PATCH] 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. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8984 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Bytecode/Reader/ConstantReader.cpp | 32 +- lib/Bytecode/Reader/InstructionReader.cpp | 382 ++++++++-------------- lib/Bytecode/Reader/Reader.cpp | 49 +-- lib/Bytecode/Reader/ReaderInternals.h | 23 +- 4 files changed, 171 insertions(+), 315 deletions(-) diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp index 2f0e0b8e0f5..4b6e998fed1 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 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 aee6ba34f49..b085581c60e 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 -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 &Args); + +}; + + + +RawInst::RawInst(const unsigned char *&Buf, const unsigned char *EndBuf, + std::vector &Args) { unsigned Op, Typ; - std::auto_ptr Result = std::auto_ptr(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(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 Raw = ParseRawInst(Buf, EndBuf); + std::vector 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 &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 &args = *Raw->VarArgs; - for (unsigned i = 0; i < args.size(); i += 2) - I->addCase(cast(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(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(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 &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 &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(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 Params; - const FunctionType::ParamTypes &PL = FTy->getParamTypes(); - std::vector &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(Raw->Ty)) + if (Args.size() > 2) throw std::string("Invalid malloc instruction!"); + if (!isa(InstTy)) throw std::string("Invalid malloc instruction!"); - return new MallocInst(cast(Raw->Ty)->getElementType(), - Raw->NumOperands ? getValue(Type::UIntTyID, - Raw->Arg1) : 0); + return new MallocInst(cast(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(Raw->Ty)) + if (Args.size() > 2) throw std::string("Invalid alloca instruction!"); + if (!isa(InstTy)) throw std::string("Invalid alloca instruction!"); - return new AllocaInst(cast(Raw->Ty)->getElementType(), - Raw->NumOperands ? getValue(Type::UIntTyID, - Raw->Arg1) : 0); + return new AllocaInst(cast(InstTy)->getElementType(), + Args.size() ? getValue(Type::UIntTyID, + Args[0]) : 0); case Instruction::Free: - if (!isa(Raw->Ty)) + if (!isa(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 Idx; - if (!isa(Raw->Ty)) + if (Args.size() == 0 || !isa(InstTy)) throw std::string("Invalid getelementptr instruction!"); - const CompositeType *TopTy = dyn_cast(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(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 &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(ETy); - if (!ElTy) throw std::string("Invalid getelementptr instruction!"); - Idx.push_back(getValue(ElTy->getIndexType(), args[i])); - } - delete Raw->VarArgs; - break; + + std::vector Idx; + + const Type *NextTy = InstTy; + for (unsigned i = 1, e = Args.size(); i != e; ++i) { + const CompositeType *TopTy = dyn_cast_or_null(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(Raw->Ty)) + if (Args.size() != 1 || !isa(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(Raw->Ty) || Raw->NumOperands != 2) + if (!isa(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(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 67726eb2c11..e649cdc08f1 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(Val) || Val->getType()->isPrimitiveType() || !cast(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(Ty)) + if (!isa(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(Ty) || - !isa(cast(Ty)->getElementType())) { + if (!isa(Ty) || + !isa(cast(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(Ty)->getElementType(); @@ -479,9 +467,8 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf, // Insert the placeholder... Function *Func = new Function(cast(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 42f7e1b4630..1fefe23fafb 100644 --- a/lib/Bytecode/Reader/ReaderInternals.h +++ b/lib/Bytecode/Reader/ReaderInternals.h @@ -14,8 +14,6 @@ #include "llvm/Bytecode/Primitives.h" #include #include -#include -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 *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 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); -- 2.34.1