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   enum Flags {
  64     None = 0,
  65     OverrideFromSrc = (1 << 0),
  66     LinkOnlyNeeded = (1 << 1),
  67     InternalizeLinkedSymbols = (1 << 2)
  68   };
  69
  70   Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
  71   Linker(Module *M);
  72
  73   Module *getModule() const { return Composite; }
  74   void deleteModule();
  75
  76   /// \brief Link \p Src into the composite. The source is destroyed.
  77   /// Passing OverrideSymbols as true will have symbols from Src
  78   /// shadow those in the Dest.
  79   /// Returns true on error.
  80   bool linkInModule(Module *Src, unsigned Flags = Flags::None);
  81
  82   /// \brief Set the composite to the passed-in module.
  83   void setModule(Module *Dst);
  84
  85   static bool LinkModules(Module *Dest, Module *Src,
  86                           DiagnosticHandlerFunction DiagnosticHandler,
  87                           unsigned Flags = Flags::None);
  88
  89   static bool LinkModules(Module *Dest, Module *Src,
  90                           unsigned Flags = Flags::None);
  91
  92 private:
  93   void init(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
  94   Module *Composite;
  95
  96   IdentifiedStructTypeSet IdentifiedStructTypes;
  97
  98   DiagnosticHandlerFunction DiagnosticHandler;
  99 };
 100
 101 } // End llvm namespace
 102
 103 #endif