mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
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. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225562 91177308-0d34-0410-b5e6-96231b3b80d8
173 lines
6.4 KiB
C++
173 lines
6.4 KiB
C++
//===-- llvm/Bitcode/ReaderWriter.h - Bitcode reader/writers ----*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This header defines interfaces to read and write LLVM bitcode files/streams.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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>
|
|
#include <string>
|
|
|
|
namespace llvm {
|
|
class BitstreamWriter;
|
|
class DataStreamer;
|
|
class LLVMContext;
|
|
class Module;
|
|
class ModulePass;
|
|
class raw_ostream;
|
|
|
|
/// 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,
|
|
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,
|
|
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,
|
|
DiagnosticHandlerFunction DiagnosticHandler = nullptr);
|
|
|
|
/// Read the specified bitcode file, returning the module.
|
|
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
|
|
/// should be in "binary" mode.
|
|
void WriteBitcodeToFile(const Module *M, raw_ostream &Out);
|
|
|
|
|
|
/// isBitcodeWrapper - Return true if the given bytes are the magic bytes
|
|
/// for an LLVM IR bitcode wrapper.
|
|
///
|
|
inline bool isBitcodeWrapper(const unsigned char *BufPtr,
|
|
const unsigned char *BufEnd) {
|
|
// See if you can find the hidden message in the magic bytes :-).
|
|
// (Hint: it's a little-endian encoding.)
|
|
return BufPtr != BufEnd &&
|
|
BufPtr[0] == 0xDE &&
|
|
BufPtr[1] == 0xC0 &&
|
|
BufPtr[2] == 0x17 &&
|
|
BufPtr[3] == 0x0B;
|
|
}
|
|
|
|
/// isRawBitcode - Return true if the given bytes are the magic bytes for
|
|
/// raw LLVM IR bitcode (without a wrapper).
|
|
///
|
|
inline bool isRawBitcode(const unsigned char *BufPtr,
|
|
const unsigned char *BufEnd) {
|
|
// These bytes sort of have a hidden message, but it's not in
|
|
// little-endian this time, and it's a little redundant.
|
|
return BufPtr != BufEnd &&
|
|
BufPtr[0] == 'B' &&
|
|
BufPtr[1] == 'C' &&
|
|
BufPtr[2] == 0xc0 &&
|
|
BufPtr[3] == 0xde;
|
|
}
|
|
|
|
/// isBitcode - Return true if the given bytes are the magic bytes for
|
|
/// LLVM IR bitcode, either with or without a wrapper.
|
|
///
|
|
inline bool isBitcode(const unsigned char *BufPtr,
|
|
const unsigned char *BufEnd) {
|
|
return isBitcodeWrapper(BufPtr, BufEnd) ||
|
|
isRawBitcode(BufPtr, BufEnd);
|
|
}
|
|
|
|
/// SkipBitcodeWrapperHeader - Some systems wrap bc files with a special
|
|
/// header for padding or other reasons. The format of this header is:
|
|
///
|
|
/// struct bc_header {
|
|
/// uint32_t Magic; // 0x0B17C0DE
|
|
/// uint32_t Version; // Version, currently always 0.
|
|
/// uint32_t BitcodeOffset; // Offset to traditional bitcode file.
|
|
/// uint32_t BitcodeSize; // Size of traditional bitcode file.
|
|
/// ... potentially other gunk ...
|
|
/// };
|
|
///
|
|
/// This function is called when we find a file with a matching magic number.
|
|
/// In this case, skip down to the subsection of the file that is actually a
|
|
/// BC file.
|
|
/// If 'VerifyBufferSize' is true, check that the buffer is large enough to
|
|
/// contain the whole bitcode file.
|
|
inline bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr,
|
|
const unsigned char *&BufEnd,
|
|
bool VerifyBufferSize) {
|
|
enum {
|
|
KnownHeaderSize = 4*4, // Size of header we read.
|
|
OffsetField = 2*4, // Offset in bytes to Offset field.
|
|
SizeField = 3*4 // Offset in bytes to Size field.
|
|
};
|
|
|
|
// Must contain the header!
|
|
if (BufEnd-BufPtr < KnownHeaderSize) return true;
|
|
|
|
unsigned Offset = ( BufPtr[OffsetField ] |
|
|
(BufPtr[OffsetField+1] << 8) |
|
|
(BufPtr[OffsetField+2] << 16) |
|
|
(BufPtr[OffsetField+3] << 24));
|
|
unsigned Size = ( BufPtr[SizeField ] |
|
|
(BufPtr[SizeField +1] << 8) |
|
|
(BufPtr[SizeField +2] << 16) |
|
|
(BufPtr[SizeField +3] << 24));
|
|
|
|
// Verify that Offset+Size fits in the file.
|
|
if (VerifyBufferSize && Offset+Size > unsigned(BufEnd-BufPtr))
|
|
return true;
|
|
BufPtr += Offset;
|
|
BufEnd = BufPtr+Size;
|
|
return false;
|
|
}
|
|
|
|
const std::error_category &BitcodeErrorCategory();
|
|
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 {
|
|
template <> struct is_error_code_enum<llvm::BitcodeError> : std::true_type {};
|
|
}
|
|
|
|
#endif
|