diff options
| -rw-r--r-- | llvm/include/llvm/Bitcode/ReaderWriter.h | 32 | ||||
| -rw-r--r-- | llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 495 | ||||
| -rw-r--r-- | llvm/lib/Bitcode/Reader/BitcodeReader.h | 29 |
3 files changed, 280 insertions, 276 deletions
diff --git a/llvm/include/llvm/Bitcode/ReaderWriter.h b/llvm/include/llvm/Bitcode/ReaderWriter.h index 8cf573544f8..ebb30ec01f3 100644 --- a/llvm/include/llvm/Bitcode/ReaderWriter.h +++ b/llvm/include/llvm/Bitcode/ReaderWriter.h @@ -139,6 +139,38 @@ namespace llvm { BufEnd = BufPtr+Size; return false; } + + const std::error_category &BitcodeErrorCategory(); + enum class BitcodeError { + BitcodeStreamInvalidSize, + ConflictingMETADATA_KINDRecords, + CouldNotFindFunctionInStream, + ExpectedConstant, + InsufficientFunctionProtos, + InvalidBitcodeSignature, + InvalidBitcodeWrapperHeader, + InvalidConstantReference, + InvalidID, // A read identifier is not found in the table it should be in. + InvalidInstructionWithNoBB, + InvalidRecord, // A read record doesn't have the expected size or structure + InvalidTypeForValue, // Type read OK, but is invalid for its use + InvalidTYPETable, + InvalidType, // We were unable to read a type + MalformedBlock, // We are unable to advance in the stream. + MalformedGlobalInitializerSet, + InvalidMultipleBlocks, // We found multiple blocks of a kind that should + // have only one + NeverResolvedValueFoundInFunction, + InvalidValue // Invalid version, inst number, attr number, etc + }; + inline std::error_code make_error_code(BitcodeError E) { + return std::error_code(static_cast<int>(E), BitcodeErrorCategory()); + } + } // End llvm namespace +namespace std { +template <> struct is_error_code_enum<llvm::BitcodeError> : std::true_type {}; +} + #endif diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 806a8a9fd07..ce66a3d0c78 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -487,10 +487,10 @@ static void decodeLLVMAttributesForBitcode(AttrBuilder &B, std::error_code BitcodeReader::ParseAttributeBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!MAttributes.empty()) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; @@ -503,7 +503,7 @@ std::error_code BitcodeReader::ParseAttributeBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -519,7 +519,7 @@ std::error_code BitcodeReader::ParseAttributeBlock() { case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] // FIXME: Remove in 4.0. if (Record.size() & 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0, e = Record.size(); i != e; i += 2) { AttrBuilder B; @@ -637,16 +637,16 @@ std::error_code BitcodeReader::ParseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) { *Kind = GetAttrFromCode(Code); if (*Kind == Attribute::None) - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); return std::error_code(); } std::error_code BitcodeReader::ParseAttributeGroupBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!MAttributeGroups.empty()) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; @@ -657,7 +657,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -672,7 +672,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { break; case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); uint64_t GrpID = Record[0]; uint64_t Idx = Record[1]; // Index of the object this attribute refers to. @@ -727,14 +727,14 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { std::error_code BitcodeReader::ParseTypeTable() { if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); return ParseTypeTableBody(); } std::error_code BitcodeReader::ParseTypeTableBody() { if (!TypeList.empty()) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); SmallVector<uint64_t, 64> Record; unsigned NumRecords = 0; @@ -748,10 +748,10 @@ std::error_code BitcodeReader::ParseTypeTableBody() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: if (NumRecords != TypeList.size()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); return std::error_code(); case BitstreamEntry::Record: // The interesting case. @@ -763,12 +763,12 @@ std::error_code BitcodeReader::ParseTypeTableBody() { Type *ResultTy = nullptr; switch (Stream.readRecord(Entry.ID, Record)) { default: - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] // TYPE_CODE_NUMENTRY contains a count of the number of types in the // type list. This allows us to reserve space. if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TypeList.resize(Record[0]); continue; case bitc::TYPE_CODE_VOID: // VOID @@ -803,20 +803,20 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); ResultTy = IntegerType::get(Context, Record[0]); break; case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or // [pointee type, address space] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned AddressSpace = 0; if (Record.size() == 2) AddressSpace = Record[1]; ResultTy = getTypeByID(Record[0]); if (!ResultTy) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = PointerType::get(ResultTy, AddressSpace); break; } @@ -824,7 +824,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { // FIXME: attrid is dead, remove it in LLVM 4.0 // FUNCTION: [vararg, attrid, retty, paramty x N] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Type*, 8> ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -835,7 +835,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[2]); if (!ResultTy || ArgTys.size() < Record.size()-3) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; @@ -843,7 +843,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { case bitc::TYPE_CODE_FUNCTION: { // FUNCTION: [vararg, retty, paramty x N] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Type*, 8> ArgTys; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -854,14 +854,14 @@ std::error_code BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[1]); if (!ResultTy || ArgTys.size() < Record.size()-2) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; } case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Type*, 8> EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -870,21 +870,21 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error(InvalidType); + return Error(BitcodeError::InvalidType); ResultTy = StructType::get(Context, EltTys, Record[0]); break; } case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] if (ConvertToString(Record, 0, TypeName)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); continue; case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (NumRecords >= TypeList.size()) - return Error(InvalidTYPETable); + return Error(BitcodeError::InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -903,17 +903,17 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Res->setBody(EltTys, Record[0]); ResultTy = Res; break; } case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] if (Record.size() != 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (NumRecords >= TypeList.size()) - return Error(InvalidTYPETable); + return Error(BitcodeError::InvalidTYPETable); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -928,24 +928,24 @@ std::error_code BitcodeReader::ParseTypeTableBody() { } case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = ArrayType::get(ResultTy, Record[0]); else - return Error(InvalidType); + return Error(BitcodeError::InvalidType); break; case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = VectorType::get(ResultTy, Record[0]); else - return Error(InvalidType); + return Error(BitcodeError::InvalidType); break; } if (NumRecords >= TypeList.size()) - return Error(InvalidTYPETable); + return Error(BitcodeError::InvalidTYPETable); assert(ResultTy && "Didn't read a type?"); assert(!TypeList[NumRecords] && "Already read type?"); TypeList[NumRecords++] = ResultTy; @@ -954,7 +954,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { std::error_code BitcodeReader::ParseValueSymbolTable() { if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -966,7 +966,7 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -981,10 +981,10 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { break; case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] if (ConvertToString(Record, 1, ValueName)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ValueID = Record[0]; if (ValueID >= ValueList.size() || !ValueList[ValueID]) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Value *V = ValueList[ValueID]; V->setName(StringRef(ValueName.data(), ValueName.size())); @@ -993,10 +993,10 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { } case bitc::VST_CODE_BBENTRY: { if (ConvertToString(Record, 1, ValueName)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); BasicBlock *BB = getBasicBlock(Record[0]); if (!BB) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); @@ -1010,7 +1010,7 @@ std::error_code BitcodeReader::ParseMetadata() { unsigned NextMDValueNo = MDValueList.size(); if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1021,7 +1021,7 @@ std::error_code BitcodeReader::ParseMetadata() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -1052,7 +1052,7 @@ std::error_code BitcodeReader::ParseMetadata() { for (unsigned i = 0; i != Size; ++i) { MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i])); if (!MD) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); NMD->addOperand(MD); } break; @@ -1062,14 +1062,14 @@ std::error_code BitcodeReader::ParseMetadata() { // fall-through case bitc::METADATA_NODE: { if (Record.size() % 2 == 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Size = Record.size(); SmallVector<Value*, 8> Elts; for (unsigned i = 0; i != Size; i += 2) { Type *Ty = getTypeByID(Record[i]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Ty->isMetadataTy()) Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); else if (!Ty->isVoidTy()) @@ -1091,14 +1091,14 @@ std::error_code BitcodeReader::ParseMetadata() { } case bitc::METADATA_KIND: { if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Kind = Record[0]; SmallString<8> Name(Record.begin()+1, Record.end()); unsigned NewKind = TheModule->getMDKindID(Name.str()); if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) - return Error(ConflictingMETADATA_KINDRecords); + return Error(BitcodeError::ConflictingMETADATA_KINDRecords); break; } } @@ -1136,7 +1136,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) GlobalInitWorklist.back().first->setInitializer(C); else - return Error(ExpectedConstant); + return Error(BitcodeError::ExpectedConstant); } GlobalInitWorklist.pop_back(); } @@ -1149,7 +1149,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) AliasInitWorklist.back().first->setAliasee(C); else - return Error(ExpectedConstant); + return Error(BitcodeError::ExpectedConstant); } AliasInitWorklist.pop_back(); } @@ -1162,7 +1162,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) FunctionPrefixWorklist.back().first->setPrefixData(C); else - return Error(ExpectedConstant); + return Error(BitcodeError::ExpectedConstant); } FunctionPrefixWorklist.pop_back(); } @@ -1180,7 +1180,7 @@ static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { std::error_code BitcodeReader::ParseConstants() { if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -1193,10 +1193,10 @@ std::error_code BitcodeReader::ParseConstants() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: if (NextCstNo != ValueList.size()) - return Error(InvalidConstantReference); + return Error(BitcodeError::InvalidConstantReference); // Once all the constants have been read, go through and resolve forward // references. @@ -1218,9 +1218,9 @@ std::error_code BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); CurTy = TypeList[Record[0]]; continue; // Skip the ValueList manipulation. case bitc::CST_CODE_NULL: // NULL @@ -1228,12 +1228,12 @@ std::error_code BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_INTEGER: // INTEGER: [intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); break; case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); APInt VInt = ReadWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth()); @@ -1243,7 +1243,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (CurTy->isHalfTy()) V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, APInt(16, (uint16_t)Record[0]))); @@ -1273,7 +1273,7 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Size = Record.size(); SmallVector<Constant*, 16> Elts; @@ -1301,7 +1301,7 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_STRING: // STRING: [values] case bitc::CST_CODE_CSTRING: { // CSTRING: [values] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallString<16> Elts(Record.begin(), Record.end()); V = ConstantDataArray::getString(Context, Elts, @@ -1310,7 +1310,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_DATA: {// DATA: [n x value] if (Record.empty()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); unsigned Size = Record.size(); @@ -1355,14 +1355,14 @@ std::error_code BitcodeReader::ParseConstants() { else V = ConstantDataArray::get(Context, Elts); } else { - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); } break; } case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown binop. @@ -1393,14 +1393,14 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedCastOpcode(Record[0]); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown cast. } else { Type *OpTy = getTypeByID(Record[1]); if (!OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); V = UpgradeBitCastExpr(Opc, Op, CurTy); if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); @@ -1410,12 +1410,12 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_INBOUNDS_GEP: case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] if (Record.size() & 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Constant*, 16> Elts; for (unsigned i = 0, e = Record.size(); i != e; i += 2) { Type *ElTy = getTypeByID(Record[i]); if (!ElTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); } ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); @@ -1426,7 +1426,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *SelectorTy = Type::getInt1Ty(Context); @@ -1445,22 +1445,22 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_EXTRACTELT : { // CE_EXTRACTELT: [opty, opval, opty, opval] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (!OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = nullptr; if (Record.size() == 4) { Type *IdxTy = getTypeByID(Record[2]); if (!IdxTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy); } else // TODO: Remove with llvm 4.0 Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); if (!Op1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); V = ConstantExpr::getExtractElement(Op0, Op1); break; } @@ -1468,7 +1468,7 @@ std::error_code BitcodeReader::ParseConstants() { : { // CE_INSERTELT: [opval, opval, opty, opval] VectorType *OpTy = dyn_cast<VectorType>(CurTy); if (Record.size() < 3 || !OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy->getElementType()); @@ -1476,19 +1476,19 @@ std::error_code BitcodeReader::ParseConstants() { if (Record.size() == 4) { Type *IdxTy = getTypeByID(Record[2]); if (!IdxTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy); } else // TODO: Remove with llvm 4.0 Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); if (!Op2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); V = ConstantExpr::getInsertElement(Op0, Op1, Op2); break; } case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] VectorType *OpTy = dyn_cast<VectorType>(CurTy); if (Record.size() < 3 || !OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1502,7 +1502,7 @@ std::error_code BitcodeReader::ParseConstants() { VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (Record.size() < 4 || !RTy || !OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1513,10 +1513,10 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] if (Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); if (!OpTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); @@ -1530,16 +1530,16 @@ std::error_code BitcodeReader::ParseConstants() { // FIXME: Remove with the 4.0 release. case bitc::CST_CODE_INLINEASM_OLD: { if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); std::string AsmStr, ConstrStr; bool HasSideEffects = Record[0] & 1; bool IsAlignStack = Record[0] >> 1; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1554,17 +1554,17 @@ std::error_code BitcodeReader::ParseConstants() { // inteldialect). case bitc::CST_CODE_INLINEASM: { if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); std::string AsmStr, ConstrStr; bool HasSideEffects = Record[0] & 1; bool IsAlignStack = (Record[0] >> 1) & 1; unsigned AsmDialect = Record[0] >> 2; unsigned AsmStrSize = Record[1]; if (2+AsmStrSize >= Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1578,14 +1578,14 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_BLOCKADDRESS:{ if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *FnTy = getTypeByID(Record[0]); if (!FnTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Function *Fn = dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); if (!Fn) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // If the function is already parsed we can insert the block address right // away. @@ -1593,7 +1593,7 @@ std::error_code BitcodeReader::ParseConstants() { Function::iterator BBI = Fn->begin(), BBE = Fn->end(); for (size_t I = 0, E = Record[2]; I != E; ++I) { if (BBI == BBE) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); ++BBI; } V = BlockAddress::get(Fn, BBI); @@ -1618,7 +1618,7 @@ std::error_code BitcodeReader::ParseConstants() { std::error_code BitcodeReader::ParseUseLists() { if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Read all the records. SmallVector<uint64_t, 64> Record; @@ -1628,7 +1628,7 @@ std::error_code BitcodeReader::ParseUseLists() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -1649,7 +1649,7 @@ std::error_code BitcodeReader::ParseUseLists() { unsigned RecordLength = Record.size(); if (RecordLength < 3) // Records should have at least an ID and two indexes. - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned ID = Record.back(); Record.pop_back(); @@ -1686,7 +1686,7 @@ std::error_code BitcodeReader::ParseUseLists() { std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Get the function we are talking about. if (FunctionsWithBodies.empty()) - return Error(InsufficientFunctionProtos); + return Error(BitcodeError::InsufficientFunctionProtos); Function *Fn = FunctionsWithBodies.back(); FunctionsWithBodies.pop_back(); @@ -1697,7 +1697,7 @@ std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Skip over the function block for now. if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); return std::error_code(); } @@ -1705,7 +1705,7 @@ std::error_code BitcodeReader::GlobalCleanup() { // Patch the initializers for globals and aliases up. ResolveGlobalAndAliasInits(); if (!GlobalInits.empty() || !AliasInits.empty()) - return Error(MalformedGlobalInitializerSet); + return Error(BitcodeError::MalformedGlobalInitializerSet); // Look for intrinsic functions which need to be upgraded at some point for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); @@ -1734,7 +1734,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { if (Resume) Stream.JumpToBit(NextUnreadBit); else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; std::vector<std::string> SectionTable; @@ -1746,7 +1746,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return GlobalCleanup(); @@ -1754,11 +1754,11 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); break; case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); break; case bitc::PARAMATTR_BLOCK_ID: if (std::error_code EC = ParseAttributeBlock()) @@ -1828,12 +1828,12 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { default: break; // Default behavior, ignore unknown content. case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] if (Record.size() < 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Only version #0 and #1 are supported so far. unsigned module_version = Record[0]; switch (module_version) { default: - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); case 0: UseRelativeIDs = false; break; @@ -1846,21 +1846,21 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TheModule->setTargetTriple(S); break; } case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TheModule->setDataLayout(S); break; } case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); TheModule->setModuleInlineAsm(S); break; } @@ -1868,27 +1868,27 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // FIXME: Remove in 4.0. std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Ignore value. break; } case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SectionTable.push_back(S); break; } case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); GCTable.push_back(S); break; } case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]); unsigned ComdatNameSize = Record[1]; std::string ComdatName; @@ -1905,12 +1905,12 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // unnamed_addr, dllstorageclass] case bitc::MODULE_CODE_GLOBALVAR: { if (Record.size() < 6) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!Ty->isPointerTy()) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); Ty = cast<PointerType>(Ty)->getElementType(); @@ -1920,7 +1920,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { std::string Section; if (Record[5]) { if (Record[5]-1 >= SectionTable.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Section = SectionTable[Record[5]-1]; } GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; @@ -1973,16 +1973,16 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // dllstorageclass] case bitc::MODULE_CODE_FUNCTION: { if (Record.size() < 8) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (!Ty->isPointerTy()) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); FunctionType *FTy = dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); if (!FTy) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); @@ -1995,7 +1995,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { Func->setAlignment((1 << Record[5]) >> 1); if (Record[6]) { if (Record[6]-1 >= SectionTable.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Func->setSection(SectionTable[Record[6]-1]); } // Local linkage must have default visibility. @@ -2004,7 +2004,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { Func->setVisibility(GetDecodedVisibility(Record[7])); if (Record.size() > 8 && Record[8]) { if (Record[8]-1 > GCTable.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Func->setGC(GCTable[Record[8]-1].c_str()); } bool UnnamedAddr = false; @@ -2039,13 +2039,13 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass] case bitc::MODULE_CODE_ALIAS: { if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); auto *PTy = dyn_cast<PointerType>(Ty); if (!PTy) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); auto *NewGA = GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), @@ -2071,7 +2071,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { case bitc::MODULE_CODE_PURGEVALS: // Trim down the value list to the specified size. if (Record.size() < 1 || Record[0] > ValueList.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); ValueList.shrinkTo(Record[0]); break; } @@ -2092,7 +2092,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -2105,7 +2105,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); @@ -2113,12 +2113,12 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { switch (Entry.ID) { case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); break; case bitc::MODULE_BLOCK_ID: // Reject multiple MODULE_BLOCK's in a single bitstream. if (TheModule) - return Error(InvalidMultipleBlocks); + return Error(BitcodeError::InvalidMultipleBlocks); TheModule = M; if (std::error_code EC = ParseModule(false)) return EC; @@ -2127,7 +2127,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { break; default: if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); break; } continue; @@ -2142,14 +2142,14 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { Stream.AtEndOfStream()) return std::error_code(); - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } } } ErrorOr<std::string> BitcodeReader::parseModuleTriple() { if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; @@ -2161,7 +2161,7 @@ ErrorOr<std::string> BitcodeReader::parseModuleTriple() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return Triple; case BitstreamEntry::Record: @@ -2175,7 +2175,7 @@ ErrorOr<std::string> BitcodeReader::parseModuleTriple() { case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Triple = S; break; } @@ -2196,7 +2196,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -2205,7 +2205,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); @@ -2215,7 +2215,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { // Ignore other sub-blocks. if (Stream.SkipBlock()) - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); continue; case BitstreamEntry::Record: @@ -2228,7 +2228,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { /// ParseMetadataAttachment - Parse metadata attachments. std::error_code BitcodeReader::ParseMetadataAttachment() { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<uint64_t, 64> Record; while (1) { @@ -2237,7 +2237,7 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -2253,14 +2253,14 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { case bitc::METADATA_ATTACHMENT: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Instruction *Inst = InstructionList[Record[0]]; for (unsigned i = 1; i != RecordLength; i = i+2) { unsigned Kind = Record[i]; DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind); if (I == MDKindMap.end()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); Value *Node = MDValueList.getValueFwdRef(Record[i+1]); Inst->setMetadata(I->second, cast<MDNode>(Node)); if (I->second == LLVMContext::MD_tbaa) @@ -2275,7 +2275,7 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { /// ParseFunctionBody - Lazily parse the specified function body block. std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); InstructionList.clear(); unsigned ModuleValueListSize = ValueList.size(); @@ -2298,7 +2298,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(MalformedBlock); + return Error(BitcodeError::MalformedBlock); case BitstreamEntry::EndBlock: goto OutOfRecordLoop; @@ -2306,7 +2306,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); break; case bitc::CONSTANTS_BLOCK_ID: if (std::error_code EC = ParseConstants()) @@ -2343,10 +2343,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: reject - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] if (Record.size() < 1 || Record[0] == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // Create all the basic blocks for the function. FunctionBBs.resize(Record[0]); for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) @@ -2367,7 +2367,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { I = &FunctionBBs[CurBBNo-1]->back(); if (!I) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I->setDebugLoc(LastLoc); I = nullptr; continue; @@ -2380,7 +2380,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { !FunctionBBs[CurBBNo-1]->empty()) I = &FunctionBBs[CurBBNo-1]->back(); if (!I || Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned Line = Record[0], Col = Record[1]; unsigned ScopeID = Record[2], IAID = Record[3]; @@ -2400,11 +2400,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 > Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); if (Opc == -1) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); InstructionList.push_back(I); if (OpNum < Record.size()) { @@ -2446,12 +2446,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *ResTy = getTypeByID(Record[OpNum]); int Opc = GetDecodedCastOpcode(Record[OpNum+1]); if (Opc == -1 || !ResTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Instruction *Temp = nullptr; if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { if (Temp) { @@ -2469,13 +2469,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *BasePtr; if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Value*, 16> GEPIdx; while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); GEPIdx.push_back(Op); } @@ -2491,14 +2491,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<unsigned, 4> EXTRACTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); EXTRACTVALIdx.push_back((unsigned)Index); } @@ -2512,17 +2512,17 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Value *Val; if (getValueTypePair(Record, OpNum, NextValueNo, Val)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<unsigned, 4> INSERTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error(InvalidValue); + return Error(BitcodeError::InvalidValue); INSERTVALIdx.push_back((unsigned)Index); } @@ -2539,7 +2539,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = SelectInst::Create(Cond, TrueVal, FalseVal); InstructionList.push_back(I); @@ -2554,18 +2554,18 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || getValueTypePair(Record, OpNum, NextValueNo, Cond)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); // select condition can be either i1 or [N x i1] if (VectorType* vector_type = dyn_cast<VectorType>(Cond->getType())) { // expect <n x i1> if (vector_type->getElementType() != Type::getInt1Ty(Context)) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); } else { // expect i1 if (Cond->getType() != Type::getInt1Ty(Context)) - return Error(InvalidTypeForValue); + return Error(BitcodeError::InvalidTypeForValue); } I = SelectInst::Create(Cond, TrueVal, FalseVal); @@ -2578,7 +2578,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || getValueTypePair(Record, OpNum, NextValueNo, Idx)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = ExtractElementInst::Create(Vec, Idx); InstructionList.push_back(I); break; @@ -2591,7 +2591,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<VectorType>(Vec->getType())->getElementType(), Elt) || getValueTypePair(Record, OpNum, NextValueNo, Idx)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = InsertElementInst::Create(Vec, Elt, Idx); InstructionList.push_back(I); break; @@ -2602,10 +2602,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec1, *Vec2, *Mask; if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new ShuffleVectorInst(Vec1, Vec2, Mask); InstructionList.push_back(I); break; @@ -2623,7 +2623,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || OpNum+1 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (LHS->getType()->isFPOrFPVectorTy()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); @@ -2645,9 +2645,9 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Op = nullptr; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (OpNum != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = ReturnInst::Create(Context, Op); InstructionList.push_back(I); @@ -2655,10 +2655,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] if (Record.size() != 1 && Record.size() != 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); BasicBlock *TrueDest = getBasicBlock(Record[0]); if (!TrueDest) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Record.size() == 1) { I = BranchInst::Create(TrueDest); @@ -2669,7 +2669,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, Type::getInt1Ty(Context)); if (!FalseDest || !Cond) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = BranchInst::Create(TrueDest, FalseDest, Cond); InstructionList.push_back(I); } @@ -2689,7 +2689,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[3]); if (!OpTy || !Cond || !Default) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned NumCases = Record[4]; @@ -2741,12 +2741,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // Old SwitchInst format without case ranges. if (Record.size() < 3 || (Record.size() & 1) == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Cond = getValue(Record, 1, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[2]); if (!OpTy || !Cond || !Default) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned NumCases = (Record.size()-3)/2; SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); InstructionList.push_back(SI); @@ -2756,7 +2756,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); if (!CaseVal || !DestBB) { delete SI; - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } SI->addCase(CaseVal, DestBB); } @@ -2765,11 +2765,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] if (Record.size() < 2) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Address = getValue(Record, 1, NextValueNo, OpTy); if (!OpTy || !Address) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); unsigned NumDests = Record.size()-2; IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); InstructionList.push_back(IBI); @@ -2778,7 +2778,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { IBI->addDestination(DestBB); } else { delete IBI; - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } } I = IBI; @@ -2788,7 +2788,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] if (Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); @@ -2797,7 +2797,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 4; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = !CalleeTy ? nullptr : @@ -2806,25 +2806,25 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // Check that the right number of fixed parameters are here. if (!FTy || !NormalBB || !UnwindBB || Record.size() < OpNum+FTy->getNumParams()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Value*, 16> Ops; for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { Ops.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); if (!Ops.back()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } if (!FTy->isVarArg()) { if (Record.size() != OpNum) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } else { // Read type/value pairs for varargs params. while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Ops.push_back(Op); } } @@ -2840,7 +2840,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned Idx = 0; Value *Val = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, Val)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = ResumeInst::Create(Val); InstructionList.push_back(I); break; @@ -2851,10 +2851,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { break; case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] if (Record.size() < 1 || ((Record.size()-1)&1)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); InstructionList.push_back(PN); @@ -2870,7 +2870,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { V = getValue(Record, 1+i, NextValueNo, Ty); BasicBlock *BB = getBasicBlock(Record[2+i]); if (!V || !BB) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PN->addIncoming(V, BB); } I = PN; @@ -2881,13 +2881,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] unsigned Idx = 0; if (Record.size() < 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *Ty = getTypeByID(Record[Idx++]); if (!Ty) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Value *PersFn = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); bool IsCleanup = !!Record[Idx++]; unsigned NumClauses = Record[Idx++]; @@ -2900,7 +2900,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, Idx, NextValueNo, Val)) { delete LP; - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } assert((CT != LandingPadInst::Catch || @@ -2919,7 +2919,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] if (Record.size() != 4) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PointerType *Ty = dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); Type *OpTy = getTypeByID(Record[1]); @@ -2928,7 +2928,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { bool InAlloca = AlignRecord & (1 << 5); unsigned Align = AlignRecord & ((1 << 5) - 1); if (!Ty || !Size) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AllocaInst *AI = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); AI->setUsedWithInAlloca(InAlloca); I = AI; @@ -2940,7 +2940,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2952,15 +2952,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+4 != Record.size()) - return Error(InvalidRecord); - + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Release || Ordering == AcquireRelease) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, @@ -2975,7 +2974,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -2989,15 +2988,15 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Acquire || Ordering == AcquireRelease) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, Ordering, SynchScope); @@ -3015,10 +3014,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), New) || (Record.size() < OpNum + 3 || Record.size() > OpNum + 5)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]); if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); AtomicOrdering FailureOrdering; @@ -3053,14 +3052,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); if (Operation < AtomicRMWInst::FIRST_BINOP || Operation > AtomicRMWInst::LAST_BINOP) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Unordered) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); @@ -3069,11 +3068,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] if (2 != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); if (Ordering == NotAtomic || Ordering == Unordered || Ordering == Monotonic) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); I = new FenceInst(Context, Ordering, SynchScope); InstructionList.push_back(I); @@ -3082,7 +3081,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_INST_CALL: { // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; @@ -3090,13 +3089,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = nullptr; if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); if (!FTy || Record.size() < FTy->getNumParams()+OpNum) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); SmallVector<Value*, 16> Args; // Read the fixed params. @@ -3107,18 +3106,18 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Args.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); if (!Args.back()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } // Read type/value pairs for varargs params. if (!FTy->isVarArg()) { if (OpNum != Record.size()) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); } else { while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Args.push_back(Op); } } @@ -3138,12 +3137,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] if (Record.size() < 3) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); Type *OpTy = getTypeByID(Record[0]); Value *Op = getValue(Record, 1, NextValueNo, OpTy); Type *ResTy = getTypeByID(Record[2]); if (!OpTy || !Op || !ResTy) - return Error(InvalidRecord); + return Error(BitcodeError::InvalidRecord); I = new VAArgInst(Op, ResTy); InstructionList.push_back(I); break; @@ -3154,7 +3153,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // this file. if (!CurBB) { delete I; - return Error(InvalidInstructionWithNoBB); + return Error(BitcodeError::InvalidInstructionWithNoBB); } CurBB->getInstList().push_back(I); @@ -3181,7 +3180,7 @@ OutOfRecordLoop: delete A; } } - return Error(NeverResolvedValueFoundInFunction); + return Error(BitcodeError::NeverResolvedValueFoundInFunction); } } @@ -3197,7 +3196,7 @@ OutOfRecordLoop: for (unsigned i = 0, e = RefList.size(); i != e; ++i) { unsigned BlockIdx = RefList[i].first; if (BlockIdx >= FunctionBBs.size()) - return Error(InvalidID); + return Error(BitcodeError::InvalidID); GlobalVariable *FwdRef = RefList[i].second; FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); @@ -3220,7 +3219,7 @@ std::error_code BitcodeReader::FindFunctionInStream( DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) { while (DeferredFunctionInfoIterator->second == 0) { if (Stream.AtEndOfStream()) - return Error(CouldNotFindFunctionInStream); + return Error(BitcodeError::CouldNotFindFunctionInStream); // ParseModule will parse the next body in the stream and set its // position in the DeferredFunctionInfo map. if (std::error_code EC = ParseModule(true)) @@ -3353,16 +3352,16 @@ std::error_code BitcodeReader::InitStreamFromBuffer() { if (Buffer->getBufferSize() & 3) { if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); else - return Error(BitcodeStreamInvalidSize); + return Error(BitcodeError::BitcodeStreamInvalidSize); } // If we have a wrapper header, parse it and ignore the non-bc file contents. // The magic number is 0x0B17C0DE stored in little endian. if (isBitcodeWrapper(BufPtr, BufEnd)) if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) - return Error(InvalidBitcodeWrapperHeader); + return Error(BitcodeError::InvalidBitcodeWrapperHeader); StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); Stream.init(*StreamFile); @@ -3379,10 +3378,10 @@ std::error_code BitcodeReader::InitLazyStream() { unsigned char buf[16]; if (Bytes->readBytes(0, 16, buf) == -1) - return Error(BitcodeStreamInvalidSize); + return Error(BitcodeError::BitcodeStreamInvalidSize); if (!isBitcode(buf, buf + 16)) - return Error(InvalidBitcodeSignature); + return Error(BitcodeError::InvalidBitcodeSignature); if (isBitcodeWrapper(buf, buf + 4)) { const unsigned char *bitcodeStart = buf; @@ -3400,45 +3399,45 @@ class BitcodeErrorCategoryType : public std::error_category { return "llvm.bitcode"; } std::string message(int IE) const override { - BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); + BitcodeError E = static_cast<BitcodeError>(IE); switch (E) { - case BitcodeReader::BitcodeStreamInvalidSize: + case BitcodeError::BitcodeStreamInvalidSize: return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; - case BitcodeReader::ConflictingMETADATA_KINDRecords: + case BitcodeError::ConflictingMETADATA_KINDRecords: return "Conflicting METADATA_KIND records"; - case BitcodeReader::CouldNotFindFunctionInStream: + case BitcodeError::CouldNotFindFunctionInStream: return "Could not find function in stream"; - case BitcodeReader::ExpectedConstant: + case BitcodeError::ExpectedConstant: return "Expected a constant"; - case BitcodeReader::InsufficientFunctionProtos: + case BitcodeError::InsufficientFunctionProtos: return "Insufficient function protos"; - case BitcodeReader::InvalidBitcodeSignature: + case BitcodeError::InvalidBitcodeSignature: return "Invalid bitcode signature"; - case BitcodeReader::InvalidBitcodeWrapperHeader: + case BitcodeError::InvalidBitcodeWrapperHeader: return "Invalid bitcode wrapper header"; - case BitcodeReader::InvalidConstantReference: + case BitcodeError::InvalidConstantReference: return "Invalid ronstant reference"; - case BitcodeReader::InvalidID: + case BitcodeError::InvalidID: return "Invalid ID"; - case BitcodeReader::InvalidInstructionWithNoBB: + case BitcodeError::InvalidInstructionWithNoBB: return "Invalid instruction with no BB"; - case BitcodeReader::InvalidRecord: + case BitcodeError::InvalidRecord: return "Invalid record"; - case BitcodeReader::InvalidTypeForValue: + case BitcodeError::InvalidTypeForValue: return "Invalid type for value"; - case BitcodeReader::InvalidTYPETable: + case BitcodeError::InvalidTYPETable: return "Invalid TYPE table"; - case BitcodeReader::InvalidType: + case BitcodeError::InvalidType: return "Invalid type"; - case BitcodeReader::MalformedBlock: + case BitcodeError::MalformedBlock: return "Malformed block"; - case BitcodeReader::MalformedGlobalInitializerSet: + case BitcodeError::MalformedGlobalInitializerSet: return "Malformed global initializer set"; - case BitcodeReader::InvalidMultipleBlocks: + case BitcodeError::InvalidMultipleBlocks: return "Invalid multiple blocks"; - case BitcodeReader::NeverResolvedValueFoundInFunction: + case BitcodeError::NeverResolvedValueFoundInFunction: return "Never resolved value found in function"; - case BitcodeReader::InvalidValue: + case BitcodeError::InvalidValue: return "Invalid value"; } llvm_unreachable("Unknown error type!"); @@ -3446,7 +3445,7 @@ class BitcodeErrorCategoryType : public std::error_category { }; } -const std::error_category &BitcodeReader::BitcodeErrorCategory() { +const std::error_category &llvm::BitcodeErrorCategory() { static BitcodeErrorCategoryType O; return O; } diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.h b/llvm/lib/Bitcode/Reader/BitcodeReader.h index d27a3eff867..40f8d134f6a 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.h +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.h @@ -193,35 +193,8 @@ class BitcodeReader : public GVMaterializer { /// not need this flag. bool UseRelativeIDs; - static const std::error_category &BitcodeErrorCategory(); - public: - enum ErrorType { - BitcodeStreamInvalidSize, - ConflictingMETADATA_KINDRecords, - CouldNotFindFunctionInStream, - ExpectedConstant, - InsufficientFunctionProtos, - InvalidBitcodeSignature, - InvalidBitcodeWrapperHeader, - InvalidConstantReference, - InvalidID, // A read identifier is not found in the table it should be in. - InvalidInstructionWithNoBB, - InvalidRecord, // A read record doesn't have the expected size or structure - InvalidTypeForValue, // Type read OK, but is invalid for its use - InvalidTYPETable, - InvalidType, // We were unable to read a type - MalformedBlock, // We are unable to advance in the stream. - MalformedGlobalInitializerSet, - InvalidMultipleBlocks, // We found multiple blocks of a kind that should - // have only one - NeverResolvedValueFoundInFunction, - InvalidValue // Invalid version, inst number, attr number, etc - }; - - std::error_code Error(ErrorType E) { - return std::error_code(E, BitcodeErrorCategory()); - } + std::error_code Error(BitcodeError E) { return make_error_code(E); } explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C) : Context(C), TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr), |
