[llvm] r225562 - Use the DiagnosticHandler to print diagnostics when reading bitcode.
Rafael Espindola
rafael.espindola at gmail.com
Fri Jan 9 16:07:30 PST 2015
Author: rafael
Date: Fri Jan 9 18:07:30 2015
New Revision: 225562
URL: http://llvm.org/viewvc/llvm-project?rev=225562&view=rev
Log:
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.
Modified:
llvm/trunk/include/llvm/Bitcode/ReaderWriter.h
llvm/trunk/include/llvm/IR/DiagnosticInfo.h
llvm/trunk/include/llvm/Linker/Linker.h
llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
llvm/trunk/lib/Bitcode/Reader/BitcodeReader.h
llvm/trunk/lib/LTO/LTOModule.cpp
llvm/trunk/lib/Linker/LinkModules.cpp
llvm/trunk/test/Bitcode/invalid.ll
llvm/trunk/test/LTO/invalid.ll
llvm/trunk/tools/gold/gold-plugin.cpp
llvm/trunk/tools/llvm-dis/llvm-dis.cpp
Modified: llvm/trunk/include/llvm/Bitcode/ReaderWriter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Bitcode/ReaderWriter.h?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Bitcode/ReaderWriter.h (original)
+++ llvm/trunk/include/llvm/Bitcode/ReaderWriter.h Fri Jan 9 18:07:30 2015
@@ -14,6 +14,7 @@
#ifndef LLVM_BITCODE_READERWRITER_H
#define LLVM_BITCODE_READERWRITER_H
+#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/MemoryBuffer.h"
#include <memory>
@@ -30,24 +31,28 @@ namespace llvm {
/// Read the header of the specified bitcode buffer and prepare for lazy
/// deserialization of function bodies. If successful, this moves Buffer. On
/// error, this *does not* move Buffer.
- ErrorOr<Module *> getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
- LLVMContext &Context);
+ ErrorOr<Module *>
+ getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
+ LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler = nullptr);
/// Read the header of the specified stream and prepare for lazy
/// deserialization and streaming of function bodies.
- ErrorOr<std::unique_ptr<Module>>
- getStreamedBitcodeModule(StringRef Name, DataStreamer *Streamer,
- LLVMContext &Context);
+ ErrorOr<std::unique_ptr<Module>> getStreamedBitcodeModule(
+ StringRef Name, DataStreamer *Streamer, LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler = nullptr);
/// Read the header of the specified bitcode buffer and extract just the
/// triple information. If successful, this returns a string. On error, this
/// returns "".
- std::string getBitcodeTargetTriple(MemoryBufferRef Buffer,
- LLVMContext &Context);
+ std::string
+ getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler = nullptr);
/// Read the specified bitcode file, returning the module.
- ErrorOr<Module *> parseBitcodeFile(MemoryBufferRef Buffer,
- LLVMContext &Context);
+ ErrorOr<Module *>
+ parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler = nullptr);
/// WriteBitcodeToFile - Write the specified module to the specified
/// raw output stream. For streams where it matters, the given stream
@@ -138,32 +143,26 @@ namespace llvm {
}
const std::error_category &BitcodeErrorCategory();
- enum class BitcodeError {
- 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,
- NeverResolvedFunctionFromBlockAddress,
- InvalidValue // Invalid version, inst number, attr number, etc
- };
+ enum class BitcodeError { InvalidBitcodeSignature, CorruptedBitcode };
inline std::error_code make_error_code(BitcodeError E) {
return std::error_code(static_cast<int>(E), BitcodeErrorCategory());
}
+ class BitcodeDiagnosticInfo : public DiagnosticInfo {
+ const Twine &Msg;
+ std::error_code EC;
+
+ public:
+ BitcodeDiagnosticInfo(std::error_code EC, DiagnosticSeverity Severity,
+ const Twine &Msg);
+ void print(DiagnosticPrinter &DP) const override;
+ std::error_code getError() const { return EC; };
+
+ static bool classof(const DiagnosticInfo *DI) {
+ return DI->getKind() == DK_Bitcode;
+ }
+ };
+
} // End llvm namespace
namespace std {
Modified: llvm/trunk/include/llvm/IR/DiagnosticInfo.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/DiagnosticInfo.h?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/include/llvm/IR/DiagnosticInfo.h (original)
+++ llvm/trunk/include/llvm/IR/DiagnosticInfo.h Fri Jan 9 18:07:30 2015
@@ -45,6 +45,7 @@ enum DiagnosticSeverity {
/// \brief Defines the different supported kind of a diagnostic.
/// This enum should be extended with a new ID for each added concrete subclass.
enum DiagnosticKind {
+ DK_Bitcode,
DK_InlineAsm,
DK_StackSize,
DK_Linker,
@@ -97,6 +98,8 @@ public:
virtual void print(DiagnosticPrinter &DP) const = 0;
};
+typedef std::function<void(const DiagnosticInfo &)> DiagnosticHandlerFunction;
+
/// Diagnostic information for inline asm reporting.
/// This is basically a message and an optional location.
class DiagnosticInfoInlineAsm : public DiagnosticInfo {
Modified: llvm/trunk/include/llvm/Linker/Linker.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Linker/Linker.h?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Linker/Linker.h (original)
+++ llvm/trunk/include/llvm/Linker/Linker.h Fri Jan 9 18:07:30 2015
@@ -13,11 +13,9 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
-
-#include <functional>
+#include "llvm/IR/DiagnosticInfo.h"
namespace llvm {
-class DiagnosticInfo;
class Module;
class StructType;
class Type;
@@ -28,8 +26,6 @@ class Type;
/// something with it after the linking.
class Linker {
public:
- typedef std::function<void(const DiagnosticInfo &)> DiagnosticHandlerFunction;
-
struct StructTypeKeyInfo {
struct KeyTy {
ArrayRef<Type *> ETypes;
Modified: llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp (original)
+++ llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp Fri Jan 9 18:07:30 2015
@@ -15,6 +15,7 @@
#include "llvm/IR/AutoUpgrade.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
@@ -33,6 +34,61 @@ enum {
SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
};
+BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC,
+ DiagnosticSeverity Severity,
+ const Twine &Msg)
+ : DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}
+
+void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
+
+static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler,
+ std::error_code EC, const Twine &Message) {
+ BitcodeDiagnosticInfo DI(EC, DS_Error, Message);
+ DiagnosticHandler(DI);
+ return EC;
+}
+
+static std::error_code Error(DiagnosticHandlerFunction DiagnosticHandler,
+ std::error_code EC) {
+ return Error(DiagnosticHandler, EC, EC.message());
+}
+
+std::error_code BitcodeReader::Error(BitcodeError E, const Twine &Message) {
+ return ::Error(DiagnosticHandler, make_error_code(E), Message);
+}
+
+std::error_code BitcodeReader::Error(const Twine &Message) {
+ return ::Error(DiagnosticHandler,
+ make_error_code(BitcodeError::CorruptedBitcode), Message);
+}
+
+std::error_code BitcodeReader::Error(BitcodeError E) {
+ return ::Error(DiagnosticHandler, make_error_code(E));
+}
+
+static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F,
+ LLVMContext &C) {
+ if (F)
+ return F;
+ return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); };
+}
+
+BitcodeReader::BitcodeReader(MemoryBuffer *buffer, LLVMContext &C,
+ DiagnosticHandlerFunction DiagnosticHandler)
+ : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)),
+ TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),
+ NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C),
+ MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false),
+ WillMaterializeAllForwardRefs(false) {}
+
+BitcodeReader::BitcodeReader(DataStreamer *streamer, LLVMContext &C,
+ DiagnosticHandlerFunction DiagnosticHandler)
+ : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)),
+ TheModule(nullptr), Buffer(nullptr), LazyStreamer(streamer),
+ NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C),
+ MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false),
+ WillMaterializeAllForwardRefs(false) {}
+
std::error_code BitcodeReader::materializeForwardReferencedFunctions() {
if (WillMaterializeAllForwardRefs)
return std::error_code();
@@ -53,7 +109,7 @@ std::error_code BitcodeReader::materiali
// isn't a trivial way to check if a function will have a body without a
// linear search through FunctionsWithBodies, so just check it here.
if (!F->isMaterializable())
- return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress);
+ return Error("Never resolved function from blockaddress");
// Try to materialize F.
if (std::error_code EC = materialize(F))
@@ -560,10 +616,10 @@ static void decodeLLVMAttributesForBitco
std::error_code BitcodeReader::ParseAttributeBlock() {
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (!MAttributes.empty())
- return Error(BitcodeError::InvalidMultipleBlocks);
+ return Error("Invalid multiple blocks");
SmallVector<uint64_t, 64> Record;
@@ -576,7 +632,7 @@ std::error_code BitcodeReader::ParseAttr
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
case BitstreamEntry::Record:
@@ -592,7 +648,7 @@ std::error_code BitcodeReader::ParseAttr
case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...]
// FIXME: Remove in 4.0.
if (Record.size() & 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
AttrBuilder B;
@@ -710,16 +766,17 @@ std::error_code BitcodeReader::ParseAttr
Attribute::AttrKind *Kind) {
*Kind = GetAttrFromCode(Code);
if (*Kind == Attribute::None)
- return Error(BitcodeError::InvalidValue);
+ return Error(BitcodeError::CorruptedBitcode,
+ "Unknown attribute kind (" + Twine(Code) + ")");
return std::error_code();
}
std::error_code BitcodeReader::ParseAttributeGroupBlock() {
if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (!MAttributeGroups.empty())
- return Error(BitcodeError::InvalidMultipleBlocks);
+ return Error("Invalid multiple blocks");
SmallVector<uint64_t, 64> Record;
@@ -730,7 +787,7 @@ std::error_code BitcodeReader::ParseAttr
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
case BitstreamEntry::Record:
@@ -745,7 +802,7 @@ std::error_code BitcodeReader::ParseAttr
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::ParseAttr
std::error_code BitcodeReader::ParseTypeTable() {
if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
return ParseTypeTableBody();
}
std::error_code BitcodeReader::ParseTypeTableBody() {
if (!TypeList.empty())
- return Error(BitcodeError::InvalidMultipleBlocks);
+ return Error("Invalid multiple blocks");
SmallVector<uint64_t, 64> Record;
unsigned NumRecords = 0;
@@ -821,10 +878,10 @@ std::error_code BitcodeReader::ParseType
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
if (NumRecords != TypeList.size())
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
return std::error_code();
case BitstreamEntry::Record:
// The interesting case.
@@ -836,12 +893,12 @@ std::error_code BitcodeReader::ParseType
Type *ResultTy = nullptr;
switch (Stream.readRecord(Entry.ID, Record)) {
default:
- return Error(BitcodeError::InvalidValue);
+ return Error("Invalid value");
case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
// TYPE_CODE_NUMENTRY contains a count of the number of types in the
// type list. This allows us to reserve space.
if (Record.size() < 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
TypeList.resize(Record[0]);
continue;
case bitc::TYPE_CODE_VOID: // VOID
@@ -876,20 +933,20 @@ std::error_code BitcodeReader::ParseType
break;
case bitc::TYPE_CODE_INTEGER: // INTEGER: [width]
if (Record.size() < 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
ResultTy = IntegerType::get(Context, Record[0]);
break;
case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
// [pointee type, address space]
if (Record.size() < 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned AddressSpace = 0;
if (Record.size() == 2)
AddressSpace = Record[1];
ResultTy = getTypeByID(Record[0]);
if (!ResultTy)
- return Error(BitcodeError::InvalidType);
+ return Error("Invalid type");
ResultTy = PointerType::get(ResultTy, AddressSpace);
break;
}
@@ -897,7 +954,7 @@ std::error_code BitcodeReader::ParseType
// FIXME: attrid is dead, remove it in LLVM 4.0
// FUNCTION: [vararg, attrid, retty, paramty x N]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Type*, 8> ArgTys;
for (unsigned i = 3, e = Record.size(); i != e; ++i) {
if (Type *T = getTypeByID(Record[i]))
@@ -908,7 +965,7 @@ std::error_code BitcodeReader::ParseType
ResultTy = getTypeByID(Record[2]);
if (!ResultTy || ArgTys.size() < Record.size()-3)
- return Error(BitcodeError::InvalidType);
+ return Error("Invalid type");
ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
break;
@@ -916,7 +973,7 @@ std::error_code BitcodeReader::ParseType
case bitc::TYPE_CODE_FUNCTION: {
// FUNCTION: [vararg, retty, paramty x N]
if (Record.size() < 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Type*, 8> ArgTys;
for (unsigned i = 2, e = Record.size(); i != e; ++i) {
if (Type *T = getTypeByID(Record[i]))
@@ -927,14 +984,14 @@ std::error_code BitcodeReader::ParseType
ResultTy = getTypeByID(Record[1]);
if (!ResultTy || ArgTys.size() < Record.size()-2)
- return Error(BitcodeError::InvalidType);
+ return Error("Invalid type");
ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
break;
}
case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N]
if (Record.size() < 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Type*, 8> EltTys;
for (unsigned i = 1, e = Record.size(); i != e; ++i) {
if (Type *T = getTypeByID(Record[i]))
@@ -943,21 +1000,21 @@ std::error_code BitcodeReader::ParseType
break;
}
if (EltTys.size() != Record.size()-1)
- return Error(BitcodeError::InvalidType);
+ return Error("Invalid type");
ResultTy = StructType::get(Context, EltTys, Record[0]);
break;
}
case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N]
if (ConvertToString(Record, 0, TypeName))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
continue;
case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
if (Record.size() < 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (NumRecords >= TypeList.size())
- return Error(BitcodeError::InvalidTYPETable);
+ return Error("Invalid TYPE table");
// Check to see if this was forward referenced, if so fill in the temp.
StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
@@ -976,17 +1033,17 @@ std::error_code BitcodeReader::ParseType
break;
}
if (EltTys.size() != Record.size()-1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Res->setBody(EltTys, Record[0]);
ResultTy = Res;
break;
}
case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: []
if (Record.size() != 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (NumRecords >= TypeList.size())
- return Error(BitcodeError::InvalidTYPETable);
+ return Error("Invalid TYPE table");
// Check to see if this was forward referenced, if so fill in the temp.
StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
@@ -1001,24 +1058,24 @@ std::error_code BitcodeReader::ParseType
}
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::ParseType
std::error_code BitcodeReader::ParseValueSymbolTable() {
if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<uint64_t, 64> Record;
@@ -1039,7 +1096,7 @@ std::error_code BitcodeReader::ParseValu
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
case BitstreamEntry::Record:
@@ -1054,10 +1111,10 @@ std::error_code BitcodeReader::ParseValu
break;
case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
if (ConvertToString(Record, 1, ValueName))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned ValueID = Record[0];
if (ValueID >= ValueList.size() || !ValueList[ValueID])
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Value *V = ValueList[ValueID];
V->setName(StringRef(ValueName.data(), ValueName.size()));
@@ -1066,10 +1123,10 @@ std::error_code BitcodeReader::ParseValu
}
case bitc::VST_CODE_BBENTRY: {
if (ConvertToString(Record, 1, ValueName))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
BasicBlock *BB = getBasicBlock(Record[0]);
if (!BB)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
BB->setName(StringRef(ValueName.data(), ValueName.size()));
ValueName.clear();
@@ -1083,7 +1140,7 @@ std::error_code BitcodeReader::ParseMeta
unsigned NextMDValueNo = MDValueList.size();
if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<uint64_t, 64> Record;
@@ -1094,7 +1151,7 @@ std::error_code BitcodeReader::ParseMeta
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
MDValueList.tryToResolveCycles();
return std::error_code();
@@ -1126,7 +1183,7 @@ std::error_code BitcodeReader::ParseMeta
for (unsigned i = 0; i != Size; ++i) {
MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i]));
if (!MD)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
NMD->addOperand(MD);
}
break;
@@ -1136,7 +1193,7 @@ std::error_code BitcodeReader::ParseMeta
// This is a LocalAsMetadata record, the only type of function-local
// metadata.
if (Record.size() % 2 == 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// If this isn't a LocalAsMetadata record, we're dropping it. This used
// to be legal, but there's no upgrade path.
@@ -1162,14 +1219,14 @@ std::error_code BitcodeReader::ParseMeta
case bitc::METADATA_OLD_NODE: {
// FIXME: Remove in 4.0.
if (Record.size() % 2 == 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned Size = Record.size();
SmallVector<Metadata *, 8> Elts;
for (unsigned i = 0; i != Size; i += 2) {
Type *Ty = getTypeByID(Record[i]);
if (!Ty)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (Ty->isMetadataTy())
Elts.push_back(MDValueList.getValueFwdRef(Record[i+1]));
else if (!Ty->isVoidTy()) {
@@ -1186,11 +1243,11 @@ std::error_code BitcodeReader::ParseMeta
}
case bitc::METADATA_VALUE: {
if (Record.size() != 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (Ty->isMetadataTy() || Ty->isVoidTy())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
MDValueList.AssignValue(
ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
@@ -1219,14 +1276,14 @@ std::error_code BitcodeReader::ParseMeta
}
case bitc::METADATA_KIND: {
if (Record.size() < 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned Kind = Record[0];
SmallString<8> Name(Record.begin()+1, Record.end());
unsigned NewKind = TheModule->getMDKindID(Name.str());
if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
- return Error(BitcodeError::ConflictingMETADATA_KINDRecords);
+ return Error("Conflicting METADATA_KIND records");
break;
}
}
@@ -1266,7 +1323,7 @@ std::error_code BitcodeReader::ResolveGl
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
GlobalInitWorklist.back().first->setInitializer(C);
else
- return Error(BitcodeError::ExpectedConstant);
+ return Error("Expected a constant");
}
GlobalInitWorklist.pop_back();
}
@@ -1279,7 +1336,7 @@ std::error_code BitcodeReader::ResolveGl
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
AliasInitWorklist.back().first->setAliasee(C);
else
- return Error(BitcodeError::ExpectedConstant);
+ return Error("Expected a constant");
}
AliasInitWorklist.pop_back();
}
@@ -1292,7 +1349,7 @@ std::error_code BitcodeReader::ResolveGl
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
FunctionPrefixWorklist.back().first->setPrefixData(C);
else
- return Error(BitcodeError::ExpectedConstant);
+ return Error("Expected a constant");
}
FunctionPrefixWorklist.pop_back();
}
@@ -1305,7 +1362,7 @@ std::error_code BitcodeReader::ResolveGl
if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
FunctionPrologueWorklist.back().first->setPrologueData(C);
else
- return Error(BitcodeError::ExpectedConstant);
+ return Error("Expected a constant");
}
FunctionPrologueWorklist.pop_back();
}
@@ -1323,7 +1380,7 @@ static APInt ReadWideAPInt(ArrayRef<uint
std::error_code BitcodeReader::ParseConstants() {
if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<uint64_t, 64> Record;
@@ -1336,10 +1393,10 @@ std::error_code BitcodeReader::ParseCons
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
if (NextCstNo != ValueList.size())
- return Error(BitcodeError::InvalidConstantReference);
+ return Error("Invalid ronstant reference");
// Once all the constants have been read, go through and resolve forward
// references.
@@ -1361,9 +1418,9 @@ std::error_code BitcodeReader::ParseCons
break;
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
if (Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
CurTy = TypeList[Record[0]];
continue; // Skip the ValueList manipulation.
case bitc::CST_CODE_NULL: // NULL
@@ -1371,12 +1428,12 @@ std::error_code BitcodeReader::ParseCons
break;
case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
if (!CurTy->isIntegerTy() || Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
break;
case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
if (!CurTy->isIntegerTy() || Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
APInt VInt = ReadWideAPInt(Record,
cast<IntegerType>(CurTy)->getBitWidth());
@@ -1386,7 +1443,7 @@ std::error_code BitcodeReader::ParseCons
}
case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
if (Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (CurTy->isHalfTy())
V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf,
APInt(16, (uint16_t)Record[0])));
@@ -1416,7 +1473,7 @@ std::error_code BitcodeReader::ParseCons
case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
if (Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned Size = Record.size();
SmallVector<Constant*, 16> Elts;
@@ -1444,7 +1501,7 @@ std::error_code BitcodeReader::ParseCons
case bitc::CST_CODE_STRING: // STRING: [values]
case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
if (Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallString<16> Elts(Record.begin(), Record.end());
V = ConstantDataArray::getString(Context, Elts,
@@ -1453,7 +1510,7 @@ std::error_code BitcodeReader::ParseCons
}
case bitc::CST_CODE_DATA: {// DATA: [n x value]
if (Record.empty())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
unsigned Size = Record.size();
@@ -1498,14 +1555,14 @@ std::error_code BitcodeReader::ParseCons
else
V = ConstantDataArray::get(Context, Elts);
} else {
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
}
break;
}
case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
if (Opc < 0) {
V = UndefValue::get(CurTy); // Unknown binop.
@@ -1536,14 +1593,14 @@ std::error_code BitcodeReader::ParseCons
}
case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
int Opc = GetDecodedCastOpcode(Record[0]);
if (Opc < 0) {
V = UndefValue::get(CurTy); // Unknown cast.
} else {
Type *OpTy = getTypeByID(Record[1]);
if (!OpTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
V = UpgradeBitCastExpr(Opc, Op, CurTy);
if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy);
@@ -1553,12 +1610,12 @@ std::error_code BitcodeReader::ParseCons
case bitc::CST_CODE_CE_INBOUNDS_GEP:
case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands]
if (Record.size() & 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Constant*, 16> Elts;
for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
Type *ElTy = getTypeByID(Record[i]);
if (!ElTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
}
ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
@@ -1569,7 +1626,7 @@ std::error_code BitcodeReader::ParseCons
}
case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *SelectorTy = Type::getInt1Ty(Context);
@@ -1588,22 +1645,22 @@ std::error_code BitcodeReader::ParseCons
case bitc::CST_CODE_CE_EXTRACTELT
: { // CE_EXTRACTELT: [opty, opval, opty, opval]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
VectorType *OpTy =
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
if (!OpTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
Constant *Op1 = nullptr;
if (Record.size() == 4) {
Type *IdxTy = getTypeByID(Record[2]);
if (!IdxTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy);
} else // TODO: Remove with llvm 4.0
Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
if (!Op1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
V = ConstantExpr::getExtractElement(Op0, Op1);
break;
}
@@ -1611,7 +1668,7 @@ std::error_code BitcodeReader::ParseCons
: { // CE_INSERTELT: [opval, opval, opty, opval]
VectorType *OpTy = dyn_cast<VectorType>(CurTy);
if (Record.size() < 3 || !OpTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
OpTy->getElementType());
@@ -1619,19 +1676,19 @@ std::error_code BitcodeReader::ParseCons
if (Record.size() == 4) {
Type *IdxTy = getTypeByID(Record[2]);
if (!IdxTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy);
} else // TODO: Remove with llvm 4.0
Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
if (!Op2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
break;
}
case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
VectorType *OpTy = dyn_cast<VectorType>(CurTy);
if (Record.size() < 3 || !OpTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
@@ -1645,7 +1702,7 @@ std::error_code BitcodeReader::ParseCons
VectorType *OpTy =
dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
if (Record.size() < 4 || !RTy || !OpTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
@@ -1656,10 +1713,10 @@ std::error_code BitcodeReader::ParseCons
}
case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
if (Record.size() < 4)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *OpTy = getTypeByID(Record[0]);
if (!OpTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
@@ -1673,16 +1730,16 @@ std::error_code BitcodeReader::ParseCons
// FIXME: Remove with the 4.0 release.
case bitc::CST_CODE_INLINEASM_OLD: {
if (Record.size() < 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
std::string AsmStr, ConstrStr;
bool HasSideEffects = Record[0] & 1;
bool IsAlignStack = Record[0] >> 1;
unsigned AsmStrSize = Record[1];
if (2+AsmStrSize >= Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned ConstStrSize = Record[2+AsmStrSize];
if (3+AsmStrSize+ConstStrSize > Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
for (unsigned i = 0; i != AsmStrSize; ++i)
AsmStr += (char)Record[2+i];
@@ -1697,17 +1754,17 @@ std::error_code BitcodeReader::ParseCons
// inteldialect).
case bitc::CST_CODE_INLINEASM: {
if (Record.size() < 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
std::string AsmStr, ConstrStr;
bool HasSideEffects = Record[0] & 1;
bool IsAlignStack = (Record[0] >> 1) & 1;
unsigned AsmDialect = Record[0] >> 2;
unsigned AsmStrSize = Record[1];
if (2+AsmStrSize >= Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned ConstStrSize = Record[2+AsmStrSize];
if (3+AsmStrSize+ConstStrSize > Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
for (unsigned i = 0; i != AsmStrSize; ++i)
AsmStr += (char)Record[2+i];
@@ -1721,14 +1778,14 @@ std::error_code BitcodeReader::ParseCons
}
case bitc::CST_CODE_BLOCKADDRESS:{
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *FnTy = getTypeByID(Record[0]);
if (!FnTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Function *Fn =
dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
if (!Fn)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// Don't let Fn get dematerialized.
BlockAddressesTaken.insert(Fn);
@@ -1739,12 +1796,12 @@ std::error_code BitcodeReader::ParseCons
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::ParseCons
std::error_code BitcodeReader::ParseUseLists() {
if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// Read all the records.
SmallVector<uint64_t, 64> Record;
@@ -1782,7 +1839,7 @@ std::error_code BitcodeReader::ParseUseL
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
case BitstreamEntry::Record:
@@ -1803,7 +1860,7 @@ std::error_code BitcodeReader::ParseUseL
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::ParseUseL
std::error_code BitcodeReader::RememberAndSkipFunctionBody() {
// Get the function we are talking about.
if (FunctionsWithBodies.empty())
- return Error(BitcodeError::InsufficientFunctionProtos);
+ return Error("Insufficient function protos");
Function *Fn = FunctionsWithBodies.back();
FunctionsWithBodies.pop_back();
@@ -1851,7 +1908,7 @@ std::error_code BitcodeReader::RememberA
// Skip over the function block for now.
if (Stream.SkipBlock())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
return std::error_code();
}
@@ -1859,7 +1916,7 @@ std::error_code BitcodeReader::GlobalCle
// Patch the initializers for globals and aliases up.
ResolveGlobalAndAliasInits();
if (!GlobalInits.empty() || !AliasInits.empty())
- return Error(BitcodeError::MalformedGlobalInitializerSet);
+ return Error("Malformed global initializer set");
// Look for intrinsic functions which need to be upgraded at some point
for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
@@ -1888,7 +1945,7 @@ std::error_code BitcodeReader::ParseModu
if (Resume)
Stream.JumpToBit(NextUnreadBit);
else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<uint64_t, 64> Record;
std::vector<std::string> SectionTable;
@@ -1900,7 +1957,7 @@ std::error_code BitcodeReader::ParseModu
switch (Entry.Kind) {
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return GlobalCleanup();
@@ -1908,11 +1965,11 @@ std::error_code BitcodeReader::ParseModu
switch (Entry.ID) {
default: // Skip unknown content.
if (Stream.SkipBlock())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
break;
case bitc::BLOCKINFO_BLOCK_ID:
if (Stream.ReadBlockInfoBlock())
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
break;
case bitc::PARAMATTR_BLOCK_ID:
if (std::error_code EC = ParseAttributeBlock())
@@ -1982,12 +2039,12 @@ std::error_code BitcodeReader::ParseModu
default: break; // Default behavior, ignore unknown content.
case bitc::MODULE_CODE_VERSION: { // VERSION: [version#]
if (Record.size() < 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// Only version #0 and #1 are supported so far.
unsigned module_version = Record[0];
switch (module_version) {
default:
- return Error(BitcodeError::InvalidValue);
+ return Error("Invalid value");
case 0:
UseRelativeIDs = false;
break;
@@ -2000,21 +2057,21 @@ std::error_code BitcodeReader::ParseModu
case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
TheModule->setTargetTriple(S);
break;
}
case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
TheModule->setDataLayout(S);
break;
}
case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
TheModule->setModuleInlineAsm(S);
break;
}
@@ -2022,27 +2079,27 @@ std::error_code BitcodeReader::ParseModu
// FIXME: Remove in 4.0.
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// Ignore value.
break;
}
case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SectionTable.push_back(S);
break;
}
case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
GCTable.push_back(S);
break;
}
case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name]
if (Record.size() < 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]);
unsigned ComdatNameSize = Record[1];
std::string ComdatName;
@@ -2059,12 +2116,12 @@ std::error_code BitcodeReader::ParseModu
// unnamed_addr, dllstorageclass]
case bitc::MODULE_CODE_GLOBALVAR: {
if (Record.size() < 6)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (!Ty->isPointerTy())
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
Ty = cast<PointerType>(Ty)->getElementType();
@@ -2074,7 +2131,7 @@ std::error_code BitcodeReader::ParseModu
std::string Section;
if (Record[5]) {
if (Record[5]-1 >= SectionTable.size())
- return Error(BitcodeError::InvalidID);
+ return Error("Invalid ID");
Section = SectionTable[Record[5]-1];
}
GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
@@ -2127,16 +2184,16 @@ std::error_code BitcodeReader::ParseModu
// prologuedata, dllstorageclass, comdat, prefixdata]
case bitc::MODULE_CODE_FUNCTION: {
if (Record.size() < 8)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (!Ty->isPointerTy())
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
FunctionType *FTy =
dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
if (!FTy)
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
"", TheModule);
@@ -2149,7 +2206,7 @@ std::error_code BitcodeReader::ParseModu
Func->setAlignment((1 << Record[5]) >> 1);
if (Record[6]) {
if (Record[6]-1 >= SectionTable.size())
- return Error(BitcodeError::InvalidID);
+ return Error("Invalid ID");
Func->setSection(SectionTable[Record[6]-1]);
}
// Local linkage must have default visibility.
@@ -2158,7 +2215,7 @@ std::error_code BitcodeReader::ParseModu
Func->setVisibility(GetDecodedVisibility(Record[7]));
if (Record.size() > 8 && Record[8]) {
if (Record[8]-1 > GCTable.size())
- return Error(BitcodeError::InvalidID);
+ return Error("Invalid ID");
Func->setGC(GCTable[Record[8]-1].c_str());
}
bool UnnamedAddr = false;
@@ -2198,13 +2255,13 @@ std::error_code BitcodeReader::ParseModu
// ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass]
case bitc::MODULE_CODE_ALIAS: {
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
auto *PTy = dyn_cast<PointerType>(Ty);
if (!PTy)
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
auto *NewGA =
GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
@@ -2230,7 +2287,7 @@ std::error_code BitcodeReader::ParseModu
case bitc::MODULE_CODE_PURGEVALS:
// Trim down the value list to the specified size.
if (Record.size() < 1 || Record[0] > ValueList.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
ValueList.shrinkTo(Record[0]);
break;
}
@@ -2251,7 +2308,7 @@ std::error_code BitcodeReader::ParseBitc
Stream.Read(4) != 0xC ||
Stream.Read(4) != 0xE ||
Stream.Read(4) != 0xD)
- return Error(BitcodeError::InvalidBitcodeSignature);
+ return Error("Invalid bitcode signature");
// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.
@@ -2264,7 +2321,7 @@ std::error_code BitcodeReader::ParseBitc
switch (Entry.Kind) {
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
@@ -2272,12 +2329,12 @@ std::error_code BitcodeReader::ParseBitc
switch (Entry.ID) {
case bitc::BLOCKINFO_BLOCK_ID:
if (Stream.ReadBlockInfoBlock())
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
break;
case bitc::MODULE_BLOCK_ID:
// Reject multiple MODULE_BLOCK's in a single bitstream.
if (TheModule)
- return Error(BitcodeError::InvalidMultipleBlocks);
+ return Error("Invalid multiple blocks");
TheModule = M;
if (std::error_code EC = ParseModule(false))
return EC;
@@ -2286,7 +2343,7 @@ std::error_code BitcodeReader::ParseBitc
break;
default:
if (Stream.SkipBlock())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
break;
}
continue;
@@ -2301,14 +2358,14 @@ std::error_code BitcodeReader::ParseBitc
Stream.AtEndOfStream())
return std::error_code();
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
}
}
ErrorOr<std::string> BitcodeReader::parseModuleTriple() {
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<uint64_t, 64> Record;
@@ -2320,7 +2377,7 @@ ErrorOr<std::string> BitcodeReader::pars
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return Triple;
case BitstreamEntry::Record:
@@ -2334,7 +2391,7 @@ ErrorOr<std::string> BitcodeReader::pars
case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
std::string S;
if (ConvertToString(Record, 0, S))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Triple = S;
break;
}
@@ -2355,7 +2412,7 @@ ErrorOr<std::string> BitcodeReader::pars
Stream.Read(4) != 0xC ||
Stream.Read(4) != 0xE ||
Stream.Read(4) != 0xD)
- return Error(BitcodeError::InvalidBitcodeSignature);
+ return Error("Invalid bitcode signature");
// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.
@@ -2364,7 +2421,7 @@ ErrorOr<std::string> BitcodeReader::pars
switch (Entry.Kind) {
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
@@ -2374,7 +2431,7 @@ ErrorOr<std::string> BitcodeReader::pars
// Ignore other sub-blocks.
if (Stream.SkipBlock())
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
continue;
case BitstreamEntry::Record:
@@ -2387,7 +2444,7 @@ ErrorOr<std::string> BitcodeReader::pars
/// ParseMetadataAttachment - Parse metadata attachments.
std::error_code BitcodeReader::ParseMetadataAttachment() {
if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<uint64_t, 64> Record;
while (1) {
@@ -2396,7 +2453,7 @@ std::error_code BitcodeReader::ParseMeta
switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
return std::error_code();
case BitstreamEntry::Record:
@@ -2412,14 +2469,14 @@ std::error_code BitcodeReader::ParseMeta
case bitc::METADATA_ATTACHMENT: {
unsigned RecordLength = Record.size();
if (Record.empty() || (RecordLength - 1) % 2 == 1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Instruction *Inst = InstructionList[Record[0]];
for (unsigned i = 1; i != RecordLength; i = i+2) {
unsigned Kind = Record[i];
DenseMap<unsigned, unsigned>::iterator I =
MDKindMap.find(Kind);
if (I == MDKindMap.end())
- return Error(BitcodeError::InvalidID);
+ return Error("Invalid ID");
Metadata *Node = MDValueList.getValueFwdRef(Record[i + 1]);
if (isa<LocalAsMetadata>(Node))
// Drop the attachment. This used to be legal, but there's no
@@ -2438,7 +2495,7 @@ std::error_code BitcodeReader::ParseMeta
/// ParseFunctionBody - Lazily parse the specified function body block.
std::error_code BitcodeReader::ParseFunctionBody(Function *F) {
if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
InstructionList.clear();
unsigned ModuleValueListSize = ValueList.size();
@@ -2469,7 +2526,7 @@ std::error_code BitcodeReader::ParseFunc
switch (Entry.Kind) {
case BitstreamEntry::Error:
- return Error(BitcodeError::MalformedBlock);
+ return Error("Malformed block");
case BitstreamEntry::EndBlock:
goto OutOfRecordLoop;
@@ -2477,7 +2534,7 @@ std::error_code BitcodeReader::ParseFunc
switch (Entry.ID) {
default: // Skip unknown content.
if (Stream.SkipBlock())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
break;
case bitc::CONSTANTS_BLOCK_ID:
if (std::error_code EC = ParseConstants())
@@ -2514,10 +2571,10 @@ std::error_code BitcodeReader::ParseFunc
unsigned BitCode = Stream.readRecord(Entry.ID, Record);
switch (BitCode) {
default: // Default behavior: reject
- return Error(BitcodeError::InvalidValue);
+ return Error("Invalid value");
case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks]
if (Record.size() < 1 || Record[0] == 0)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// Create all the basic blocks for the function.
FunctionBBs.resize(Record[0]);
@@ -2530,7 +2587,7 @@ std::error_code BitcodeReader::ParseFunc
auto &BBRefs = BBFRI->second;
// Check for invalid basic block references.
if (BBRefs.size() > FunctionBBs.size())
- return Error(BitcodeError::InvalidID);
+ return Error("Invalid ID");
assert(!BBRefs.empty() && "Unexpected empty array");
assert(!BBRefs.front() && "Invalid reference to entry block");
for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
@@ -2556,7 +2613,7 @@ std::error_code BitcodeReader::ParseFunc
I = getLastInstruction();
if (!I)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I->setDebugLoc(LastLoc);
I = nullptr;
continue;
@@ -2564,7 +2621,7 @@ std::error_code BitcodeReader::ParseFunc
case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia]
I = getLastInstruction();
if (!I || Record.size() < 4)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned Line = Record[0], Col = Record[1];
unsigned ScopeID = Record[2], IAID = Record[3];
@@ -2584,11 +2641,11 @@ std::error_code BitcodeReader::ParseFunc
if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
OpNum+1 > Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
if (Opc == -1)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
InstructionList.push_back(I);
if (OpNum < Record.size()) {
@@ -2630,12 +2687,12 @@ std::error_code BitcodeReader::ParseFunc
Value *Op;
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
OpNum+2 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *ResTy = getTypeByID(Record[OpNum]);
int Opc = GetDecodedCastOpcode(Record[OpNum+1]);
if (Opc == -1 || !ResTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Instruction *Temp = nullptr;
if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
if (Temp) {
@@ -2653,13 +2710,13 @@ std::error_code BitcodeReader::ParseFunc
unsigned OpNum = 0;
Value *BasePtr;
if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Value*, 16> GEPIdx;
while (OpNum != Record.size()) {
Value *Op;
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
GEPIdx.push_back(Op);
}
@@ -2675,14 +2732,14 @@ std::error_code BitcodeReader::ParseFunc
unsigned OpNum = 0;
Value *Agg;
if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<unsigned, 4> EXTRACTVALIdx;
for (unsigned RecSize = Record.size();
OpNum != RecSize; ++OpNum) {
uint64_t Index = Record[OpNum];
if ((unsigned)Index != Index)
- return Error(BitcodeError::InvalidValue);
+ return Error("Invalid value");
EXTRACTVALIdx.push_back((unsigned)Index);
}
@@ -2696,17 +2753,17 @@ std::error_code BitcodeReader::ParseFunc
unsigned OpNum = 0;
Value *Agg;
if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Value *Val;
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<unsigned, 4> INSERTVALIdx;
for (unsigned RecSize = Record.size();
OpNum != RecSize; ++OpNum) {
uint64_t Index = Record[OpNum];
if ((unsigned)Index != Index)
- return Error(BitcodeError::InvalidValue);
+ return Error("Invalid value");
INSERTVALIdx.push_back((unsigned)Index);
}
@@ -2723,7 +2780,7 @@ std::error_code BitcodeReader::ParseFunc
if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = SelectInst::Create(Cond, TrueVal, FalseVal);
InstructionList.push_back(I);
@@ -2738,18 +2795,18 @@ std::error_code BitcodeReader::ParseFunc
if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
getValueTypePair(Record, OpNum, NextValueNo, Cond))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
// select condition can be either i1 or [N x i1]
if (VectorType* vector_type =
dyn_cast<VectorType>(Cond->getType())) {
// expect <n x i1>
if (vector_type->getElementType() != Type::getInt1Ty(Context))
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
} else {
// expect i1
if (Cond->getType() != Type::getInt1Ty(Context))
- return Error(BitcodeError::InvalidTypeForValue);
+ return Error("Invalid type for value");
}
I = SelectInst::Create(Cond, TrueVal, FalseVal);
@@ -2762,7 +2819,7 @@ std::error_code BitcodeReader::ParseFunc
Value *Vec, *Idx;
if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
getValueTypePair(Record, OpNum, NextValueNo, Idx))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = ExtractElementInst::Create(Vec, Idx);
InstructionList.push_back(I);
break;
@@ -2775,7 +2832,7 @@ std::error_code BitcodeReader::ParseFunc
popValue(Record, OpNum, NextValueNo,
cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
getValueTypePair(Record, OpNum, NextValueNo, Idx))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = InsertElementInst::Create(Vec, Elt, Idx);
InstructionList.push_back(I);
break;
@@ -2786,10 +2843,10 @@ std::error_code BitcodeReader::ParseFunc
Value *Vec1, *Vec2, *Mask;
if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = new ShuffleVectorInst(Vec1, Vec2, Mask);
InstructionList.push_back(I);
break;
@@ -2807,7 +2864,7 @@ std::error_code BitcodeReader::ParseFunc
if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
OpNum+1 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (LHS->getType()->isFPOrFPVectorTy())
I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
@@ -2829,9 +2886,9 @@ std::error_code BitcodeReader::ParseFunc
unsigned OpNum = 0;
Value *Op = nullptr;
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (OpNum != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = ReturnInst::Create(Context, Op);
InstructionList.push_back(I);
@@ -2839,10 +2896,10 @@ std::error_code BitcodeReader::ParseFunc
}
case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
if (Record.size() != 1 && Record.size() != 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
BasicBlock *TrueDest = getBasicBlock(Record[0]);
if (!TrueDest)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (Record.size() == 1) {
I = BranchInst::Create(TrueDest);
@@ -2853,7 +2910,7 @@ std::error_code BitcodeReader::ParseFunc
Value *Cond = getValue(Record, 2, NextValueNo,
Type::getInt1Ty(Context));
if (!FalseDest || !Cond)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = BranchInst::Create(TrueDest, FalseDest, Cond);
InstructionList.push_back(I);
}
@@ -2873,7 +2930,7 @@ std::error_code BitcodeReader::ParseFunc
Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
BasicBlock *Default = getBasicBlock(Record[3]);
if (!OpTy || !Cond || !Default)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned NumCases = Record[4];
@@ -2925,12 +2982,12 @@ std::error_code BitcodeReader::ParseFunc
// Old SwitchInst format without case ranges.
if (Record.size() < 3 || (Record.size() & 1) == 0)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *OpTy = getTypeByID(Record[0]);
Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
BasicBlock *Default = getBasicBlock(Record[2]);
if (!OpTy || !Cond || !Default)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned NumCases = (Record.size()-3)/2;
SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
InstructionList.push_back(SI);
@@ -2940,7 +2997,7 @@ std::error_code BitcodeReader::ParseFunc
BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
if (!CaseVal || !DestBB) {
delete SI;
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
SI->addCase(CaseVal, DestBB);
}
@@ -2949,11 +3006,11 @@ std::error_code BitcodeReader::ParseFunc
}
case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
if (Record.size() < 2)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *OpTy = getTypeByID(Record[0]);
Value *Address = getValue(Record, 1, NextValueNo, OpTy);
if (!OpTy || !Address)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
unsigned NumDests = Record.size()-2;
IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
InstructionList.push_back(IBI);
@@ -2962,7 +3019,7 @@ std::error_code BitcodeReader::ParseFunc
IBI->addDestination(DestBB);
} else {
delete IBI;
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
}
I = IBI;
@@ -2972,7 +3029,7 @@ std::error_code BitcodeReader::ParseFunc
case bitc::FUNC_CODE_INST_INVOKE: {
// INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
if (Record.size() < 4)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AttributeSet PAL = getAttributes(Record[0]);
unsigned CCInfo = Record[1];
BasicBlock *NormalBB = getBasicBlock(Record[2]);
@@ -2981,7 +3038,7 @@ std::error_code BitcodeReader::ParseFunc
unsigned OpNum = 4;
Value *Callee;
if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
FunctionType *FTy = !CalleeTy ? nullptr :
@@ -2990,25 +3047,25 @@ std::error_code BitcodeReader::ParseFunc
// Check that the right number of fixed parameters are here.
if (!FTy || !NormalBB || !UnwindBB ||
Record.size() < OpNum+FTy->getNumParams())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Value*, 16> Ops;
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
Ops.push_back(getValue(Record, OpNum, NextValueNo,
FTy->getParamType(i)));
if (!Ops.back())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
if (!FTy->isVarArg()) {
if (Record.size() != OpNum)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
} else {
// Read type/value pairs for varargs params.
while (OpNum != Record.size()) {
Value *Op;
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Ops.push_back(Op);
}
}
@@ -3024,7 +3081,7 @@ std::error_code BitcodeReader::ParseFunc
unsigned Idx = 0;
Value *Val = nullptr;
if (getValueTypePair(Record, Idx, NextValueNo, Val))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = ResumeInst::Create(Val);
InstructionList.push_back(I);
break;
@@ -3035,10 +3092,10 @@ std::error_code BitcodeReader::ParseFunc
break;
case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
if (Record.size() < 1 || ((Record.size()-1)&1))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
InstructionList.push_back(PN);
@@ -3054,7 +3111,7 @@ std::error_code BitcodeReader::ParseFunc
V = getValue(Record, 1+i, NextValueNo, Ty);
BasicBlock *BB = getBasicBlock(Record[2+i]);
if (!V || !BB)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
PN->addIncoming(V, BB);
}
I = PN;
@@ -3065,13 +3122,13 @@ std::error_code BitcodeReader::ParseFunc
// LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
unsigned Idx = 0;
if (Record.size() < 4)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *Ty = getTypeByID(Record[Idx++]);
if (!Ty)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Value *PersFn = nullptr;
if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
bool IsCleanup = !!Record[Idx++];
unsigned NumClauses = Record[Idx++];
@@ -3084,7 +3141,7 @@ std::error_code BitcodeReader::ParseFunc
if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
delete LP;
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
assert((CT != LandingPadInst::Catch ||
@@ -3103,7 +3160,7 @@ std::error_code BitcodeReader::ParseFunc
case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
if (Record.size() != 4)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
PointerType *Ty =
dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
Type *OpTy = getTypeByID(Record[1]);
@@ -3112,7 +3169,7 @@ std::error_code BitcodeReader::ParseFunc
bool InAlloca = AlignRecord & (1 << 5);
unsigned Align = AlignRecord & ((1 << 5) - 1);
if (!Ty || !Size)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AllocaInst *AI = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
AI->setUsedWithInAlloca(InAlloca);
I = AI;
@@ -3124,7 +3181,7 @@ std::error_code BitcodeReader::ParseFunc
Value *Op;
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
OpNum+2 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
InstructionList.push_back(I);
@@ -3136,14 +3193,14 @@ std::error_code BitcodeReader::ParseFunc
Value *Op;
if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
OpNum+4 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
if (Ordering == NotAtomic || Ordering == Release ||
Ordering == AcquireRelease)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
if (Ordering != NotAtomic && Record[OpNum] == 0)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1,
@@ -3158,7 +3215,7 @@ std::error_code BitcodeReader::ParseFunc
popValue(Record, OpNum, NextValueNo,
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
OpNum+2 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
InstructionList.push_back(I);
@@ -3172,15 +3229,15 @@ std::error_code BitcodeReader::ParseFunc
popValue(Record, OpNum, NextValueNo,
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
OpNum+4 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
if (Ordering == NotAtomic || Ordering == Acquire ||
Ordering == AcquireRelease)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
if (Ordering != NotAtomic && Record[OpNum] == 0)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1,
Ordering, SynchScope);
@@ -3198,10 +3255,10 @@ std::error_code BitcodeReader::ParseFunc
popValue(Record, OpNum, NextValueNo,
cast<PointerType>(Ptr->getType())->getElementType(), New) ||
(Record.size() < OpNum + 3 || Record.size() > OpNum + 5))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]);
if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]);
AtomicOrdering FailureOrdering;
@@ -3236,14 +3293,14 @@ std::error_code BitcodeReader::ParseFunc
popValue(Record, OpNum, NextValueNo,
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
OpNum+4 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]);
if (Operation < AtomicRMWInst::FIRST_BINOP ||
Operation > AtomicRMWInst::LAST_BINOP)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
if (Ordering == NotAtomic || Ordering == Unordered)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope);
cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
@@ -3252,11 +3309,11 @@ std::error_code BitcodeReader::ParseFunc
}
case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope]
if (2 != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AtomicOrdering Ordering = GetDecodedOrdering(Record[0]);
if (Ordering == NotAtomic || Ordering == Unordered ||
Ordering == Monotonic)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]);
I = new FenceInst(Context, Ordering, SynchScope);
InstructionList.push_back(I);
@@ -3265,7 +3322,7 @@ std::error_code BitcodeReader::ParseFunc
case bitc::FUNC_CODE_INST_CALL: {
// CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
AttributeSet PAL = getAttributes(Record[0]);
unsigned CCInfo = Record[1];
@@ -3273,13 +3330,13 @@ std::error_code BitcodeReader::ParseFunc
unsigned OpNum = 2;
Value *Callee;
if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
FunctionType *FTy = nullptr;
if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
if (!FTy || Record.size() < FTy->getNumParams()+OpNum)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
SmallVector<Value*, 16> Args;
// Read the fixed params.
@@ -3290,18 +3347,18 @@ std::error_code BitcodeReader::ParseFunc
Args.push_back(getValue(Record, OpNum, NextValueNo,
FTy->getParamType(i)));
if (!Args.back())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
}
// Read type/value pairs for varargs params.
if (!FTy->isVarArg()) {
if (OpNum != Record.size())
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
} else {
while (OpNum != Record.size()) {
Value *Op;
if (getValueTypePair(Record, OpNum, NextValueNo, Op))
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Args.push_back(Op);
}
}
@@ -3321,12 +3378,12 @@ std::error_code BitcodeReader::ParseFunc
}
case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
if (Record.size() < 3)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
Type *OpTy = getTypeByID(Record[0]);
Value *Op = getValue(Record, 1, NextValueNo, OpTy);
Type *ResTy = getTypeByID(Record[2]);
if (!OpTy || !Op || !ResTy)
- return Error(BitcodeError::InvalidRecord);
+ return Error("Invalid record");
I = new VAArgInst(Op, ResTy);
InstructionList.push_back(I);
break;
@@ -3337,7 +3394,7 @@ std::error_code BitcodeReader::ParseFunc
// this file.
if (!CurBB) {
delete I;
- return Error(BitcodeError::InvalidInstructionWithNoBB);
+ return Error("Invalid instruction with no BB");
}
CurBB->getInstList().push_back(I);
@@ -3364,7 +3421,7 @@ OutOfRecordLoop:
delete A;
}
}
- return Error(BitcodeError::NeverResolvedValueFoundInFunction);
+ return Error("Never resolved value found in function");
}
}
@@ -3384,7 +3441,7 @@ std::error_code BitcodeReader::FindFunct
DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
while (DeferredFunctionInfoIterator->second == 0) {
if (Stream.AtEndOfStream())
- return Error(BitcodeError::CouldNotFindFunctionInStream);
+ return Error("Could not find function in stream");
// ParseModule will parse the next body in the stream and set its
// position in the DeferredFunctionInfo map.
if (std::error_code EC = ParseModule(true))
@@ -3486,7 +3543,7 @@ std::error_code BitcodeReader::Materiali
// Check that all block address forward references got resolved (as we
// promised above).
if (!BasicBlockFwdRefs.empty())
- return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress);
+ return Error("Never resolved function from blockaddress");
// Upgrade any intrinsic calls that slipped through (should not happen!) and
// delete the old functions to clean up. We can't do this unless the entire
@@ -3529,13 +3586,13 @@ std::error_code BitcodeReader::InitStrea
const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
if (Buffer->getBufferSize() & 3)
- return Error(BitcodeError::InvalidBitcodeSignature);
+ return Error("Invalid bitcode signature");
// If we have a wrapper header, parse it and ignore the non-bc file contents.
// The magic number is 0x0B17C0DE stored in little endian.
if (isBitcodeWrapper(BufPtr, BufEnd))
if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
- return Error(BitcodeError::InvalidBitcodeWrapperHeader);
+ return Error("Invalid bitcode wrapper header");
StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
Stream.init(&*StreamFile);
@@ -3553,10 +3610,10 @@ std::error_code BitcodeReader::InitLazyS
unsigned char buf[16];
if (Bytes.readBytes(buf, 16, 0) != 16)
- return Error(BitcodeError::InvalidBitcodeSignature);
+ return Error("Invalid bitcode signature");
if (!isBitcode(buf, buf + 16))
- return Error(BitcodeError::InvalidBitcodeSignature);
+ return Error("Invalid bitcode signature");
if (isBitcodeWrapper(buf, buf + 4)) {
const unsigned char *bitcodeStart = buf;
@@ -3576,44 +3633,10 @@ class BitcodeErrorCategoryType : public
std::string message(int IE) const override {
BitcodeError E = static_cast<BitcodeError>(IE);
switch (E) {
- case BitcodeError::ConflictingMETADATA_KINDRecords:
- return "Conflicting METADATA_KIND records";
- case BitcodeError::CouldNotFindFunctionInStream:
- return "Could not find function in stream";
- case BitcodeError::ExpectedConstant:
- return "Expected a constant";
- case BitcodeError::InsufficientFunctionProtos:
- return "Insufficient function protos";
case BitcodeError::InvalidBitcodeSignature:
return "Invalid bitcode signature";
- case BitcodeError::InvalidBitcodeWrapperHeader:
- return "Invalid bitcode wrapper header";
- case BitcodeError::InvalidConstantReference:
- return "Invalid ronstant reference";
- case BitcodeError::InvalidID:
- return "Invalid ID";
- case BitcodeError::InvalidInstructionWithNoBB:
- return "Invalid instruction with no BB";
- case BitcodeError::InvalidRecord:
- return "Invalid record";
- case BitcodeError::InvalidTypeForValue:
- return "Invalid type for value";
- case BitcodeError::InvalidTYPETable:
- return "Invalid TYPE table";
- case BitcodeError::InvalidType:
- return "Invalid type";
- case BitcodeError::MalformedBlock:
- return "Malformed block";
- case BitcodeError::MalformedGlobalInitializerSet:
- return "Malformed global initializer set";
- case BitcodeError::InvalidMultipleBlocks:
- return "Invalid multiple blocks";
- case BitcodeError::NeverResolvedValueFoundInFunction:
- return "Never resolved value found in function";
- case BitcodeError::NeverResolvedFunctionFromBlockAddress:
- return "Never resolved function from blockaddress";
- case BitcodeError::InvalidValue:
- return "Invalid value";
+ case BitcodeError::CorruptedBitcode:
+ return "Corrupted bitcode";
}
llvm_unreachable("Unknown error type!");
}
@@ -3640,9 +3663,11 @@ const std::error_category &llvm::Bitcode
/// materialize everything -- in particular, if this isn't truly lazy.
static ErrorOr<Module *>
getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
- LLVMContext &Context, bool WillMaterializeAll) {
+ LLVMContext &Context, bool WillMaterializeAll,
+ DiagnosticHandlerFunction DiagnosticHandler) {
Module *M = new Module(Buffer->getBufferIdentifier(), Context);
- BitcodeReader *R = new BitcodeReader(Buffer.get(), Context);
+ BitcodeReader *R =
+ new BitcodeReader(Buffer.get(), Context, DiagnosticHandler);
M->setMaterializer(R);
auto cleanupOnError = [&](std::error_code EC) {
@@ -3665,26 +3690,30 @@ getLazyBitcodeModuleImpl(std::unique_ptr
ErrorOr<Module *>
llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
- LLVMContext &Context) {
- return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false);
+ LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler) {
+ return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false,
+ DiagnosticHandler);
}
ErrorOr<std::unique_ptr<Module>>
llvm::getStreamedBitcodeModule(StringRef Name, DataStreamer *Streamer,
- LLVMContext &Context) {
+ LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler) {
std::unique_ptr<Module> M = make_unique<Module>(Name, Context);
- BitcodeReader *R = new BitcodeReader(Streamer, Context);
+ BitcodeReader *R = new BitcodeReader(Streamer, Context, DiagnosticHandler);
M->setMaterializer(R);
if (std::error_code EC = R->ParseBitcodeInto(M.get()))
return EC;
return std::move(M);
}
-ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer,
- LLVMContext &Context) {
+ErrorOr<Module *>
+llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler) {
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
- ErrorOr<Module *> ModuleOrErr =
- getLazyBitcodeModuleImpl(std::move(Buf), Context, true);
+ ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModuleImpl(
+ std::move(Buf), Context, true, DiagnosticHandler);
if (!ModuleOrErr)
return ModuleOrErr;
Module *M = ModuleOrErr.get();
@@ -3700,10 +3729,12 @@ ErrorOr<Module *> llvm::parseBitcodeFile
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 "";
Modified: llvm/trunk/lib/Bitcode/Reader/BitcodeReader.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Reader/BitcodeReader.h?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/lib/Bitcode/Reader/BitcodeReader.h (original)
+++ llvm/trunk/lib/Bitcode/Reader/BitcodeReader.h Fri Jan 9 18:07:30 2015
@@ -132,6 +132,7 @@ public:
class BitcodeReader : public GVMaterializer {
LLVMContext &Context;
+ DiagnosticHandlerFunction DiagnosticHandler;
Module *TheModule;
std::unique_ptr<MemoryBuffer> Buffer;
std::unique_ptr<BitstreamReader> StreamFile;
@@ -210,18 +211,14 @@ class BitcodeReader : public GVMateriali
SmallPtrSet<const Function *, 4> BlockAddressesTaken;
public:
- 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),
- NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C),
- MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false),
- WillMaterializeAllForwardRefs(false) {}
- explicit BitcodeReader(DataStreamer *streamer, LLVMContext &C)
- : Context(C), TheModule(nullptr), Buffer(nullptr), LazyStreamer(streamer),
- NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C),
- MDValueList(C), SeenFirstFunctionBody(false), UseRelativeIDs(false),
- WillMaterializeAllForwardRefs(false) {}
+ std::error_code Error(BitcodeError E, const Twine &Message);
+ std::error_code Error(BitcodeError E);
+ std::error_code Error(const Twine &Message);
+
+ explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C,
+ DiagnosticHandlerFunction DiagnosticHandler);
+ explicit BitcodeReader(DataStreamer *streamer, LLVMContext &C,
+ DiagnosticHandlerFunction DiagnosticHandler);
~BitcodeReader() { FreeState(); }
std::error_code materializeForwardReferencedFunctions();
Modified: llvm/trunk/lib/LTO/LTOModule.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/LTO/LTOModule.cpp?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/lib/LTO/LTOModule.cpp (original)
+++ llvm/trunk/lib/LTO/LTOModule.cpp Fri Jan 9 18:07:30 2015
@@ -17,6 +17,7 @@
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/CodeGen/Analysis.h"
#include "llvm/IR/Constants.h"
+#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
@@ -146,23 +147,42 @@ LTOModule *LTOModule::createInContext(co
return makeLTOModule(Buffer, options, errMsg, Context);
}
-static ErrorOr<Module *> parseBitcodeFileImpl(MemoryBufferRef Buffer,
- LLVMContext &Context,
- bool ShouldBeLazy) {
+static Module *parseBitcodeFileImpl(MemoryBufferRef Buffer,
+ LLVMContext &Context, bool ShouldBeLazy,
+ std::string &ErrMsg) {
+
// Find the buffer.
ErrorOr<MemoryBufferRef> MBOrErr =
IRObjectFile::findBitcodeInMemBuffer(Buffer);
- if (std::error_code EC = MBOrErr.getError())
- return EC;
+ if (std::error_code EC = MBOrErr.getError()) {
+ ErrMsg = EC.message();
+ return nullptr;
+ }
+
+ std::function<void(const DiagnosticInfo &)> DiagnosticHandler =
+ [&ErrMsg](const DiagnosticInfo &DI) {
+ raw_string_ostream Stream(ErrMsg);
+ DiagnosticPrinterRawOStream DP(Stream);
+ DI.print(DP);
+ };
- if (!ShouldBeLazy)
+ if (!ShouldBeLazy) {
// Parse the full file.
- return parseBitcodeFile(*MBOrErr, Context);
+ ErrorOr<Module *> M =
+ parseBitcodeFile(*MBOrErr, Context, DiagnosticHandler);
+ if (!M)
+ return nullptr;
+ return *M;
+ }
// Parse lazily.
std::unique_ptr<MemoryBuffer> LightweightBuf =
MemoryBuffer::getMemBuffer(*MBOrErr, false);
- return getLazyBitcodeModule(std::move(LightweightBuf), Context);
+ ErrorOr<Module *> M = getLazyBitcodeModule(std::move(LightweightBuf), Context,
+ DiagnosticHandler);
+ if (!M)
+ return nullptr;
+ return *M;
}
LTOModule *LTOModule::makeLTOModule(MemoryBufferRef Buffer,
@@ -176,13 +196,11 @@ LTOModule *LTOModule::makeLTOModule(Memo
// If we own a context, we know this is being used only for symbol
// extraction, not linking. Be lazy in that case.
- ErrorOr<Module *> MOrErr = parseBitcodeFileImpl(
- Buffer, *Context, /* ShouldBeLazy */ static_cast<bool>(OwnedContext));
- if (std::error_code EC = MOrErr.getError()) {
- errMsg = EC.message();
+ std::unique_ptr<Module> M(parseBitcodeFileImpl(
+ Buffer, *Context,
+ /* ShouldBeLazy */ static_cast<bool>(OwnedContext), errMsg));
+ if (!M)
return nullptr;
- }
- std::unique_ptr<Module> M(MOrErr.get());
std::string TripleStr = M->getTargetTriple();
if (TripleStr.empty())
Modified: llvm/trunk/lib/Linker/LinkModules.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Linker/LinkModules.cpp?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/lib/Linker/LinkModules.cpp (original)
+++ llvm/trunk/lib/Linker/LinkModules.cpp Fri Jan 9 18:07:30 2015
@@ -420,11 +420,11 @@ class ModuleLinker {
/// Functions that have replaced other functions.
SmallPtrSet<const Function *, 16> OverridingFunctions;
- Linker::DiagnosticHandlerFunction DiagnosticHandler;
+ DiagnosticHandlerFunction DiagnosticHandler;
public:
ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM,
- Linker::DiagnosticHandlerFunction DiagnosticHandler)
+ DiagnosticHandlerFunction DiagnosticHandler)
: DstM(dstM), SrcM(srcM), TypeMap(Set),
ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues),
DiagnosticHandler(DiagnosticHandler) {}
Modified: llvm/trunk/test/Bitcode/invalid.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Bitcode/invalid.ll?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/test/Bitcode/invalid.ll (original)
+++ llvm/trunk/test/Bitcode/invalid.ll Fri Jan 9 18:07:30 2015
@@ -1,6 +1,6 @@
; RUN: not llvm-dis < %s.bc 2>&1 | FileCheck %s
-; CHECK: llvm-dis{{(\.EXE|\.exe)?}}: Invalid value
+; CHECK: llvm-dis{{(\.EXE|\.exe)?}}: Unknown attribute kind (48)
; invalid.ll.bc has an invalid attribute number.
; The test checks that LLVM reports the error and doesn't access freed memory
Modified: llvm/trunk/test/LTO/invalid.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/LTO/invalid.ll?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/test/LTO/invalid.ll (original)
+++ llvm/trunk/test/LTO/invalid.ll Fri Jan 9 18:07:30 2015
@@ -1,4 +1,4 @@
; RUN: not llvm-lto %S/../Bitcode/invalid.ll.bc 2>&1 | FileCheck %s
-; CHECK: llvm-lto{{.*}}: error loading file '{{.*}}/../Bitcode/invalid.ll.bc': Invalid value
+; CHECK: llvm-lto{{.*}}: error loading file '{{.*}}/../Bitcode/invalid.ll.bc': Unknown attribute kind (48)
Modified: llvm/trunk/tools/gold/gold-plugin.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/gold/gold-plugin.cpp?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/tools/gold/gold-plugin.cpp (original)
+++ llvm/trunk/tools/gold/gold-plugin.cpp Fri Jan 9 18:07:30 2015
@@ -19,6 +19,8 @@
#include "llvm/CodeGen/Analysis.h"
#include "llvm/CodeGen/CommandFlags.h"
#include "llvm/IR/Constants.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
@@ -269,6 +271,23 @@ static bool shouldSkip(uint32_t Symflags
return false;
}
+static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+ assert(DI.getSeverity() == DS_Error && "Only expecting errors");
+ const auto &BDI = cast<BitcodeDiagnosticInfo>(DI);
+ std::error_code EC = BDI.getError();
+ if (EC == BitcodeError::InvalidBitcodeSignature)
+ return;
+
+ std::string ErrStorage;
+ {
+ raw_string_ostream OS(ErrStorage);
+ DiagnosticPrinterRawOStream DP(OS);
+ DI.print(DP);
+ }
+ message(LDPL_FATAL, "LLVM gold plugin has failed to create LTO module: %s",
+ ErrStorage.c_str());
+}
+
/// Called by gold to see whether this file is one that our plugin can handle.
/// We'll try to open it and register all the symbols with add_symbol if
/// possible.
@@ -302,11 +321,11 @@ static ld_plugin_status claim_file_hook(
BufferRef = Buffer->getMemBufferRef();
}
+ Context.setDiagnosticHandler(diagnosticHandler);
ErrorOr<std::unique_ptr<object::IRObjectFile>> ObjOrErr =
object::IRObjectFile::create(BufferRef, Context);
std::error_code EC = ObjOrErr.getError();
- if (EC == BitcodeError::InvalidBitcodeSignature ||
- EC == object::object_error::invalid_file_type ||
+ if (EC == object::object_error::invalid_file_type ||
EC == object::object_error::bitcode_section_not_found)
return LDPS_OK;
Modified: llvm/trunk/tools/llvm-dis/llvm-dis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-dis/llvm-dis.cpp?rev=225562&r1=225561&r2=225562&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-dis/llvm-dis.cpp (original)
+++ llvm/trunk/tools/llvm-dis/llvm-dis.cpp Fri Jan 9 18:07:30 2015
@@ -20,6 +20,8 @@
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/IR/AssemblyAnnotationWriter.h"
#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
@@ -112,6 +114,17 @@ public:
} // end anon namespace
+static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+ assert(DI.getSeverity() == DS_Error && "Only expecting errors");
+
+ raw_ostream &OS = errs();
+ OS << (char *)Context << ": ";
+ DiagnosticPrinterRawOStream DP(OS);
+ DI.print(DP);
+ OS << '\n';
+ exit(1);
+}
+
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
@@ -120,6 +133,7 @@ int main(int argc, char **argv) {
LLVMContext &Context = getGlobalContext();
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
+ Context.setDiagnosticHandler(diagnosticHandler, argv[0]);
cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
@@ -136,25 +150,8 @@ int main(int argc, char **argv) {
DisplayFilename = InputFilename;
ErrorOr<std::unique_ptr<Module>> MOrErr =
getStreamedBitcodeModule(DisplayFilename, Streamer, Context);
- if (std::error_code EC = MOrErr.getError())
- ErrorMessage = EC.message();
- else
- M = std::move(*MOrErr);
- if(M.get()) {
- if (std::error_code EC = M->materializeAllPermanently()) {
- ErrorMessage = EC.message();
- M.reset();
- }
- }
- }
-
- if (!M.get()) {
- errs() << argv[0] << ": ";
- if (ErrorMessage.size())
- errs() << ErrorMessage << "\n";
- else
- errs() << "bitcode didn't read correctly.\n";
- return 1;
+ M = std::move(*MOrErr);
+ M->materializeAllPermanently();
}
// Just use stdout. We won't actually print anything on it.
More information about the llvm-commits
mailing list