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