include/llvm/Linker/Linker.h

   1 //===- Linker.h - Module Linker Interface -----------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_LINKER_LINKER_H
  11 #define LLVM_LINKER_LINKER_H
  12
  13 #include "llvm/ADT/ArrayRef.h"
  14 #include "llvm/ADT/DenseMap.h"
  15 #include "llvm/ADT/DenseSet.h"
  16 #include "llvm/IR/DiagnosticInfo.h"
  17
  18 namespace llvm {
  19 class Module;
  20 class StructType;
  21 class Type;
  22
  23 /// This class provides the core functionality of linking in LLVM. It keeps a
  24 /// pointer to the merged module so far. It doesn't take ownership of the
  25 /// module since it is assumed that the user of this class will want to do
  26 /// something with it after the linking.
  27 class Linker {
  28 public:
  29   struct StructTypeKeyInfo {
  30     struct KeyTy {
  31       ArrayRef<Type *> ETypes;
  32       bool IsPacked;
  33       KeyTy(ArrayRef<Type *> E, bool P);
  34       KeyTy(const StructType *ST);
  35       bool operator==(const KeyTy &that) const;
  36       bool operator!=(const KeyTy &that) const;
  37     };
  38     static StructType *getEmptyKey();
  39     static StructType *getTombstoneKey();
  40     static unsigned getHashValue(const KeyTy &Key);
  41     static unsigned getHashValue(const StructType *ST);
  42     static bool isEqual(const KeyTy &LHS, const StructType *RHS);
  43     static bool isEqual(const StructType *LHS, const StructType *RHS);
  44   };
  45
  46   typedef DenseSet<StructType *, StructTypeKeyInfo> NonOpaqueStructTypeSet;
  47   typedef DenseSet<StructType *> OpaqueStructTypeSet;
  48
  49   struct IdentifiedStructTypeSet {
  50     // The set of opaque types is the composite module.
  51     OpaqueStructTypeSet OpaqueStructTypes;
  52
  53     // The set of identified but non opaque structures in the composite module.
  54     NonOpaqueStructTypeSet NonOpaqueStructTypes;
  55
  56     void addNonOpaque(StructType *Ty);
  57     void switchToNonOpaque(StructType *Ty);
  58     void addOpaque(StructType *Ty);
  59     StructType *findNonOpaque(ArrayRef<Type *> ETypes, bool IsPacked);
  60     bool hasType(StructType *Ty);
  61   };
  62
  63   Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
  64   Linker(Module *M);
  65   ~Linker();
  66
  67   Module *getModule() const { return Composite; }
  68   void deleteModule();
  69
  70   /// \brief Link \p Src into the composite. The source is destroyed.
  71   /// Returns true on error.
  72   bool linkInModule(Module *Src);
  73
  74   /// \brief Set the composite to the passed-in module.
  75   void setModule(Module *Dst);
  76
  77   static bool LinkModules(Module *Dest, Module *Src,
  78                           DiagnosticHandlerFunction DiagnosticHandler);
  79
  80   static bool LinkModules(Module *Dest, Module *Src);
  81
  82 private:
  83   void init(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
  84   Module *Composite;
  85
  86   IdentifiedStructTypeSet IdentifiedStructTypes;
  87
  88   DiagnosticHandlerFunction DiagnosticHandler;
  89 };
  90
  91 } // End llvm namespace
  92
  93 #endif