Use the DiagnosticHandler to print diagnostics when reading bitcode.
The bitcode reading interface used std::error_code to report an error to the
callers and it is the callers job to print diagnostics.
This is not ideal for error handling or diagnostic reporting:
* For error handling, all that the callers care about is 3 possibilities:
* It worked
* The bitcode file is corrupted/invalid.
* The file is not bitcode at all.
* For diagnostic, it is user friendly to include far more information
about the invalid case so the user can find out what is wrong with the
bitcode file. This comes up, for example, when a developer introduces a
bug while extending the format.
The compromise we had was to have a lot of error codes.
With this patch we use the DiagnosticHandler to communicate with the
human and std::error_code to communicate with the caller.
This allows us to have far fewer error codes and adds the infrastructure to
print better diagnostics. This is so because the diagnostics are printed when
he issue is found. The code that detected the problem in alive in the stack and
can pass down as much context as needed. As an example the patch updates
test/Bitcode/invalid.ll.
Using a DiagnosticHandler also moves the fatal/non-fatal error decision to the
caller. A simple one like llvm-dis can just use fatal errors. The gold plugin
needs a bit more complex treatment because of being passed non-bitcode files. An
hypothetical interactive tool would make all bitcode errors non-fatal.
llvm-svn: 225562
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index c28a133..75d311c 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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::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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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::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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
: { // 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 @@
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 @@
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 @@
}
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 @@
// 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 @@
// 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 @@
}
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 @@
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::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 @@
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 @@
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::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 @@
// 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 @@
// 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 @@
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 @@
switch (Entry.Kind) {
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return GlobalCleanup();
@@ -1908,11 +1965,11 @@
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 @@
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 @@
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 @@
// 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 @@
// 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::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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
break;
default:
if (Stream.SkipBlock())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
break;
}
continue;
@@ -2301,14 +2358,14 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// Ignore other sub-blocks.
if (Stream.SkipBlock())
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
continue;
case BitstreamEntry::Record:
@@ -2387,7 +2444,7 @@
/// 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 @@
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 @@
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 @@
/// 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 @@
switch (Entry.Kind) {
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
goto OutOfRecordLoop;
@@ -2477,7 +2534,7 @@
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 @@
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 @@
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 @@
I = getLastInstruction();
if (!I)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I->setDebugLoc(LastLoc);
I = nullptr;
continue;
@@ -2564,7 +2621,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
// 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 @@
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 @@
}
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 @@
IBI->addDestination(DestBB);
} else {
delete IBI;
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
}
I = IBI;
@@ -2972,7 +3029,7 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
delete LP;
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
assert((CT != LandingPadInst::Catch ||
@@ -3103,7 +3160,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
// 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 @@
delete A;
}
}
- return Error(BitcodeError::NeverResolvedValueFoundInFunction);
+ return Error("Never resolved value found in function");
}
}
@@ -3384,7 +3441,7 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
/// 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 @@
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 @@
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 "";