diff options
Diffstat (limited to 'llvm/lib/Bitcode/Reader/BitcodeReader.cpp')
| -rw-r--r-- | llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 593 |
1 files changed, 312 insertions, 281 deletions
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index c28a1333632..75d311c0386 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -15,6 +15,7 @@ #include "llvm/IR/AutoUpgrade.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" +#include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/LLVMContext.h" @@ -33,6 +34,61 @@ enum { SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex }; +BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC, + DiagnosticSeverity Severity, + const Twine &Msg) + : DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {} + +void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; } + +static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler, + std::error_code EC, const Twine &Message) { + BitcodeDiagnosticInfo DI(EC, DS_Error, Message); + DiagnosticHandler(DI); + return EC; +} + +static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler, + std::error_code EC) { + return Error(DiagnosticHandler, EC, EC.message()); +} + +std::error_code BitcodeReader::Error(BitcodeError E, const Twine &Message) { + return ::Error(DiagnosticHandler, make_error_code(E), Message); +} + +std::error_code BitcodeReader::Error(const Twine &Message) { + return ::Error(DiagnosticHandler, + make_error_code(BitcodeError::CorruptedBitcode), Message); +} + +std::error_code BitcodeReader::Error(BitcodeError E) { + return ::Error(DiagnosticHandler, make_error_code(E)); +} + +static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F, + LLVMContext &C) { + if (F) + return F; + return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); }; +} + +BitcodeReader::BitcodeReader(MemoryBuffer *buffer, LLVMContext &C, + DiagnosticHandlerFunction DiagnosticHandler) + : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)), + TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr), + NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C), + MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false), + WillMaterializeAllForwardRefs(false) {} + +BitcodeReader::BitcodeReader(DataStreamer *streamer, LLVMContext &C, + DiagnosticHandlerFunction DiagnosticHandler) + : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)), + TheModule(nullptr), Buffer(nullptr), LazyStreamer(streamer), + NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C), + MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false), + WillMaterializeAllForwardRefs(false) {} + std::error_code BitcodeReader::materializeForwardReferencedFunctions() { if (WillMaterializeAllForwardRefs) return std::error_code(); @@ -53,7 +109,7 @@ std::error_code BitcodeReader::materializeForwardReferencedFunctions() { // isn't a trivial way to check if a function will have a body without a // linear search through FunctionsWithBodies, so just check it here. if (!F->isMaterializable()) - return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); + return Error("Never resolved function from blockaddress"); // Try to materialize F. if (std::error_code EC = materialize(F)) @@ -560,10 +616,10 @@ static void decodeLLVMAttributesForBitcode(AttrBuilder &B, std::error_code BitcodeReader::ParseAttributeBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (!MAttributes.empty()) - return Error(BitcodeError::InvalidMultipleBlocks); + return Error("Invalid multiple blocks"); SmallVector<uint64_t, 64> Record; @@ -576,7 +632,7 @@ std::error_code BitcodeReader::ParseAttributeBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -592,7 +648,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); for (unsigned i = 0, e = Record.size(); i != e; i += 2) { AttrBuilder B; @@ -710,16 +766,17 @@ std::error_code BitcodeReader::ParseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) { *Kind = GetAttrFromCode(Code); if (*Kind == Attribute::None) - return Error(BitcodeError::InvalidValue); + return Error(BitcodeError::CorruptedBitcode, + "Unknown attribute kind (" + Twine(Code) + ")"); return std::error_code(); } std::error_code BitcodeReader::ParseAttributeGroupBlock() { if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (!MAttributeGroups.empty()) - return Error(BitcodeError::InvalidMultipleBlocks); + return Error("Invalid multiple blocks"); SmallVector<uint64_t, 64> Record; @@ -730,7 +787,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -745,7 +802,7 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { break; case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); uint64_t GrpID = Record[0]; uint64_t Idx = Record[1]; // Index of the object this attribute refers to. @@ -800,14 +857,14 @@ std::error_code BitcodeReader::ParseAttributeGroupBlock() { std::error_code BitcodeReader::ParseTypeTable() { if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); return ParseTypeTableBody(); } std::error_code BitcodeReader::ParseTypeTableBody() { if (!TypeList.empty()) - return Error(BitcodeError::InvalidMultipleBlocks); + return Error("Invalid multiple blocks"); SmallVector<uint64_t, 64> Record; unsigned NumRecords = 0; @@ -821,10 +878,10 @@ std::error_code BitcodeReader::ParseTypeTableBody() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: if (NumRecords != TypeList.size()) - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); return std::error_code(); case BitstreamEntry::Record: // The interesting case. @@ -836,12 +893,12 @@ std::error_code BitcodeReader::ParseTypeTableBody() { Type *ResultTy = nullptr; switch (Stream.readRecord(Entry.ID, Record)) { default: - return Error(BitcodeError::InvalidValue); + return Error("Invalid value"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); TypeList.resize(Record[0]); continue; case bitc::TYPE_CODE_VOID: // VOID @@ -876,20 +933,20 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] if (Record.size() < 1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned AddressSpace = 0; if (Record.size() == 2) AddressSpace = Record[1]; ResultTy = getTypeByID(Record[0]); if (!ResultTy) - return Error(BitcodeError::InvalidType); + return Error("Invalid type"); ResultTy = PointerType::get(ResultTy, AddressSpace); break; } @@ -897,7 +954,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<Type*, 8> ArgTys; for (unsigned i = 3, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -908,7 +965,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[2]); if (!ResultTy || ArgTys.size() < Record.size()-3) - return Error(BitcodeError::InvalidType); + return Error("Invalid type"); ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); break; @@ -916,7 +973,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { case bitc::TYPE_CODE_FUNCTION: { // FUNCTION: [vararg, retty, paramty x N] if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<Type*, 8> ArgTys; for (unsigned i = 2, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -927,14 +984,14 @@ std::error_code BitcodeReader::ParseTypeTableBody() { ResultTy = getTypeByID(Record[1]); if (!ResultTy || ArgTys.size() < Record.size()-2) - return Error(BitcodeError::InvalidType); + return Error("Invalid type"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<Type*, 8> EltTys; for (unsigned i = 1, e = Record.size(); i != e; ++i) { if (Type *T = getTypeByID(Record[i])) @@ -943,21 +1000,21 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error(BitcodeError::InvalidType); + return Error("Invalid type"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); continue; case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] if (Record.size() < 1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (NumRecords >= TypeList.size()) - return Error(BitcodeError::InvalidTYPETable); + return Error("Invalid TYPE table"); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -976,17 +1033,17 @@ std::error_code BitcodeReader::ParseTypeTableBody() { break; } if (EltTys.size() != Record.size()-1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Res->setBody(EltTys, Record[0]); ResultTy = Res; break; } case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] if (Record.size() != 1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (NumRecords >= TypeList.size()) - return Error(BitcodeError::InvalidTYPETable); + return Error("Invalid TYPE table"); // Check to see if this was forward referenced, if so fill in the temp. StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); @@ -1001,24 +1058,24 @@ std::error_code BitcodeReader::ParseTypeTableBody() { } case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = ArrayType::get(ResultTy, Record[0]); else - return Error(BitcodeError::InvalidType); + return Error("Invalid type"); break; case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if ((ResultTy = getTypeByID(Record[1]))) ResultTy = VectorType::get(ResultTy, Record[0]); else - return Error(BitcodeError::InvalidType); + return Error("Invalid type"); break; } if (NumRecords >= TypeList.size()) - return Error(BitcodeError::InvalidTYPETable); + return Error("Invalid TYPE table"); assert(ResultTy && "Didn't read a type?"); assert(!TypeList[NumRecords] && "Already read type?"); TypeList[NumRecords++] = ResultTy; @@ -1027,7 +1084,7 @@ std::error_code BitcodeReader::ParseTypeTableBody() { std::error_code BitcodeReader::ParseValueSymbolTable() { if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<uint64_t, 64> Record; @@ -1039,7 +1096,7 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -1054,10 +1111,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned ValueID = Record[0]; if (ValueID >= ValueList.size() || !ValueList[ValueID]) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Value *V = ValueList[ValueID]; V->setName(StringRef(ValueName.data(), ValueName.size())); @@ -1066,10 +1123,10 @@ std::error_code BitcodeReader::ParseValueSymbolTable() { } case bitc::VST_CODE_BBENTRY: { if (ConvertToString(Record, 1, ValueName)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); BasicBlock *BB = getBasicBlock(Record[0]); if (!BB) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); BB->setName(StringRef(ValueName.data(), ValueName.size())); ValueName.clear(); @@ -1083,7 +1140,7 @@ std::error_code BitcodeReader::ParseMetadata() { unsigned NextMDValueNo = MDValueList.size(); if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<uint64_t, 64> Record; @@ -1094,7 +1151,7 @@ std::error_code BitcodeReader::ParseMetadata() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: MDValueList.tryToResolveCycles(); return std::error_code(); @@ -1126,7 +1183,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); NMD->addOperand(MD); } break; @@ -1136,7 +1193,7 @@ std::error_code BitcodeReader::ParseMetadata() { // This is a LocalAsMetadata record, the only type of function-local // metadata. if (Record.size() % 2 == 1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); // If this isn't a LocalAsMetadata record, we're dropping it. This used // to be legal, but there's no upgrade path. @@ -1162,14 +1219,14 @@ std::error_code BitcodeReader::ParseMetadata() { case bitc::METADATA_OLD_NODE: { // FIXME: Remove in 4.0. if (Record.size() % 2 == 1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned Size = Record.size(); SmallVector<Metadata *, 8> Elts; for (unsigned i = 0; i != Size; i += 2) { Type *Ty = getTypeByID(Record[i]); if (!Ty) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (Ty->isMetadataTy()) Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); else if (!Ty->isVoidTy()) { @@ -1186,11 +1243,11 @@ std::error_code BitcodeReader::ParseMetadata() { } case bitc::METADATA_VALUE: { if (Record.size() != 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *Ty = getTypeByID(Record[0]); if (Ty->isMetadataTy() || Ty->isVoidTy()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); MDValueList.AssignValue( ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), @@ -1219,14 +1276,14 @@ std::error_code BitcodeReader::ParseMetadata() { } case bitc::METADATA_KIND: { if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::ConflictingMETADATA_KINDRecords); + return Error("Conflicting METADATA_KIND records"); break; } } @@ -1266,7 +1323,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) GlobalInitWorklist.back().first->setInitializer(C); else - return Error(BitcodeError::ExpectedConstant); + return Error("Expected a constant"); } GlobalInitWorklist.pop_back(); } @@ -1279,7 +1336,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) AliasInitWorklist.back().first->setAliasee(C); else - return Error(BitcodeError::ExpectedConstant); + return Error("Expected a constant"); } AliasInitWorklist.pop_back(); } @@ -1292,7 +1349,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) FunctionPrefixWorklist.back().first->setPrefixData(C); else - return Error(BitcodeError::ExpectedConstant); + return Error("Expected a constant"); } FunctionPrefixWorklist.pop_back(); } @@ -1305,7 +1362,7 @@ std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) FunctionPrologueWorklist.back().first->setPrologueData(C); else - return Error(BitcodeError::ExpectedConstant); + return Error("Expected a constant"); } FunctionPrologueWorklist.pop_back(); } @@ -1323,7 +1380,7 @@ static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { std::error_code BitcodeReader::ParseConstants() { if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<uint64_t, 64> Record; @@ -1336,10 +1393,10 @@ std::error_code BitcodeReader::ParseConstants() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: if (NextCstNo != ValueList.size()) - return Error(BitcodeError::InvalidConstantReference); + return Error("Invalid ronstant reference"); // Once all the constants have been read, go through and resolve forward // references. @@ -1361,9 +1418,9 @@ std::error_code BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] if (Record.empty()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); CurTy = TypeList[Record[0]]; continue; // Skip the ValueList manipulation. case bitc::CST_CODE_NULL: // NULL @@ -1371,12 +1428,12 @@ std::error_code BitcodeReader::ParseConstants() { break; case bitc::CST_CODE_INTEGER: // INTEGER: [intval] if (!CurTy->isIntegerTy() || Record.empty()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); APInt VInt = ReadWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth()); @@ -1386,7 +1443,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] if (Record.empty()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (CurTy->isHalfTy()) V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, APInt(16, (uint16_t)Record[0]))); @@ -1416,7 +1473,7 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] if (Record.empty()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned Size = Record.size(); SmallVector<Constant*, 16> Elts; @@ -1444,7 +1501,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallString<16> Elts(Record.begin(), Record.end()); V = ConstantDataArray::getString(Context, Elts, @@ -1453,7 +1510,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_DATA: {// DATA: [n x value] if (Record.empty()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); unsigned Size = Record.size(); @@ -1498,14 +1555,14 @@ std::error_code BitcodeReader::ParseConstants() { else V = ConstantDataArray::get(Context, Elts); } else { - return Error(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); } break; } case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown binop. @@ -1536,14 +1593,14 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); int Opc = GetDecodedCastOpcode(Record[0]); if (Opc < 0) { V = UndefValue::get(CurTy); // Unknown cast. } else { Type *OpTy = getTypeByID(Record[1]); if (!OpTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); V = UpgradeBitCastExpr(Opc, Op, CurTy); if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); @@ -1553,12 +1610,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<Constant*, 16> Elts; for (unsigned i = 0, e = Record.size(); i != e; i += 2) { Type *ElTy = getTypeByID(Record[i]); if (!ElTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); } ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); @@ -1569,7 +1626,7 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *SelectorTy = Type::getInt1Ty(Context); @@ -1588,22 +1645,22 @@ std::error_code BitcodeReader::ParseConstants() { case bitc::CST_CODE_CE_EXTRACTELT : { // CE_EXTRACTELT: [opty, opval, opty, opval] if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (!OpTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = nullptr; if (Record.size() == 4) { Type *IdxTy = getTypeByID(Record[2]); if (!IdxTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); V = ConstantExpr::getExtractElement(Op0, Op1); break; } @@ -1611,7 +1668,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy->getElementType()); @@ -1619,19 +1676,19 @@ std::error_code BitcodeReader::ParseConstants() { if (Record.size() == 4) { Type *IdxTy = getTypeByID(Record[2]); if (!IdxTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1645,7 +1702,7 @@ std::error_code BitcodeReader::ParseConstants() { VectorType *OpTy = dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); if (Record.size() < 4 || !RTy || !OpTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), @@ -1656,10 +1713,10 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] if (Record.size() < 4) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *OpTy = getTypeByID(Record[0]); if (!OpTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); @@ -1673,16 +1730,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1697,17 +1754,17 @@ std::error_code BitcodeReader::ParseConstants() { // inteldialect). case bitc::CST_CODE_INLINEASM: { if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned ConstStrSize = Record[2+AsmStrSize]; if (3+AsmStrSize+ConstStrSize > Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); for (unsigned i = 0; i != AsmStrSize; ++i) AsmStr += (char)Record[2+i]; @@ -1721,14 +1778,14 @@ std::error_code BitcodeReader::ParseConstants() { } case bitc::CST_CODE_BLOCKADDRESS:{ if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *FnTy = getTypeByID(Record[0]); if (!FnTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Function *Fn = dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); if (!Fn) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); // Don't let Fn get dematerialized. BlockAddressesTaken.insert(Fn); @@ -1739,12 +1796,12 @@ std::error_code BitcodeReader::ParseConstants() { unsigned BBID = Record[2]; if (!BBID) // Invalid reference to entry block. - return Error(BitcodeError::InvalidID); + return Error("Invalid ID"); if (!Fn->empty()) { Function::iterator BBI = Fn->begin(), BBE = Fn->end(); for (size_t I = 0, E = BBID; I != E; ++I) { if (BBI == BBE) - return Error(BitcodeError::InvalidID); + return Error("Invalid ID"); ++BBI; } BB = BBI; @@ -1772,7 +1829,7 @@ std::error_code BitcodeReader::ParseConstants() { std::error_code BitcodeReader::ParseUseLists() { if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); // Read all the records. SmallVector<uint64_t, 64> Record; @@ -1782,7 +1839,7 @@ std::error_code BitcodeReader::ParseUseLists() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -1803,7 +1860,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned ID = Record.back(); Record.pop_back(); @@ -1840,7 +1897,7 @@ std::error_code BitcodeReader::ParseUseLists() { std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Get the function we are talking about. if (FunctionsWithBodies.empty()) - return Error(BitcodeError::InsufficientFunctionProtos); + return Error("Insufficient function protos"); Function *Fn = FunctionsWithBodies.back(); FunctionsWithBodies.pop_back(); @@ -1851,7 +1908,7 @@ std::error_code BitcodeReader::RememberAndSkipFunctionBody() { // Skip over the function block for now. if (Stream.SkipBlock()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); return std::error_code(); } @@ -1859,7 +1916,7 @@ std::error_code BitcodeReader::GlobalCleanup() { // Patch the initializers for globals and aliases up. ResolveGlobalAndAliasInits(); if (!GlobalInits.empty() || !AliasInits.empty()) - return Error(BitcodeError::MalformedGlobalInitializerSet); + return Error("Malformed global initializer set"); // Look for intrinsic functions which need to be upgraded at some point for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); @@ -1888,7 +1945,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { if (Resume) Stream.JumpToBit(NextUnreadBit); else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<uint64_t, 64> Record; std::vector<std::string> SectionTable; @@ -1900,7 +1957,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return GlobalCleanup(); @@ -1908,11 +1965,11 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); break; case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); break; case bitc::PARAMATTR_BLOCK_ID: if (std::error_code EC = ParseAttributeBlock()) @@ -1982,12 +2039,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); // Only version #0 and #1 are supported so far. unsigned module_version = Record[0]; switch (module_version) { default: - return Error(BitcodeError::InvalidValue); + return Error("Invalid value"); case 0: UseRelativeIDs = false; break; @@ -2000,21 +2057,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); TheModule->setTargetTriple(S); break; } case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); TheModule->setDataLayout(S); break; } case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); TheModule->setModuleInlineAsm(S); break; } @@ -2022,27 +2079,27 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // FIXME: Remove in 4.0. std::string S; if (ConvertToString(Record, 0, S)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); // Ignore value. break; } case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SectionTable.push_back(S); break; } case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] std::string S; if (ConvertToString(Record, 0, S)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); GCTable.push_back(S); break; } case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name] if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]); unsigned ComdatNameSize = Record[1]; std::string ComdatName; @@ -2059,12 +2116,12 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // unnamed_addr, dllstorageclass] case bitc::MODULE_CODE_GLOBALVAR: { if (Record.size() < 6) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (!Ty->isPointerTy()) - return Error(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); Ty = cast<PointerType>(Ty)->getElementType(); @@ -2074,7 +2131,7 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { std::string Section; if (Record[5]) { if (Record[5]-1 >= SectionTable.size()) - return Error(BitcodeError::InvalidID); + return Error("Invalid ID"); Section = SectionTable[Record[5]-1]; } GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; @@ -2127,16 +2184,16 @@ std::error_code BitcodeReader::ParseModule(bool Resume) { // prologuedata, dllstorageclass, comdat, prefixdata] case bitc::MODULE_CODE_FUNCTION: { if (Record.size() < 8) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (!Ty->isPointerTy()) - return Error(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); FunctionType *FTy = dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); if (!FTy) - return Error(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, "", TheModule); @@ -2149,7 +2206,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(BitcodeError::InvalidID); + return Error("Invalid ID"); Func->setSection(SectionTable[Record[6]-1]); } // Local linkage must have default visibility. @@ -2158,7 +2215,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(BitcodeError::InvalidID); + return Error("Invalid ID"); Func->setGC(GCTable[Record[8]-1].c_str()); } bool UnnamedAddr = false; @@ -2198,13 +2255,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); auto *PTy = dyn_cast<PointerType>(Ty); if (!PTy) - return Error(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); auto *NewGA = GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), @@ -2230,7 +2287,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); ValueList.shrinkTo(Record[0]); break; } @@ -2251,7 +2308,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error(BitcodeError::InvalidBitcodeSignature); + return Error("Invalid bitcode signature"); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -2264,7 +2321,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); @@ -2272,12 +2329,12 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { switch (Entry.ID) { case bitc::BLOCKINFO_BLOCK_ID: if (Stream.ReadBlockInfoBlock()) - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); break; case bitc::MODULE_BLOCK_ID: // Reject multiple MODULE_BLOCK's in a single bitstream. if (TheModule) - return Error(BitcodeError::InvalidMultipleBlocks); + return Error("Invalid multiple blocks"); TheModule = M; if (std::error_code EC = ParseModule(false)) return EC; @@ -2286,7 +2343,7 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { break; default: if (Stream.SkipBlock()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); break; } continue; @@ -2301,14 +2358,14 @@ std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { Stream.AtEndOfStream()) return std::error_code(); - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } } } ErrorOr<std::string> BitcodeReader::parseModuleTriple() { if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<uint64_t, 64> Record; @@ -2320,7 +2377,7 @@ ErrorOr<std::string> BitcodeReader::parseModuleTriple() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return Triple; case BitstreamEntry::Record: @@ -2334,7 +2391,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); Triple = S; break; } @@ -2355,7 +2412,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { Stream.Read(4) != 0xC || Stream.Read(4) != 0xE || Stream.Read(4) != 0xD) - return Error(BitcodeError::InvalidBitcodeSignature); + return Error("Invalid bitcode signature"); // We expect a number of well-defined blocks, though we don't necessarily // need to understand them all. @@ -2364,7 +2421,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); @@ -2374,7 +2431,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { // Ignore other sub-blocks. if (Stream.SkipBlock()) - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); continue; case BitstreamEntry::Record: @@ -2387,7 +2444,7 @@ ErrorOr<std::string> BitcodeReader::parseTriple() { /// ParseMetadataAttachment - Parse metadata attachments. std::error_code BitcodeReader::ParseMetadataAttachment() { if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<uint64_t, 64> Record; while (1) { @@ -2396,7 +2453,7 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { switch (Entry.Kind) { case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: return std::error_code(); case BitstreamEntry::Record: @@ -2412,14 +2469,14 @@ std::error_code BitcodeReader::ParseMetadataAttachment() { case bitc::METADATA_ATTACHMENT: { unsigned RecordLength = Record.size(); if (Record.empty() || (RecordLength - 1) % 2 == 1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidID); + return Error("Invalid ID"); Metadata *Node = MDValueList.getValueFwdRef(Record[i + 1]); if (isa<LocalAsMetadata>(Node)) // Drop the attachment. This used to be legal, but there's no @@ -2438,7 +2495,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); InstructionList.clear(); unsigned ModuleValueListSize = ValueList.size(); @@ -2469,7 +2526,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.Kind) { case BitstreamEntry::Error: - return Error(BitcodeError::MalformedBlock); + return Error("Malformed block"); case BitstreamEntry::EndBlock: goto OutOfRecordLoop; @@ -2477,7 +2534,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { switch (Entry.ID) { default: // Skip unknown content. if (Stream.SkipBlock()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); break; case bitc::CONSTANTS_BLOCK_ID: if (std::error_code EC = ParseConstants()) @@ -2514,10 +2571,10 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned BitCode = Stream.readRecord(Entry.ID, Record); switch (BitCode) { default: // Default behavior: reject - return Error(BitcodeError::InvalidValue); + return Error("Invalid value"); case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks] if (Record.size() < 1 || Record[0] == 0) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); // Create all the basic blocks for the function. FunctionBBs.resize(Record[0]); @@ -2530,7 +2587,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { auto &BBRefs = BBFRI->second; // Check for invalid basic block references. if (BBRefs.size() > FunctionBBs.size()) - return Error(BitcodeError::InvalidID); + return Error("Invalid ID"); assert(!BBRefs.empty() && "Unexpected empty array"); assert(!BBRefs.front() && "Invalid reference to entry block"); for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E; @@ -2556,7 +2613,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { I = getLastInstruction(); if (!I) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I->setDebugLoc(LastLoc); I = nullptr; continue; @@ -2564,7 +2621,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] I = getLastInstruction(); if (!I || Record.size() < 4) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned Line = Record[0], Col = Record[1]; unsigned ScopeID = Record[2], IAID = Record[3]; @@ -2584,11 +2641,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); if (Opc == -1) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); InstructionList.push_back(I); if (OpNum < Record.size()) { @@ -2630,12 +2687,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *ResTy = getTypeByID(Record[OpNum]); int Opc = GetDecodedCastOpcode(Record[OpNum+1]); if (Opc == -1 || !ResTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Instruction *Temp = nullptr; if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { if (Temp) { @@ -2653,13 +2710,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *BasePtr; if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<Value*, 16> GEPIdx; while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); GEPIdx.push_back(Op); } @@ -2675,14 +2732,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<unsigned, 4> EXTRACTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error(BitcodeError::InvalidValue); + return Error("Invalid value"); EXTRACTVALIdx.push_back((unsigned)Index); } @@ -2696,17 +2753,17 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Agg; if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Value *Val; if (getValueTypePair(Record, OpNum, NextValueNo, Val)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<unsigned, 4> INSERTVALIdx; for (unsigned RecSize = Record.size(); OpNum != RecSize; ++OpNum) { uint64_t Index = Record[OpNum]; if ((unsigned)Index != Index) - return Error(BitcodeError::InvalidValue); + return Error("Invalid value"); INSERTVALIdx.push_back((unsigned)Index); } @@ -2723,7 +2780,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = SelectInst::Create(Cond, TrueVal, FalseVal); InstructionList.push_back(I); @@ -2738,18 +2795,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); // 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(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); } else { // expect i1 if (Cond->getType() != Type::getInt1Ty(Context)) - return Error(BitcodeError::InvalidTypeForValue); + return Error("Invalid type for value"); } I = SelectInst::Create(Cond, TrueVal, FalseVal); @@ -2762,7 +2819,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Vec, *Idx; if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || getValueTypePair(Record, OpNum, NextValueNo, Idx)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = ExtractElementInst::Create(Vec, Idx); InstructionList.push_back(I); break; @@ -2775,7 +2832,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = InsertElementInst::Create(Vec, Elt, Idx); InstructionList.push_back(I); break; @@ -2786,10 +2843,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = new ShuffleVectorInst(Vec1, Vec2, Mask); InstructionList.push_back(I); break; @@ -2807,7 +2864,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (LHS->getType()->isFPOrFPVectorTy()) I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); @@ -2829,9 +2886,9 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 0; Value *Op = nullptr; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (OpNum != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = ReturnInst::Create(Context, Op); InstructionList.push_back(I); @@ -2839,10 +2896,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); BasicBlock *TrueDest = getBasicBlock(Record[0]); if (!TrueDest) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (Record.size() == 1) { I = BranchInst::Create(TrueDest); @@ -2853,7 +2910,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Cond = getValue(Record, 2, NextValueNo, Type::getInt1Ty(Context)); if (!FalseDest || !Cond) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = BranchInst::Create(TrueDest, FalseDest, Cond); InstructionList.push_back(I); } @@ -2873,7 +2930,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned NumCases = Record[4]; @@ -2925,12 +2982,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // Old SwitchInst format without case ranges. if (Record.size() < 3 || (Record.size() & 1) == 0) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *OpTy = getTypeByID(Record[0]); Value *Cond = getValue(Record, 1, NextValueNo, OpTy); BasicBlock *Default = getBasicBlock(Record[2]); if (!OpTy || !Cond || !Default) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned NumCases = (Record.size()-3)/2; SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); InstructionList.push_back(SI); @@ -2940,7 +2997,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); if (!CaseVal || !DestBB) { delete SI; - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } SI->addCase(CaseVal, DestBB); } @@ -2949,11 +3006,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] if (Record.size() < 2) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *OpTy = getTypeByID(Record[0]); Value *Address = getValue(Record, 1, NextValueNo, OpTy); if (!OpTy || !Address) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); unsigned NumDests = Record.size()-2; IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); InstructionList.push_back(IBI); @@ -2962,7 +3019,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { IBI->addDestination(DestBB); } else { delete IBI; - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } } I = IBI; @@ -2972,7 +3029,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; BasicBlock *NormalBB = getBasicBlock(Record[2]); @@ -2981,7 +3038,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 4; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); FunctionType *FTy = !CalleeTy ? nullptr : @@ -2990,25 +3047,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); } if (!FTy->isVarArg()) { if (Record.size() != OpNum) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } else { // Read type/value pairs for varargs params. while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Ops.push_back(Op); } } @@ -3024,7 +3081,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned Idx = 0; Value *Val = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, Val)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = ResumeInst::Create(Val); InstructionList.push_back(I); break; @@ -3035,10 +3092,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *Ty = getTypeByID(Record[0]); if (!Ty) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); InstructionList.push_back(PN); @@ -3054,7 +3111,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); PN->addIncoming(V, BB); } I = PN; @@ -3065,13 +3122,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] unsigned Idx = 0; if (Record.size() < 4) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *Ty = getTypeByID(Record[Idx++]); if (!Ty) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Value *PersFn = nullptr; if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); bool IsCleanup = !!Record[Idx++]; unsigned NumClauses = Record[Idx++]; @@ -3084,7 +3141,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { if (getValueTypePair(Record, Idx, NextValueNo, Val)) { delete LP; - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } assert((CT != LandingPadInst::Catch || @@ -3103,7 +3160,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); PointerType *Ty = dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); Type *OpTy = getTypeByID(Record[1]); @@ -3112,7 +3169,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { bool InAlloca = AlignRecord & (1 << 5); unsigned Align = AlignRecord & ((1 << 5) - 1); if (!Ty || !Size) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); AllocaInst *AI = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); AI->setUsedWithInAlloca(InAlloca); I = AI; @@ -3124,7 +3181,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+2 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -3136,14 +3193,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op) || OpNum+4 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Release || Ordering == AcquireRelease) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, @@ -3158,7 +3215,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+2 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); InstructionList.push_back(I); @@ -3172,15 +3229,15 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Acquire || Ordering == AcquireRelease) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); if (Ordering != NotAtomic && Record[OpNum] == 0) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, Ordering, SynchScope); @@ -3198,10 +3255,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]); if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); AtomicOrdering FailureOrdering; @@ -3236,14 +3293,14 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { popValue(Record, OpNum, NextValueNo, cast<PointerType>(Ptr->getType())->getElementType(), Val) || OpNum+4 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); if (Operation < AtomicRMWInst::FIRST_BINOP || Operation > AtomicRMWInst::LAST_BINOP) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); if (Ordering == NotAtomic || Ordering == Unordered) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); @@ -3252,11 +3309,11 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] if (2 != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); if (Ordering == NotAtomic || Ordering == Unordered || Ordering == Monotonic) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); I = new FenceInst(Context, Ordering, SynchScope); InstructionList.push_back(I); @@ -3265,7 +3322,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(BitcodeError::InvalidRecord); + return Error("Invalid record"); AttributeSet PAL = getAttributes(Record[0]); unsigned CCInfo = Record[1]; @@ -3273,13 +3330,13 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { unsigned OpNum = 2; Value *Callee; if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); 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(BitcodeError::InvalidRecord); + return Error("Invalid record"); SmallVector<Value*, 16> Args; // Read the fixed params. @@ -3290,18 +3347,18 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { Args.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i))); if (!Args.back()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } // Read type/value pairs for varargs params. if (!FTy->isVarArg()) { if (OpNum != Record.size()) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); } else { while (OpNum != Record.size()) { Value *Op; if (getValueTypePair(Record, OpNum, NextValueNo, Op)) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Args.push_back(Op); } } @@ -3321,12 +3378,12 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { } case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] if (Record.size() < 3) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); Type *OpTy = getTypeByID(Record[0]); Value *Op = getValue(Record, 1, NextValueNo, OpTy); Type *ResTy = getTypeByID(Record[2]); if (!OpTy || !Op || !ResTy) - return Error(BitcodeError::InvalidRecord); + return Error("Invalid record"); I = new VAArgInst(Op, ResTy); InstructionList.push_back(I); break; @@ -3337,7 +3394,7 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) { // this file. if (!CurBB) { delete I; - return Error(BitcodeError::InvalidInstructionWithNoBB); + return Error("Invalid instruction with no BB"); } CurBB->getInstList().push_back(I); @@ -3364,7 +3421,7 @@ OutOfRecordLoop: delete A; } } - return Error(BitcodeError::NeverResolvedValueFoundInFunction); + return Error("Never resolved value found in function"); } } @@ -3384,7 +3441,7 @@ std::error_code BitcodeReader::FindFunctionInStream( DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) { while (DeferredFunctionInfoIterator->second == 0) { if (Stream.AtEndOfStream()) - return Error(BitcodeError::CouldNotFindFunctionInStream); + return Error("Could not find function in stream"); // ParseModule will parse the next body in the stream and set its // position in the DeferredFunctionInfo map. if (std::error_code EC = ParseModule(true)) @@ -3486,7 +3543,7 @@ std::error_code BitcodeReader::MaterializeModule(Module *M) { // Check that all block address forward references got resolved (as we // promised above). if (!BasicBlockFwdRefs.empty()) - return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); + return Error("Never resolved function from blockaddress"); // Upgrade any intrinsic calls that slipped through (should not happen!) and // delete the old functions to clean up. We can't do this unless the entire @@ -3529,13 +3586,13 @@ std::error_code BitcodeReader::InitStreamFromBuffer() { const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); if (Buffer->getBufferSize() & 3) - return Error(BitcodeError::InvalidBitcodeSignature); + return Error("Invalid bitcode signature"); // 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(BitcodeError::InvalidBitcodeWrapperHeader); + return Error("Invalid bitcode wrapper header"); StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); Stream.init(&*StreamFile); @@ -3553,10 +3610,10 @@ std::error_code BitcodeReader::InitLazyStream() { unsigned char buf[16]; if (Bytes.readBytes(buf, 16, 0) != 16) - return Error(BitcodeError::InvalidBitcodeSignature); + return Error("Invalid bitcode signature"); if (!isBitcode(buf, buf + 16)) - return Error(BitcodeError::InvalidBitcodeSignature); + return Error("Invalid bitcode signature"); if (isBitcodeWrapper(buf, buf + 4)) { const unsigned char *bitcodeStart = buf; @@ -3576,44 +3633,10 @@ class BitcodeErrorCategoryType : public std::error_category { std::string message(int IE) const override { BitcodeError E = static_cast<BitcodeError>(IE); switch (E) { - case BitcodeError::ConflictingMETADATA_KINDRecords: - return "Conflicting METADATA_KIND records"; - case BitcodeError::CouldNotFindFunctionInStream: - return "Could not find function in stream"; - case BitcodeError::ExpectedConstant: - return "Expected a constant"; - case BitcodeError::InsufficientFunctionProtos: - return "Insufficient function protos"; case BitcodeError::InvalidBitcodeSignature: return "Invalid bitcode signature"; - case BitcodeError::InvalidBitcodeWrapperHeader: - return "Invalid bitcode wrapper header"; - case BitcodeError::InvalidConstantReference: - return "Invalid ronstant reference"; - case BitcodeError::InvalidID: - return "Invalid ID"; - case BitcodeError::InvalidInstructionWithNoBB: - return "Invalid instruction with no BB"; - case BitcodeError::InvalidRecord: - return "Invalid record"; - case BitcodeError::InvalidTypeForValue: - return "Invalid type for value"; - case BitcodeError::InvalidTYPETable: - return "Invalid TYPE table"; - case BitcodeError::InvalidType: - return "Invalid type"; - case BitcodeError::MalformedBlock: - return "Malformed block"; - case BitcodeError::MalformedGlobalInitializerSet: - return "Malformed global initializer set"; - case BitcodeError::InvalidMultipleBlocks: - return "Invalid multiple blocks"; - case BitcodeError::NeverResolvedValueFoundInFunction: - return "Never resolved value found in function"; - case BitcodeError::NeverResolvedFunctionFromBlockAddress: - return "Never resolved function from blockaddress"; - case BitcodeError::InvalidValue: - return "Invalid value"; + case BitcodeError::CorruptedBitcode: + return "Corrupted bitcode"; } llvm_unreachable("Unknown error type!"); } @@ -3640,9 +3663,11 @@ const std::error_category &llvm::BitcodeErrorCategory() { /// materialize everything -- in particular, if this isn't truly lazy. static ErrorOr<Module *> getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer, - LLVMContext &Context, bool WillMaterializeAll) { + LLVMContext &Context, bool WillMaterializeAll, + DiagnosticHandlerFunction DiagnosticHandler) { Module *M = new Module(Buffer->getBufferIdentifier(), Context); - BitcodeReader *R = new BitcodeReader(Buffer.get(), Context); + BitcodeReader *R = + new BitcodeReader(Buffer.get(), Context, DiagnosticHandler); M->setMaterializer(R); auto cleanupOnError = [&](std::error_code EC) { @@ -3665,26 +3690,30 @@ getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer, ErrorOr<Module *> llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer, - LLVMContext &Context) { - return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false); + LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler) { + return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false, + DiagnosticHandler); } ErrorOr<std::unique_ptr<Module>> llvm::getStreamedBitcodeModule(StringRef Name, DataStreamer *Streamer, - LLVMContext &Context) { + LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler) { std::unique_ptr<Module> M = make_unique<Module>(Name, Context); - BitcodeReader *R = new BitcodeReader(Streamer, Context); + BitcodeReader *R = new BitcodeReader(Streamer, Context, DiagnosticHandler); M->setMaterializer(R); if (std::error_code EC = R->ParseBitcodeInto(M.get())) return EC; return std::move(M); } -ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer, - LLVMContext &Context) { +ErrorOr<Module *> +llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler) { std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); - ErrorOr<Module *> ModuleOrErr = - getLazyBitcodeModuleImpl(std::move(Buf), Context, true); + ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModuleImpl( + std::move(Buf), Context, true, DiagnosticHandler); if (!ModuleOrErr) return ModuleOrErr; Module *M = ModuleOrErr.get(); @@ -3700,10 +3729,12 @@ ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer, return M; } -std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, - LLVMContext &Context) { +std::string +llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context, + DiagnosticHandlerFunction DiagnosticHandler) { std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); - auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context); + auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context, + DiagnosticHandler); ErrorOr<std::string> Triple = R->parseTriple(); if (Triple.getError()) return ""; |
