mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
68016e0a6e
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
90 lines
2.7 KiB
C++
90 lines
2.7 KiB
C++
//===- Linker.h - Module Linker Interface -----------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LINKER_LINKER_H
|
|
#define LLVM_LINKER_LINKER_H
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/DenseSet.h"
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
|
|
|
namespace llvm {
|
|
class Module;
|
|
class StructType;
|
|
class Type;
|
|
|
|
/// This class provides the core functionality of linking in LLVM. It keeps a
|
|
/// pointer to the merged module so far. It doesn't take ownership of the
|
|
/// module since it is assumed that the user of this class will want to do
|
|
/// something with it after the linking.
|
|
class Linker {
|
|
public:
|
|
struct StructTypeKeyInfo {
|
|
struct KeyTy {
|
|
ArrayRef<Type *> ETypes;
|
|
bool IsPacked;
|
|
KeyTy(ArrayRef<Type *> E, bool P);
|
|
KeyTy(const StructType *ST);
|
|
bool operator==(const KeyTy &that) const;
|
|
bool operator!=(const KeyTy &that) const;
|
|
};
|
|
static StructType *getEmptyKey();
|
|
static StructType *getTombstoneKey();
|
|
static unsigned getHashValue(const KeyTy &Key);
|
|
static unsigned getHashValue(const StructType *ST);
|
|
static bool isEqual(const KeyTy &LHS, const StructType *RHS);
|
|
static bool isEqual(const StructType *LHS, const StructType *RHS);
|
|
};
|
|
|
|
typedef DenseSet<StructType *, StructTypeKeyInfo> NonOpaqueStructTypeSet;
|
|
typedef DenseSet<StructType *> OpaqueStructTypeSet;
|
|
|
|
struct IdentifiedStructTypeSet {
|
|
// The set of opaque types is the composite module.
|
|
OpaqueStructTypeSet OpaqueStructTypes;
|
|
|
|
// The set of identified but non opaque structures in the composite module.
|
|
NonOpaqueStructTypeSet NonOpaqueStructTypes;
|
|
|
|
void addNonOpaque(StructType *Ty);
|
|
void addOpaque(StructType *Ty);
|
|
StructType *findNonOpaque(ArrayRef<Type *> ETypes, bool IsPacked);
|
|
bool hasType(StructType *Ty);
|
|
};
|
|
|
|
Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
|
|
Linker(Module *M);
|
|
~Linker();
|
|
|
|
Module *getModule() const { return Composite; }
|
|
void deleteModule();
|
|
|
|
/// \brief Link \p Src into the composite. The source is destroyed.
|
|
/// Returns true on error.
|
|
bool linkInModule(Module *Src);
|
|
|
|
static bool LinkModules(Module *Dest, Module *Src,
|
|
DiagnosticHandlerFunction DiagnosticHandler);
|
|
|
|
static bool LinkModules(Module *Dest, Module *Src);
|
|
|
|
private:
|
|
void init(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
|
|
Module *Composite;
|
|
|
|
IdentifiedStructTypeSet IdentifiedStructTypes;
|
|
|
|
DiagnosticHandlerFunction DiagnosticHandler;
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|