Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(100)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp

Issue 1310883003: Install notion of diagnostic handler into PNaCl bitcode readers. (Closed) Base URL: https://chromium.googlesource.com/native_client/pnacl-llvm.git@master
Patch Set: Fix issues in patch set 2. Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « include/llvm/IRReader/IRReader.h ('k') | lib/Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
diff --git a/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp b/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
index 85fb068830b3694a47bdfc4f32434d82a3d6b7f0..8afb02ac10a3b13d9d6ee9eb02dfb8579f48348c 100644
--- a/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
+++ b/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
@@ -18,12 +18,15 @@
#include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
#include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
#include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
+#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/IR/AutoUpgrade.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/GVMaterializer.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/OperandTraits.h"
#include "llvm/IR/Operator.h"
@@ -130,12 +133,18 @@ public:
void OverwriteValue(Value *V, NaClBcIndexSize_t Idx);
};
+static DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F,
+ LLVMContext &C) {
+ if (F)
+ return F;
+ return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); };
+}
+
class NaClBitcodeReader : public GVMaterializer {
NaClBitcodeHeader Header; // Header fields of the PNaCl bitcode file.
LLVMContext &Context;
+ DiagnosticHandlerFunction DiagnosticHandler;
Module *TheModule;
- // If non-null, stream to write verbose errors to.
- raw_ostream *Verbose;
PNaClAllowedIntrinsics AllowedIntrinsics;
std::unique_ptr<MemoryBuffer> Buffer;
std::unique_ptr<NaClBitstreamReader> StreamFile;
@@ -185,53 +194,25 @@ class NaClBitcodeReader : public GVMaterializer {
/// Integer type use for PNaCl conversion of pointers.
Type *IntPtrType;
- static const std::error_category &BitcodeErrorCategory();
-
public:
-
- /// Types of errors reported.
- enum ErrorType {
- CouldNotFindFunctionInStream // Unable to find function in bitcode stream.
- = 1, // Note: Error types must not be zero!
- InsufficientFunctionProtos,
- InvalidBitstream, // Error in bitstream format.
- InvalidBlock, // Invalid block found in bitcode.
- InvalidConstantReference, // Bad constant reference.
- InvalidDataAfterModule, // Invalid data after module.
- InvalidInstructionWithNoBB, // No basic block for instruction.
- InvalidMultipleBlocks, // Multiple blocks for a kind of block that should
- // have only one.
- InvalidRecord, // Record doesn't have expected size or structure.
- InvalidSkippedBlock, // Unable to skip unknown block in bitcode file.
- InvalidType, // Invalid type in record.
- InvalidTypeForValue, // Type of value incorrect.
- InvalidValue, // Invalid value in record.
- MalformedBlock // Unable to advance over block.
- };
-
explicit NaClBitcodeReader(MemoryBuffer *buffer, LLVMContext &C,
- raw_ostream *Verbose,
+ DiagnosticHandlerFunction DiagnosticHandler,
bool AcceptSupportedOnly)
- : Context(C), TheModule(nullptr), Verbose(Verbose), AllowedIntrinsics(&C),
- Buffer(buffer),
+ : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)),
+ TheModule(nullptr), AllowedIntrinsics(&C), Buffer(buffer),
LazyStreamer(nullptr), NextUnreadBit(0), SeenValueSymbolTable(false),
- ValueList(),
- SeenFirstFunctionBody(false),
+ ValueList(), SeenFirstFunctionBody(false),
AcceptSupportedBitcodeOnly(AcceptSupportedOnly),
- IntPtrType(IntegerType::get(C, PNaClIntPtrTypeBitSize)) {
- }
- explicit NaClBitcodeReader(StreamingMemoryObject *streamer,
- LLVMContext &C,
- raw_ostream *Verbose,
+ IntPtrType(IntegerType::get(C, PNaClIntPtrTypeBitSize)) {}
+ explicit NaClBitcodeReader(StreamingMemoryObject *streamer, LLVMContext &C,
+ DiagnosticHandlerFunction DiagnosticHandler,
bool AcceptSupportedOnly)
- : Context(C), TheModule(nullptr), Verbose(Verbose), AllowedIntrinsics(&C),
- Buffer(nullptr),
+ : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)),
+ TheModule(nullptr), AllowedIntrinsics(&C), Buffer(nullptr),
LazyStreamer(streamer), NextUnreadBit(0), SeenValueSymbolTable(false),
- ValueList(),
- SeenFirstFunctionBody(false),
+ ValueList(), SeenFirstFunctionBody(false),
AcceptSupportedBitcodeOnly(AcceptSupportedOnly),
- IntPtrType(IntegerType::get(C, PNaClIntPtrTypeBitSize)) {
- }
+ IntPtrType(IntegerType::get(C, PNaClIntPtrTypeBitSize)) {}
~NaClBitcodeReader() override {
FreeState();
}
@@ -245,12 +226,11 @@ public:
void Dematerialize(GlobalValue *GV) override;
void releaseBuffer();
- std::error_code Error(ErrorType E) const {
- return std::error_code(E, BitcodeErrorCategory());
- }
+ std::error_code Error(std::error_code EC, const Twine &Message) const;
- /// Generates the corresponding verbose Message, then generates error.
- std::error_code Error(ErrorType E, const std::string &Message) const;
+ std::error_code Error(const Twine &Message) const {
+ return Error(make_error_code(BitcodeError::CorruptedBitcode), Message);
+ }
/// Main interface to parsing a bitcode buffer. returns true if an error
/// occurred.
@@ -452,50 +432,6 @@ bool NaClBitcodeReaderValueList::createValueFwdRef(NaClBcIndexSize_t Idx,
return false;
}
-class NaClBitcodeErrorCategoryType : public std::error_category {
- const char *name() const LLVM_NOEXCEPT override {
- return "pnacl.bitcode";
- }
- std::string message(int IndexError) const override {
- switch(static_cast<NaClBitcodeReader::ErrorType>(IndexError)) {
- case NaClBitcodeReader::CouldNotFindFunctionInStream:
- return "Unable to find function in bitcode stream.";
- case NaClBitcodeReader::InsufficientFunctionProtos:
- return "Insufficient function protos";
- case NaClBitcodeReader::InvalidBitstream:
- return "Error in bitstream format";
- case NaClBitcodeReader::InvalidBlock:
- return "Invalid block found in bitcode file";
- case NaClBitcodeReader::InvalidConstantReference:
- return "Bad constant reference";
- case NaClBitcodeReader::InvalidDataAfterModule:
- return "Invalid data after module";
- case NaClBitcodeReader::InvalidInstructionWithNoBB:
- return "No basic block for instruction";
- case NaClBitcodeReader::InvalidMultipleBlocks:
- return "Multiple blocks for a kind of block that should have only one";
- case NaClBitcodeReader::InvalidRecord:
- return "Record doesn't have expected size or structure";
- case NaClBitcodeReader::InvalidSkippedBlock:
- return "Unable to skip unknown block in bitcode file";
- case NaClBitcodeReader::InvalidType:
- return "Invalid type in record";
- case NaClBitcodeReader::InvalidTypeForValue:
- return "Type of value in record incorrect";
- case NaClBitcodeReader::InvalidValue:
- return "Invalid value in record";
- case NaClBitcodeReader::MalformedBlock:
- return "Malformed block. Unable to advance over block";
- }
- llvm_unreachable("Unknown error type!");
- }
-};
-
-const std::error_category &NaClBitcodeReader::BitcodeErrorCategory() {
- static NaClBitcodeErrorCategoryType ErrCat;
- return ErrCat;
-}
-
Type *NaClBitcodeReader::getTypeByID(NaClBcIndexSize_t ID) {
// The type table size is always specified correctly.
if (ID >= TypeList.size())
@@ -519,13 +455,15 @@ static_assert(
(1u << MaxAlignmentExponent) == Value::MaximumAlignment,
"Inconsistency between Value.MaxAlignment and PNaCl alignment limit");
-std::error_code NaClBitcodeReader::Error(ErrorType E,
- const std::string &Message) const {
- if (Verbose) {
- naclbitc::ErrorAt(*Verbose, naclbitc::Error, Stream.GetCurrentBitNo())
- << Message << "\n";
- }
- return Error(E);
+std::error_code NaClBitcodeReader::Error(std::error_code EC,
+ const Twine &Message) const {
+ std::string Buffer;
+ raw_string_ostream StrBuf(Buffer);
+ StrBuf << "(" << naclbitc::getBitAddress(Stream.GetCurrentBitNo()) << ") "
+ << Message;
+ BitcodeDiagnosticInfo DI(EC, DS_Error, StrBuf.str());
+ DiagnosticHandler(DI);
+ return EC;
}
std::error_code NaClBitcodeReader::getAlignmentValue(
@@ -535,7 +473,7 @@ std::error_code NaClBitcodeReader::getAlignmentValue(
raw_string_ostream StrBuf(Buffer);
StrBuf << "Alignment can't be greater than 2**" << MaxAlignmentExponent
<< ". Found: 2**" << (Exponent - 1);
- return Error(InvalidValue, StrBuf.str());
+ return Error(StrBuf.str());
}
Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1;
return std::error_code();
@@ -544,7 +482,7 @@ std::error_code NaClBitcodeReader::getAlignmentValue(
std::error_code NaClBitcodeReader::ParseTypeTable() {
DEBUG(dbgs() << "-> ParseTypeTable\n");
if (Stream.EnterSubBlock(naclbitc::TYPE_BLOCK_ID_NEW))
- return Error(InvalidRecord, "Malformed block record");
+ return Error("Malformed block record");
std::error_code result = ParseTypeTableBody();
if (!result)
@@ -554,7 +492,7 @@ std::error_code NaClBitcodeReader::ParseTypeTable() {
std::error_code NaClBitcodeReader::ParseTypeTableBody() {
if (!TypeList.empty())
- return Error(InvalidMultipleBlocks, "Multiple TYPE_BLOCKs found!");
+ return Error("Multiple TYPE_BLOCKs found!");
SmallVector<uint64_t, 64> Record;
NaClBcIndexSize_t NumRecords = 0;
@@ -566,13 +504,12 @@ std::error_code NaClBitcodeReader::ParseTypeTableBody() {
switch (Entry.Kind) {
case NaClBitstreamEntry::SubBlock:
- return Error(InvalidBlock, "Invalid block found in the types block");
+ return Error("Invalid block found in the types block");
case NaClBitstreamEntry::Error:
- return Error(MalformedBlock, "Malformed types block");
+ return Error("Malformed types block");
case NaClBitstreamEntry::EndBlock:
if (NumRecords != ExpectedNumRecords)
- return Error(MalformedBlock,
- "Invalid forward reference in the types block");
+ return Error("Invalid forward reference in the types block");
return std::error_code();
case NaClBitstreamEntry::Record:
// The interesting case.
@@ -589,17 +526,17 @@ std::error_code NaClBitcodeReader::ParseTypeTableBody() {
raw_string_ostream StrM(Message);
StrM << "Unknown type code in type table: " << TypeCode;
StrM.flush();
- return Error(InvalidValue, Message);
+ return Error(Message);
}
case naclbitc::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, "Invalid TYPE_CODE_NUMENTRY record");
+ return Error("Invalid TYPE_CODE_NUMENTRY record");
uint64_t Size = Record[0];
if (Size > NaClBcIndexSize_t_Max)
- return Error(InvalidValue, "Size too big in TYPE_CODE_NUMENTRY record");
+ return Error("Size too big in TYPE_CODE_NUMENTRY record");
// The code double checks that Expected size and the actual size
// at the end of the block. To reduce allocations we preallocate
// the space.
@@ -614,25 +551,25 @@ std::error_code NaClBitcodeReader::ParseTypeTableBody() {
}
case naclbitc::TYPE_CODE_VOID: // VOID
if (Record.size() != 0)
- return Error(InvalidRecord, "Invalid TYPE_CODE_VOID record");
+ return Error("Invalid TYPE_CODE_VOID record");
ResultTy = Type::getVoidTy(Context);
break;
case naclbitc::TYPE_CODE_FLOAT: // FLOAT
if (Record.size() != 0)
- return Error(InvalidRecord, "Invalid TYPE_CODE_FLOAT record");
+ return Error("Invalid TYPE_CODE_FLOAT record");
ResultTy = Type::getFloatTy(Context);
break;
case naclbitc::TYPE_CODE_DOUBLE: // DOUBLE
if (Record.size() != 0)
- return Error(InvalidRecord, "Invalid TYPE_CODE_DOUBLE record");
+ return Error("Invalid TYPE_CODE_DOUBLE record");
ResultTy = Type::getDoubleTy(Context);
break;
case naclbitc::TYPE_CODE_INTEGER: // INTEGER: [width]
if (Record.size() != 1)
- return Error(InvalidRecord, "Invalid TYPE_CODE_INTEGER record");
+ return Error("Invalid TYPE_CODE_INTEGER record");
// TODO(kschimpf): Should we check if Record[0] is in range?
ResultTy = IntegerType::get(Context, Record[0]);
break;
@@ -640,7 +577,7 @@ std::error_code NaClBitcodeReader::ParseTypeTableBody() {
case naclbitc::TYPE_CODE_FUNCTION: {
// FUNCTION: [vararg, retty, paramty x N]
if (Record.size() < 2)
- return Error(InvalidRecord, "Invalid TYPE_CODE_FUNCTION record");
+ return Error("Invalid TYPE_CODE_FUNCTION record");
SmallVector<Type *, 8> ArgTys;
for (size_t i = 2, e = Record.size(); i != e; ++i) {
if (Type *T = getTypeByID(Record[i]))
@@ -651,28 +588,28 @@ std::error_code NaClBitcodeReader::ParseTypeTableBody() {
ResultTy = getTypeByID(Record[1]);
if (ResultTy == 0 || ArgTys.size() < Record.size() - 2)
- return Error(InvalidType, "invalid type in function type");
+ return Error("invalid type in function type");
ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
break;
}
case naclbitc::TYPE_CODE_VECTOR: { // VECTOR: [numelts, eltty]
if (Record.size() != 2)
- return Error(InvalidRecord, "Invalid VECTOR type record");
+ return Error("Invalid VECTOR type record");
if ((ResultTy = getTypeByID(Record[1])))
ResultTy = VectorType::get(ResultTy, Record[0]);
else
- return Error(InvalidType, "invalid type in vector type");
+ return Error("invalid type in vector type");
break;
}
}
if (NumRecords >= ExpectedNumRecords)
- return Error(MalformedBlock, "invalid TYPE table");
+ return Error("invalid TYPE table");
assert(ResultTy && "Didn't read a type?");
assert(TypeList[NumRecords] == 0 && "Already read type?");
if (NumRecords == NaClBcIndexSize_t_Max)
- return Error(InvalidRecord, "Exceeded type index limit");
+ return Error("Exceeded type index limit");
TypeList[NumRecords++] = ResultTy;
}
return std::error_code();
@@ -747,15 +684,12 @@ public:
Stream.advance(NaClBitstreamCursor::AF_DontPopBlockAtEnd, nullptr);
switch (Entry.Kind) {
case NaClBitstreamEntry::SubBlock:
- return Reader.Error(NaClBitcodeReader::InvalidBlock,
- "Invalid block in the global vars block");
+ return Reader.Error("Invalid block in the global vars block");
case NaClBitstreamEntry::Error:
- return Reader.Error(NaClBitcodeReader::MalformedBlock,
- "Error in the global vars block");
+ return Reader.Error("Error in the global vars block");
case NaClBitstreamEntry::EndBlock:
if (ProcessingGlobal || NumGlobals != (NextValueNo - FirstValueNo))
- return Reader.Error(NaClBitcodeReader::MalformedBlock,
- "Error in the global vars block");
+ return Reader.Error("Error in the global vars block");
return std::error_code();
case NaClBitstreamEntry::Record:
// The interesting case.
@@ -767,13 +701,11 @@ public:
unsigned Bitcode = Stream.readRecord(Entry.ID, Record);
switch (Bitcode) {
default:
- return Reader.Error(NaClBitcodeReader::InvalidValue,
- "Unknown global variable entry");
+ return Reader.Error("Unknown global variable entry");
case naclbitc::GLOBALVAR_VAR:
// Start the definition of a global variable.
if (ProcessingGlobal || Record.size() != 2)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_VAR record");
+ return Reader.Error("Bad GLOBALVAR_VAR record");
ProcessingGlobal = true;
if (std::error_code EC =
Reader.getAlignmentValue(Record[0], VarAlignment))
@@ -788,21 +720,18 @@ public:
// Record[0].
if (!ProcessingGlobal || !VarType.empty() ||
VarInitializersNeeded != 1 || Record.size() != 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_COMPOUND record");
+ return Reader.Error("Bad GLOBALVAR_COMPOUND record");
uint64_t Size = Record[0];
// Check that ILP32 assumption met.
if (Size > MaxNaClGlobalVarInits)
- return Reader.Error(NaClBitcodeReader::InvalidValue,
- "Size too big in GLOBALVAR_COMPOUND record");
+ return Reader.Error("Size too big in GLOBALVAR_COMPOUND record");
VarInitializersNeeded = static_cast<size_t>(Size);
break;
}
case naclbitc::GLOBALVAR_ZEROFILL: {
// Define a type that defines a sequence of zero-filled bytes.
if (!ProcessingGlobal || Record.size() != 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_ZEROFILL record");
+ return Reader.Error("Bad GLOBALVAR_ZEROFILL record");
VarType.push_back(ArrayType::get(
Type::getInt8Ty(Context), Record[0]));
break;
@@ -810,8 +739,7 @@ public:
case naclbitc::GLOBALVAR_DATA: {
// Defines a type defined by a sequence of byte values.
if (!ProcessingGlobal || Record.size() < 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_DATA record");
+ return Reader.Error("Bad GLOBALVAR_DATA record");
VarType.push_back(ArrayType::get(
Type::getInt8Ty(Context), Record.size()));
break;
@@ -819,18 +747,15 @@ public:
case naclbitc::GLOBALVAR_RELOC: {
// Define a relocation initializer type.
if (!ProcessingGlobal || Record.size() < 1 || Record.size() > 2)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_RELOC record");
+ return Reader.Error("Bad GLOBALVAR_RELOC record");
VarType.push_back(IntegerType::get(Context, 32));
break;
}
case naclbitc::GLOBALVAR_COUNT:
if (Record.size() != 1 || NumGlobals != 0)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Invalid global count record");
+ return Reader.Error("Invalid global count record");
if (Record[0] > NaClBcIndexSize_t_Max)
- return Reader.Error(NaClBitcodeReader::InvalidValue,
- "Size too big in global count record");
+ return Reader.Error("Size too big in global count record");
NumGlobals = static_cast<NaClBcIndexSize_t>(Record[0]);
break;
}
@@ -843,7 +768,6 @@ public:
switch (VarType.size()) {
case 0:
return Reader.Error(
- NaClBitcodeReader::InvalidRecord,
"No initializer for global variable in global vars block");
case 1:
Ty = VarType[0];
@@ -877,15 +801,12 @@ public:
Stream.advance(NaClBitstreamCursor::AF_DontAutoprocessAbbrevs, nullptr);
switch (Entry.Kind) {
case NaClBitstreamEntry::SubBlock:
- return Reader.Error(NaClBitcodeReader::InvalidBlock,
- "Invalid block in the global vars block");
+ return Reader.Error("Invalid block in the global vars block");
case NaClBitstreamEntry::Error:
- return Reader.Error(NaClBitcodeReader::MalformedBlock,
- "Error in the global vars block");
+ return Reader.Error("Error in the global vars block");
case NaClBitstreamEntry::EndBlock:
if (ProcessingGlobal || NumGlobals != (NextValueNo - FirstValueNo))
- return Reader.Error(NaClBitcodeReader::MalformedBlock,
- "Error in the global vars block");
+ return Reader.Error("Error in the global vars block");
return std::error_code();
case NaClBitstreamEntry::Record:
if (Entry.ID == naclbitc::DEFINE_ABBREV) {
@@ -901,8 +822,7 @@ public:
unsigned Bitcode = Stream.readRecord(Entry.ID, Record);
switch (Bitcode) {
default:
- return Reader.Error(NaClBitcodeReader::InvalidValue,
- "Unknown global variable entry 2");
+ return Reader.Error("Unknown global variable entry (pass 2)");
case naclbitc::GLOBALVAR_VAR:
// Start the definition of a global variable.
ProcessingGlobal = true;
@@ -915,8 +835,7 @@ public:
// Record[0].
if (!ProcessingGlobal || !VarInit.empty() ||
VarInitializersNeeded != 1 || Record.size() != 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_COMPOUND record");
+ return Reader.Error("Bad GLOBALVAR_COMPOUND record");
// Note: We assume VarInitializersNeeded size was checked
// in GenerateGlobalVarsPass.
VarInitializersNeeded = static_cast<size_t>(Record[0]);
@@ -924,8 +843,7 @@ public:
case naclbitc::GLOBALVAR_ZEROFILL: {
// Define an initializer that defines a sequence of zero-filled bytes.
if (!ProcessingGlobal || Record.size() != 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_ZEROFILL record");
+ return Reader.Error("Bad GLOBALVAR_ZEROFILL record");
Type *Ty = ArrayType::get(Type::getInt8Ty(Context),
Record[0]);
Constant *Zero = ConstantAggregateZero::get(Ty);
@@ -935,8 +853,7 @@ public:
case naclbitc::GLOBALVAR_DATA: {
// Defines an initializer defined by a sequence of byte values.
if (!ProcessingGlobal || Record.size() < 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_DATA record");
+ return Reader.Error("Bad GLOBALVAR_DATA record");
size_t Size = Record.size();
uint8_t *Buf = new uint8_t[Size];
assert(Buf);
@@ -951,8 +868,7 @@ public:
case naclbitc::GLOBALVAR_RELOC: {
// Define a relocation initializer.
if (!ProcessingGlobal || Record.size() < 1 || Record.size() > 2)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Bad GLOBALVAR_RELOC record");
+ return Reader.Error("Bad GLOBALVAR_RELOC record");
Constant *BaseVal = cast<Constant>(Reader.getFnValueByID(Record[0]));
Type *IntPtrType = IntegerType::get(Context, 32);
Constant *Val = ConstantExpr::getPtrToInt(BaseVal, IntPtrType);
@@ -960,8 +876,7 @@ public:
uint64_t Addend = Record[1];
// Note: PNaCl is ILP32, so Addend must be uint32_t.
if (Addend > std::numeric_limits<uint32_t>::max())
- return Reader.Error(NaClBitcodeReader::InvalidValue,
- "Addend of GLOBALVAR_RELOC record too big");
+ return Reader.Error("Addend of GLOBALVAR_RELOC record too big");
Val = ConstantExpr::getAdd(Val, ConstantInt::get(IntPtrType,
Addend));
}
@@ -970,8 +885,7 @@ public:
}
case naclbitc::GLOBALVAR_COUNT:
if (Record.size() != 1)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Invalid global count record");
+ return Reader.Error("Invalid global count record");
// Note: NumGlobals should have been set in GenerateGlobalVarsPass.
// Fail if methods are called in wrong order.
assert(NumGlobals == Record[0]);
@@ -985,7 +899,7 @@ public:
Constant *Init = 0;
switch (VarInit.size()) {
case 0:
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
+ return Reader.Error(
"No initializer for global variable in global vars block");
case 1:
Init = VarInit[0];
@@ -996,8 +910,7 @@ public:
}
cast<GlobalVariable>(ValueList[NextValueNo])->setInitializer(Init);
if (NextValueNo == NaClBcIndexSize_t_Max)
- return Reader.Error(NaClBitcodeReader::InvalidRecord,
- "Exceeded value index limit");
+ return Reader.Error("Exceeded value index limit");
++NextValueNo;
ProcessingGlobal = false;
VarInitializersNeeded = 0;
@@ -1009,7 +922,7 @@ public:
std::error_code NaClBitcodeReader::ParseGlobalVars() {
if (Stream.EnterSubBlock(naclbitc::GLOBALVAR_BLOCK_ID))
- return Error(InvalidRecord, "Malformed block record");
+ return Error("Malformed block record");
ParseGlobalsHandler PassHandler(*this, ValueList, Stream, Context, TheModule);
if (std::error_code EC = PassHandler.GenerateGlobalVarsPass())
@@ -1020,7 +933,7 @@ std::error_code NaClBitcodeReader::ParseGlobalVars() {
std::error_code NaClBitcodeReader::ParseValueSymbolTable() {
DEBUG(dbgs() << "-> ParseValueSymbolTable\n");
if (Stream.EnterSubBlock(naclbitc::VALUE_SYMTAB_BLOCK_ID))
- return Error(InvalidRecord, "Malformed block record");
+ return Error("Malformed block record");
SmallVector<uint64_t, 64> Record;
@@ -1031,10 +944,9 @@ std::error_code NaClBitcodeReader::ParseValueSymbolTable() {
switch (Entry.Kind) {
case NaClBitstreamEntry::SubBlock:
- return Error(InvalidBlock,
- "Invalid block in the value symbol table block");
+ return Error("Invalid block in the value symbol table block");
case NaClBitstreamEntry::Error:
- return Error(MalformedBlock, "malformed value symbol table block");
+ return Error("malformed value symbol table block");
case NaClBitstreamEntry::EndBlock:
DEBUG(dbgs() << "<- ParseValueSymbolTable\n");
return std::error_code();
@@ -1050,10 +962,10 @@ std::error_code NaClBitcodeReader::ParseValueSymbolTable() {
break;
case naclbitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
if (ConvertToString(Record, 1, ValueName))
- return Error(InvalidRecord, "Invalid VST_ENTRY record");
+ return Error("Invalid VST_ENTRY record");
Value *V = getFnValueByID(Record[0]);
if (V == nullptr)
- return Error(InvalidValue, "Invalid Value ID in VST_ENTRY record");
+ return Error("Invalid Value ID in VST_ENTRY record");
V->setName(StringRef(ValueName.data(), ValueName.size()));
ValueName.clear();
@@ -1061,10 +973,10 @@ std::error_code NaClBitcodeReader::ParseValueSymbolTable() {
}
case naclbitc::VST_CODE_BBENTRY: {
if (ConvertToString(Record, 1, ValueName))
- return Error(InvalidRecord, "Invalid VST_BBENTRY record");
+ return Error("Invalid VST_BBENTRY record");
BasicBlock *BB = getBasicBlock(Record[0]);
if (BB == 0)
- return Error(InvalidValue, "Invalid BB ID in VST_BBENTRY record");
+ return Error("Invalid BB ID in VST_BBENTRY record");
BB->setName(StringRef(ValueName.data(), ValueName.size()));
ValueName.clear();
@@ -1077,7 +989,7 @@ std::error_code NaClBitcodeReader::ParseValueSymbolTable() {
std::error_code NaClBitcodeReader::ParseConstants() {
DEBUG(dbgs() << "-> ParseConstants\n");
if (Stream.EnterSubBlock(naclbitc::CONSTANTS_BLOCK_ID))
- return Error(InvalidRecord, "Malformed block record");
+ return Error("Malformed block record");
SmallVector<uint64_t, 64> Record;
@@ -1089,13 +1001,12 @@ std::error_code NaClBitcodeReader::ParseConstants() {
switch (Entry.Kind) {
case NaClBitstreamEntry::SubBlock:
- return Error(InvalidBlock, "Invalid block in function constants block");
+ return Error("Invalid block in function constants block");
case NaClBitstreamEntry::Error:
- return Error(MalformedBlock, "malformed function constants block");
+ return Error("malformed function constants block");
case NaClBitstreamEntry::EndBlock:
if (NextCstNo != ValueList.size())
- return Error(InvalidConstantReference,
- "Invalid constant reference!");
+ return Error("Invalid constant reference!");
DEBUG(dbgs() << "<- ParseConstants\n");
return std::error_code();
case NaClBitstreamEntry::Record:
@@ -1112,29 +1023,26 @@ std::error_code NaClBitcodeReader::ParseConstants() {
std::string Message;
raw_string_ostream StrM(Message);
StrM << "Invalid Constant code: " << BitCode;
- StrM.flush();
- return Error(InvalidValue, Message);
+ return Error(StrM.str());
}
case naclbitc::CST_CODE_UNDEF: // UNDEF
V = UndefValue::get(CurTy);
break;
case naclbitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
if (Record.empty())
- return Error(NaClBitcodeReader::InvalidRecord,
- "Malformed CST_SETTYPE record");
+ return Error("Malformed CST_SETTYPE record");
if (Record[0] >= TypeList.size())
- return Error(NaClBitcodeReader::InvalidType,
- "Invalid Type ID in CST_SETTYPE record");
+ return Error("Invalid Type ID in CST_SETTYPE record");
CurTy = TypeList[Record[0]];
continue; // Skip the ValueList manipulation.
case naclbitc::CST_CODE_INTEGER: // INTEGER: [intval]
if (!CurTy->isIntegerTy() || Record.empty())
- return Error(InvalidRecord, "Invalid CST_INTEGER record");
+ return Error("Invalid CST_INTEGER record");
V = ConstantInt::get(CurTy, NaClDecodeSignRotatedValue(Record[0]));
break;
case naclbitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
if (Record.empty())
- return Error(NaClBitcodeReader::InvalidRecord, "Invalid FLOAT record");
+ return Error("Invalid FLOAT record");
if (CurTy->isFloatTy())
V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle,
APInt(32, (uint32_t)Record[0])));
@@ -1142,8 +1050,7 @@ std::error_code NaClBitcodeReader::ParseConstants() {
V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble,
APInt(64, Record[0])));
else
- return Error(NaClBitcodeReader::InvalidRecord,
- "Unknown type for FLOAT record");
+ return Error("Unknown type for FLOAT record");
break;
}
}
@@ -1160,8 +1067,7 @@ std::error_code NaClBitcodeReader::RememberAndSkipFunctionBody() {
DEBUG(dbgs() << "-> RememberAndSkipFunctionBody\n");
// Get the function we are talking about.
if (FunctionsWithBodies.empty())
- return Error(InsufficientFunctionProtos,
- "Insufficient function protos");
+ return Error("Insufficient function protos");
Function *Fn = FunctionsWithBodies.back();
FunctionsWithBodies.pop_back();
@@ -1172,7 +1078,7 @@ std::error_code NaClBitcodeReader::RememberAndSkipFunctionBody() {
// Skip over the function block for now.
if (Stream.SkipBlock())
- return Error(InvalidSkippedBlock, "Unable to skip function block.");
+ return Error("Unable to skip function block.");
DEBUG(dbgs() << "<- RememberAndSkipFunctionBody\n");
return std::error_code();
}
@@ -1253,7 +1159,7 @@ std::error_code NaClBitcodeReader::ParseModule(bool Resume) {
if (Resume)
Stream.JumpToBit(NextUnreadBit);
else if (Stream.EnterSubBlock(naclbitc::MODULE_BLOCK_ID))
- return Error(InvalidRecord, "Malformed block record");
+ return Error("Malformed block record");
SmallVector<uint64_t, 64> Record;
@@ -1263,13 +1169,13 @@ std::error_code NaClBitcodeReader::ParseModule(bool Resume) {
switch (Entry.Kind) {
case NaClBitstreamEntry::Error:
- return Error(MalformedBlock, "malformed module block");
+ return Error("malformed module block");
case NaClBitstreamEntry::EndBlock:
DEBUG(dbgs() << "<- ParseModule\n");
if (std::error_code EC = GlobalCleanup())
return EC;
if (!Stream.AtEndOfStream())
- return Error(InvalidDataAfterModule, "Invalid data after module");
+ return Error("Invalid data after module");
return std::error_code();
case NaClBitstreamEntry::SubBlock:
switch (Entry.ID) {
@@ -1277,11 +1183,11 @@ std::error_code NaClBitcodeReader::ParseModule(bool Resume) {
std::string Message;
raw_string_ostream StrM(Message);
StrM << "Unknown block ID: " << Entry.ID;
- return Error(InvalidRecord, StrM.str());
+ return Error(StrM.str());
}
case naclbitc::BLOCKINFO_BLOCK_ID:
if (Stream.ReadBlockInfoBlock(0))
- return Error(MalformedBlock, "Malformed BlockInfoBlock");
+ return Error("Malformed BlockInfoBlock");
break;
case naclbitc::TYPE_BLOCK_ID_NEW:
if (std::error_code EC = ParseTypeTable())
@@ -1340,41 +1246,39 @@ std::error_code NaClBitcodeReader::ParseModule(bool Resume) {
raw_string_ostream StrM(Message);
StrM << "Invalid MODULE_CODE: " << Selector;
StrM.flush();
- return Error(InvalidValue, Message);
+ return Error(Message);
}
case naclbitc::MODULE_CODE_VERSION: { // VERSION: [version#]
if (Record.size() < 1)
- return Error(InvalidRecord, "Malformed MODULE_CODE_VERSION");
+ return Error("Malformed MODULE_CODE_VERSION");
// Only version #1 is supported for PNaCl. Version #0 is not supported.
uint64_t module_version = Record[0];
if (module_version != 1)
- return Error(InvalidValue, "Unknown bitstream version!");
+ return Error("Unknown bitstream version!");
break;
}
// FUNCTION: [type, callingconv, isproto, linkage]
case naclbitc::MODULE_CODE_FUNCTION: {
if (Record.size() < 4)
- return Error(InvalidRecord, "Invalid MODULE_CODE_FUNCTION record");
+ return Error("Invalid MODULE_CODE_FUNCTION record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
- return Error(InvalidType, "Invalid MODULE_CODE_FUNCTION record");
+ return Error("Invalid MODULE_CODE_FUNCTION record");
FunctionType *FTy = dyn_cast<FunctionType>(Ty);
if (!FTy)
- return Error(InvalidType,
- "Function not declared with a function type!");
+ return Error("Function not declared with a function type!");
Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
"", TheModule);
CallingConv::ID CallingConv;
if (!naclbitc::DecodeCallingConv(Record[1], CallingConv))
- return Error(InvalidValue,
- "PNaCl bitcode contains invalid calling conventions.");
+ return Error("PNaCl bitcode contains invalid calling conventions.");
Func->setCallingConv(CallingConv);
bool isProto = Record[2];
GlobalValue::LinkageTypes Linkage;
if (!naclbitc::DecodeLinkage(Record[3], Linkage))
- return Error(InvalidValue, "Unknown linkage type");
+ return Error("Unknown linkage type");
Func->setLinkage(Linkage);
ValueList.push_back(Func);
@@ -1419,7 +1323,7 @@ std::error_code NaClBitcodeReader::ParseBitcodeInto(Module *M) {
switch (Entry.Kind) {
case NaClBitstreamEntry::Error:
- return Error(MalformedBlock, "malformed module file");
+ return Error("malformed module file");
case NaClBitstreamEntry::EndBlock:
return std::error_code();
@@ -1428,8 +1332,7 @@ std::error_code NaClBitcodeReader::ParseBitcodeInto(Module *M) {
case naclbitc::MODULE_BLOCK_ID:
// Reject multiple MODULE_BLOCK's in a single bitstream.
if (TheModule)
- return Error(InvalidMultipleBlocks,
- "Multiple MODULE_BLOCKs in same stream");
+ return Error("Multiple MODULE_BLOCKs in same stream");
TheModule = M;
if (std::error_code EC = ParseModule(false))
return EC;
@@ -1437,13 +1340,13 @@ std::error_code NaClBitcodeReader::ParseBitcodeInto(Module *M) {
return std::error_code();
break;
default:
- return Error(InvalidBlock, "Invalid top-level block found.");
+ return Error("Invalid top-level block found.");
break;
}
continue;
case NaClBitstreamEntry::Record:
// There should be no records in the top-level of blocks.
- return Error(InvalidRecord, "Invalid record at top-level");
+ return Error("Invalid record at top-level");
}
}
}
@@ -1455,8 +1358,7 @@ std::error_code NaClBitcodeReader::InstallInstruction(
// this file.
if (BB == 0) {
delete I;
- return Error(InvalidInstructionWithNoBB,
- "Instruction with no BB, can't install");
+ return Error("Instruction with no BB, can't install");
}
BB->getInstList().push_back(I);
return std::error_code();
@@ -1519,7 +1421,7 @@ Value *NaClBitcodeReader::ConvertOpToType(Value *Op, Type *T,
std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
DEBUG(dbgs() << "-> ParseFunctionBody\n");
if (Stream.EnterSubBlock(naclbitc::FUNCTION_BLOCK_ID))
- return Error(InvalidRecord, "Malformed block record");
+ return Error("Malformed block record");
NaClBcIndexSize_t ModuleValueListSize = ValueList.size();
@@ -1538,14 +1440,14 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
switch (Entry.Kind) {
case NaClBitstreamEntry::Error:
- return Error(MalformedBlock, "Bitcode error in function block");
+ return Error("Bitcode error in function block");
case NaClBitstreamEntry::EndBlock:
goto OutOfRecordLoop;
case NaClBitstreamEntry::SubBlock:
switch (Entry.ID) {
default:
- return Error(InvalidBlock, "Invalid block in function block");
+ return Error("Invalid block in function block");
break;
case naclbitc::CONSTANTS_BLOCK_ID:
if (std::error_code EC = ParseConstants())
@@ -1557,7 +1459,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if (std::error_code EC = ParseValueSymbolTable())
return EC;
} else {
- return Error(InvalidRecord, "Local value symbol tables not allowed");
+ return Error("Local value symbol tables not allowed");
}
break;
}
@@ -1581,12 +1483,12 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
StrM << " " << Record[I];
}
StrM << ">";
- return Error(InvalidRecord, StrM.str());
+ return Error(StrM.str());
}
case naclbitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks]
if (Record.size() != 1 || Record[0] == 0)
- return Error(InvalidRecord, "Invalid DECLAREBLOCKS record");
+ return Error("Invalid DECLAREBLOCKS record");
// Create all the basic blocks for the function.
// TODO(kschimpf): Figure out how to handle size values that
// are too large.
@@ -1607,14 +1509,14 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if (popValue(Record, &OpNum, NextValueNo, &LHS) ||
popValue(Record, &OpNum, NextValueNo, &RHS) ||
OpNum+1 > Record.size())
- return Error(InvalidRecord, "Invalid BINOP record");
+ return Error("Invalid BINOP record");
LHS = ConvertOpToScalar(LHS, CurBBNo);
RHS = ConvertOpToScalar(RHS, CurBBNo);
Instruction::BinaryOps Opc;
if (!naclbitc::DecodeBinaryOpcode(Record[OpNum++], LHS->getType(), Opc))
- return Error(InvalidValue, "Invalid binary opcode in BINOP record");
+ return Error("Invalid binary opcode in BINOP record");
I = BinaryOperator::Create(Opc, LHS, RHS);
break;
}
@@ -1623,14 +1525,14 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
Value *Op;
if (popValue(Record, &OpNum, NextValueNo, &Op) ||
OpNum+2 != Record.size())
- return Error(InvalidRecord, "Invalid CAST record: bad record size");
+ return Error("Invalid CAST record: bad record size");
Type *ResTy = getTypeByID(Record[OpNum]);
if (ResTy == 0)
- return Error(InvalidType, "Invalid CAST record: bad type ID");
+ return Error("Invalid CAST record: bad type ID");
Instruction::CastOps Opc;
if (!naclbitc::DecodeCastOpcode(Record[OpNum+1], Opc)) {
- return Error(InvalidValue, "Invalid CAST record: bad opcode");
+ return Error("Invalid CAST record: bad opcode");
}
// If a ptrtoint cast was elided on the argument of the cast,
@@ -1661,7 +1563,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
popValue(Record, &OpNum, NextValueNo, &FalseVal) ||
popValue(Record, &OpNum, NextValueNo, &Cond) ||
OpNum != Record.size())
- return Error(InvalidRecord, "Invalid SELECT record");
+ return Error("Invalid SELECT record");
TrueVal = ConvertOpToScalar(TrueVal, CurBBNo);
FalseVal = ConvertOpToScalar(FalseVal, CurBBNo);
@@ -1671,12 +1573,11 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
dyn_cast<VectorType>(Cond->getType())) {
// expect <n x i1>
if (vector_type->getElementType() != Type::getInt1Ty(Context))
- return Error(InvalidTypeForValue,
- "Invalid SELECT vector condition type");
+ return Error("Invalid SELECT vector condition type");
} else {
// expect i1
if (Cond->getType() != Type::getInt1Ty(Context))
- return Error(InvalidTypeForValue, "Invalid SELECT condition type");
+ return Error("Invalid SELECT condition type");
}
I = SelectInst::Create(Cond, TrueVal, FalseVal);
@@ -1688,11 +1589,11 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
Value *Vec, *Idx;
if (popValue(Record, &OpNum, NextValueNo, &Vec) ||
popValue(Record, &OpNum, NextValueNo, &Idx) || OpNum != Record.size())
- return Error(InvalidRecord, "Invalid EXTRACTELEMENT record");
+ return Error("Invalid EXTRACTELEMENT record");
// expect i32
if (Idx->getType() != Type::getInt32Ty(Context))
- return Error(InvalidTypeForValue, "Invalid EXTRACTELEMENT index type");
+ return Error("Invalid EXTRACTELEMENT index type");
I = ExtractElementInst::Create(Vec, Idx);
break;
@@ -1704,18 +1605,17 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if (popValue(Record, &OpNum, NextValueNo, &Vec) ||
popValue(Record, &OpNum, NextValueNo, &Elt) ||
popValue(Record, &OpNum, NextValueNo, &Idx) || OpNum != Record.size())
- return Error(InvalidRecord, "Invalid INSERTELEMENT record");
+ return Error("Invalid INSERTELEMENT record");
// expect vector type
if (!isa<VectorType>(Vec->getType()))
- return Error(InvalidTypeForValue, "Invalid INSERTELEMENT vector type");
+ return Error("Invalid INSERTELEMENT vector type");
// match vector and element types
if (cast<VectorType>(Vec->getType())->getElementType() != Elt->getType())
- return Error(InvalidTypeForValue,
- "Mismatched INSERTELEMENT vector and element type");
+ return Error("Mismatched INSERTELEMENT vector and element type");
// expect i32
if (Idx->getType() != Type::getInt32Ty(Context))
- return Error(InvalidTypeForValue, "Invalid INSERTELEMENT index type");
+ return Error("Invalid INSERTELEMENT index type");
I = InsertElementInst::Create(Vec, Elt, Idx);
break;
@@ -1729,7 +1629,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if (popValue(Record, &OpNum, NextValueNo, &LHS) ||
popValue(Record, &OpNum, NextValueNo, &RHS) ||
OpNum+1 != Record.size())
- return Error(InvalidRecord, "Invalid CMP record");
+ return Error("Invalid CMP record");
LHS = ConvertOpToScalar(LHS, CurBBNo);
RHS = ConvertOpToScalar(RHS, CurBBNo);
@@ -1738,13 +1638,11 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if (LHS->getType()->isFPOrFPVectorTy()) {
if (!naclbitc::DecodeFcmpPredicate(Record[OpNum], Predicate))
return Error(
- InvalidValue,
"PNaCl bitcode contains invalid floating comparison predicate");
I = new FCmpInst(Predicate, LHS, RHS);
} else {
if (!naclbitc::DecodeIcmpPredicate(Record[OpNum], Predicate))
return Error(
- InvalidValue,
"PNaCl bitcode contains invalid integer comparison predicate");
I = new ICmpInst(Predicate, LHS, RHS);
}
@@ -1762,19 +1660,19 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
size_t OpNum = 0;
Value *Op = NULL;
if (popValue(Record, &OpNum, NextValueNo, &Op))
- return Error(InvalidRecord, "Invalid RET record");
+ return Error("Invalid RET record");
if (OpNum != Record.size())
- return Error(InvalidRecord, "Invalid RET record");
+ return Error("Invalid RET record");
I = ReturnInst::Create(Context, ConvertOpToScalar(Op, CurBBNo));
break;
}
case naclbitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
if (Record.size() != 1 && Record.size() != 3)
- return Error(InvalidRecord, "Invalid BR record");
+ return Error("Invalid BR record");
BasicBlock *TrueDest = getBasicBlock(Record[0]);
if (TrueDest == 0)
- return Error(InvalidRecord, "Invalid BR record");
+ return Error("Invalid BR record");
if (Record.size() == 1) {
I = BranchInst::Create(TrueDest);
@@ -1783,13 +1681,13 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
BasicBlock *FalseDest = getBasicBlock(Record[1]);
Value *Cond = getValue(Record, 2, NextValueNo);
if (FalseDest == 0 || Cond == 0)
- return Error(InvalidValue, "Invalid BR record");
+ return Error("Invalid BR record");
if (!Cond->getType()->isIntegerTy(1)) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Type of branch condition not i1. Found: "
<< *Cond->getType() << "\n";
- return Error(InvalidValue, StrBuf.str());
+ return Error(StrBuf.str());
}
I = BranchInst::Create(TrueDest, FalseDest, Cond);
}
@@ -1797,17 +1695,16 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
}
case naclbitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
if (Record.size() < 4)
- return Error(InvalidRecord, "Invalid SWITCH record");
+ return Error("Invalid SWITCH record");
Type *OpTy = getTypeByID(Record[0]);
unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
if (ValueBitWidth > 64)
- return Error(InvalidValue,
- "Wide integers are not supported in PNaCl bitcode");
+ return Error("Wide integers are not supported in PNaCl bitcode");
Value *Cond = getValue(Record, 1, NextValueNo);
BasicBlock *Default = getBasicBlock(Record[2]);
if (OpTy == 0 || Cond == 0 || Default == 0)
- return Error(InvalidRecord, "Invalid SWITCH record");
+ return Error("Invalid SWITCH record");
Cond = ConvertOpToScalar(Cond, CurBBNo);
// TODO(kschimpf): Deal with values that are too large for NumCases.
@@ -1823,19 +1720,17 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
// no-one produced them.
// See https://code.google.com/p/nativeclient/issues/detail?id=3758
if (CurIdx + 3 >= Record.size())
- return Error(InvalidRecord,
- "Incomplete case entry in SWITCH record");
+ return Error("Incomplete case entry in SWITCH record");
uint64_t NumItems = Record[CurIdx++];
bool isSingleNumber = Record[CurIdx++];
if (NumItems != 1 || !isSingleNumber)
- return Error(InvalidRecord,
- "Case ranges are not supported in PNaCl bitcode");
+ return Error("Case ranges are not supported in PNaCl bitcode");
APInt CaseValue(ValueBitWidth,
NaClDecodeSignRotatedValue(Record[CurIdx++]));
BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
if (DestBB == nullptr)
- return Error(InvalidValue, "Invalid branch in SWITCH case");
+ return Error("Invalid branch in SWITCH case");
SI->addCase(ConstantInt::get(Context, CaseValue), DestBB);
}
I = SI.release();
@@ -1846,9 +1741,10 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
break;
case naclbitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
if (Record.size() < 1 || ((Record.size()-1)&1))
- return Error(InvalidRecord, "Invalid PHI record");
+ return Error("Invalid PHI record");
Type *Ty = getTypeByID(Record[0]);
- if (!Ty) return Error(InvalidType, "Invalid PHI record");
+ if (!Ty)
+ return Error("Invalid PHI record");
PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
@@ -1861,7 +1757,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
NaClBcIndexSize_t BBIndex = Record[2+i];
BasicBlock *BB = getBasicBlock(BBIndex);
if (!V || !BB)
- return Error(InvalidValue, "Invalid PHI record");
+ return Error("Invalid PHI record");
if (Ty == IntPtrType) {
// Delay installing scalar casts until all instructions of
// the function are rendered. This guarantees that we insert
@@ -1877,11 +1773,11 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
case naclbitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [op, align]
if (Record.size() != 2)
- return Error(InvalidRecord, "Invalid ALLOCA record");
+ return Error("Invalid ALLOCA record");
Value *Size;
size_t OpNum = 0;
if (popValue(Record, &OpNum, NextValueNo, &Size))
- return Error(InvalidRecord, "Invalid ALLOCA record");
+ return Error("Invalid ALLOCA record");
unsigned Alignment;
if (std::error_code EC = getAlignmentValue(Record[1], Alignment))
return EC;
@@ -1894,15 +1790,15 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
Value *Op;
if (popValue(Record, &OpNum, NextValueNo, &Op) ||
Record.size() != 3)
- return Error(InvalidRecord, "Invalid LOAD record");
+ return Error("Invalid LOAD record");
// Add pointer cast to op.
Type *T = getTypeByID(Record[2]);
if (T == nullptr)
- return Error(InvalidType, "Invalid type for load instruction");
+ return Error("Invalid type for load instruction");
Op = ConvertOpToType(Op, T->getPointerTo(), CurBBNo);
if (Op == nullptr)
- return Error(InvalidTypeForValue, "Can't convert cast to type");
+ return Error("Can't convert cast to type");
unsigned Alignment;
if (std::error_code EC = getAlignmentValue(Record[OpNum], Alignment))
return EC;
@@ -1916,11 +1812,11 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if (popValue(Record, &OpNum, NextValueNo, &Ptr) ||
popValue(Record, &OpNum, NextValueNo, &Val) ||
OpNum+1 != Record.size())
- return Error(InvalidRecord, "Invalid STORE record");
+ return Error("Invalid STORE record");
Val = ConvertOpToScalar(Val, CurBBNo);
Ptr = ConvertOpToType(Ptr, Val->getType()->getPointerTo(), CurBBNo);
if (Ptr == nullptr)
- return Error(InvalidTypeForValue, "Can't convert cast to type");
+ return Error("Can't convert cast to type");
unsigned Alignment;
if (std::error_code EC = getAlignmentValue(Record[OpNum], Alignment))
return EC;
@@ -1934,14 +1830,14 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
if ((Record.size() < 2) ||
(BitCode == naclbitc::FUNC_CODE_INST_CALL_INDIRECT &&
Record.size() < 3))
- return Error(InvalidRecord, "Invalid CALL record");
+ return Error("Invalid CALL record");
unsigned CCInfo = Record[0];
size_t OpNum = 1;
Value *Callee;
if (popValue(Record, &OpNum, NextValueNo, &Callee))
- return Error(InvalidRecord, "Invalid CALL record");
+ return Error("Invalid CALL record");
// Build function type for call.
FunctionType *FTy = 0;
@@ -1956,12 +1852,12 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
FTy = dyn_cast<FunctionType>(OpTy->getElementType());
}
if (FTy == 0)
- return Error(InvalidType, "Invalid type for CALL record");
+ return Error("Invalid type for CALL record");
}
size_t NumParams = Record.size() - OpNum;
if (FTy && NumParams != FTy->getNumParams())
- return Error(InvalidRecord, "Invalid CALL record");
+ return Error("Invalid CALL record");
// Process call arguments.
SmallVector<Value*, 6> Args;
@@ -1971,7 +1867,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Invalid call argument: Index " << Index;
- return Error(InvalidValue, StrBuf.str());
+ return Error(StrBuf.str());
}
if (FTy) {
// Add a cast, to a pointer type if necessary, in case this
@@ -1984,7 +1880,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
StrBuf << "Unable to cast call argument to parameter type: " << Index;
- return Error(InvalidValue, StrBuf.str());
+ return Error(StrBuf.str());
}
Args.push_back(Arg);
}
@@ -2003,8 +1899,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
I = CallInst::Create(Callee, Args);
CallingConv::ID CallingConv;
if (!naclbitc::DecodeCallingConv(CCInfo>>1, CallingConv))
- return Error(InvalidValue,
- "PNaCl bitcode contains invalid calling conventions.");
+ return Error("PNaCl bitcode contains invalid calling conventions.");
cast<CallInst>(I)->setCallingConv(CallingConv);
cast<CallInst>(I)->setTailCall(CCInfo & 1);
break;
@@ -2013,7 +1908,7 @@ std::error_code NaClBitcodeReader::ParseFunctionBody(Function *F) {
// Build corresponding forward reference.
if (Record.size() != 2 ||
ValueList.createValueFwdRef(Record[0], getTypeByID(Record[1])))
- return Error(InvalidRecord, "Invalid FORWARDTYPEREF record");
+ return Error("Invalid FORWARDTYPEREF record");
continue;
}
@@ -2068,7 +1963,7 @@ OutOfRecordLoop:
delete A;
}
}
- return Error(InvalidValue, "Never resolved value found in function!");
+ return Error("Never resolved value found in function!");
}
}
@@ -2077,7 +1972,7 @@ OutOfRecordLoop:
raw_string_ostream StrBuf(Buffer);
StrBuf << "Declared " << FunctionBBs.size() << " basic blocks. Found: "
<< CurBBNo;
- return Error(MalformedBlock, StrBuf.str());
+ return Error(StrBuf.str());
}
// Trim the value list down to the size it was before we parsed this function.
@@ -2093,8 +1988,7 @@ std::error_code NaClBitcodeReader::FindFunctionInStream(
DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) {
while (DeferredFunctionInfoIterator->second == 0) {
if (Stream.AtEndOfStream())
- return Error(CouldNotFindFunctionInStream,
- "Could not find Function in stream");
+ 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))
@@ -2227,14 +2121,13 @@ std::error_code NaClBitcodeReader::InitStreamFromBuffer() {
const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
if (Buffer->getBufferSize() & 3)
- return Error(InvalidBitstream,
- "Bitcode stream should be a multiple of 4 bytes in length");
+ return Error("Bitcode stream should be a multiple of 4 bytes in length");
if (Header.Read(BufPtr, BufEnd))
- return Error(InvalidBitstream, Header.Unsupported());
+ return Error(Header.Unsupported());
if (AcceptHeader())
- return Error(InvalidBitstream, Header.Unsupported());
+ return Error(Header.Unsupported());
StreamFile.reset(new NaClBitstreamReader(BufPtr, BufEnd, Header));
Stream.init(StreamFile.get());
@@ -2244,10 +2137,10 @@ std::error_code NaClBitcodeReader::InitStreamFromBuffer() {
std::error_code NaClBitcodeReader::InitLazyStream() {
if (Header.Read(LazyStreamer))
- return Error(InvalidBitstream, Header.Unsupported());
+ return Error(Header.Unsupported());
if (AcceptHeader())
- return Error(InvalidBitstream, Header.Unsupported());
+ return Error(Header.Unsupported());
StreamFile.reset(new NaClBitstreamReader(LazyStreamer, Header));
Stream.init(StreamFile.get());
@@ -2269,6 +2162,26 @@ const char *llvm::PNaClDataLayout =
"e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
"f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
+DiagnosticHandlerFunction
+llvm::redirectNaClDiagnosticToStream(raw_ostream &Out) {
+ return [&](const DiagnosticInfo &DI) {
+ switch (DI.getSeverity()) {
+ case DS_Error:
+ Out << "Error: ";
+ break;
+ case DS_Warning:
+ Out << "Warning: ";
+ case DS_Remark:
+ case DS_Note:
+ break;
+ }
+ // Now print diagnostic error message.
+ DiagnosticPrinterRawOStream Printer(Out);
+ DI.print(Printer);
+ Out << "\n";
+ };
+}
+
/// \brief Get a lazy one-at-time loading module from bitcode.
///
/// This isn't always used in a lazy context. In particular, it's also used by
@@ -2276,11 +2189,11 @@ const char *llvm::PNaClDataLayout =
/// NaCl does not support BlockAddresses, so it does not need to materialize
/// forward-referenced functions from block address references.
ErrorOr<Module *> llvm::getNaClLazyBitcodeModule(
- std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext& Context,
- raw_ostream *Verbose, bool AcceptSupportedOnly) {
+ std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler, bool AcceptSupportedOnly) {
Module *M = new Module(Buffer->getBufferIdentifier(), Context);
- NaClBitcodeReader *R =
- new NaClBitcodeReader(Buffer.get(), Context, Verbose, AcceptSupportedOnly);
+ NaClBitcodeReader *R = new NaClBitcodeReader(
+ Buffer.get(), Context, DiagnosticHandler, AcceptSupportedOnly);
M->setMaterializer(R);
auto cleanupOnError = [&](std::error_code EC) {
@@ -2296,17 +2209,13 @@ ErrorOr<Module *> llvm::getNaClLazyBitcodeModule(
return M;
}
-
-Module *llvm::getNaClStreamedBitcodeModule(const std::string &name,
- StreamingMemoryObject *Streamer,
- LLVMContext &Context,
- raw_ostream *Verbose,
- std::string *ErrMsg,
- bool AcceptSupportedOnly) {
+Module *llvm::getNaClStreamedBitcodeModule(
+ const std::string &name, StreamingMemoryObject *Streamer,
+ LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler,
+ std::string *ErrMsg, bool AcceptSupportedOnly) {
Module *M = new Module(name, Context);
- NaClBitcodeReader *R =
- new NaClBitcodeReader(Streamer, Context, Verbose,
- AcceptSupportedOnly);
+ NaClBitcodeReader *R = new NaClBitcodeReader(
+ Streamer, Context, DiagnosticHandler, AcceptSupportedOnly);
M->setMaterializer(R);
if (std::error_code EC = R->ParseBitcodeInto(M)) {
if (ErrMsg)
@@ -2318,13 +2227,13 @@ Module *llvm::getNaClStreamedBitcodeModule(const std::string &name,
return M;
}
-ErrorOr<Module *> llvm::NaClParseBitcodeFile(
- MemoryBufferRef Buffer, LLVMContext& Context, raw_ostream *Verbose,
- bool AcceptSupportedOnly){
+ErrorOr<Module *>
+llvm::NaClParseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
+ DiagnosticHandlerFunction DiagnosticHandler,
+ bool AcceptSupportedOnly) {
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
- ErrorOr<Module *> ModuleOrErr =
- getNaClLazyBitcodeModule(std::move(Buf), Context, Verbose,
- AcceptSupportedOnly);
+ ErrorOr<Module *> ModuleOrErr = getNaClLazyBitcodeModule(
+ std::move(Buf), Context, DiagnosticHandler, AcceptSupportedOnly);
if (!ModuleOrErr)
return ModuleOrErr;
Module *M = ModuleOrErr.get();
« no previous file with comments | « include/llvm/IRReader/IRReader.h ('k') | lib/Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698