2 files changed, 146 insertions, 0 deletions
diff --git a/clang-r353983e/include/llvm/Linker/IRMover.h b/clang-r353983e/include/llvm/Linker/IRMover.h
new file mode 100644
index 00000000..e5df83f0
--- /dev/null
+++ b/clang-r353983e/include/llvm/Linker/IRMover.h
@@ -0,0 +1,88 @@
+//===- IRMover.h ------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LINKER_IRMOVER_H
+#define LLVM_LINKER_IRMOVER_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
+#include <functional>
+
+namespace llvm {
+class Error;
+class GlobalValue;
+class Metadata;
+class Module;
+class StructType;
+class TrackingMDRef;
+class Type;
+
+class IRMover {
+  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);
+  };
+
+  /// Type of the Metadata map in \a ValueToValueMapTy.
+  typedef DenseMap<const Metadata *, TrackingMDRef> MDMapT;
+
+public:
+  class IdentifiedStructTypeSet {
+    // The set of opaque types is the composite module.
+    DenseSet<StructType *> OpaqueStructTypes;
+
+    // The set of identified but non opaque structures in the composite module.
+    DenseSet<StructType *, StructTypeKeyInfo> NonOpaqueStructTypes;
+
+  public:
+    void addNonOpaque(StructType *Ty);
+    void switchToNonOpaque(StructType *Ty);
+    void addOpaque(StructType *Ty);
+    StructType *findNonOpaque(ArrayRef<Type *> ETypes, bool IsPacked);
+    bool hasType(StructType *Ty);
+  };
+
+  IRMover(Module &M);
+
+  typedef std::function<void(GlobalValue &)> ValueAdder;
+
+  /// Move in the provide values in \p ValuesToLink from \p Src.
+  ///
+  /// - \p AddLazyFor is a call back that the IRMover will call when a global
+  ///   value is referenced by one of the ValuesToLink (transitively) but was
+  ///   not present in ValuesToLink. The GlobalValue and a ValueAdder callback
+  ///   are passed as an argument, and the callback is expected to be called
+  ///   if the GlobalValue needs to be added to the \p ValuesToLink and linked.
+  /// - \p IsPerformingImport is true when this IR link is to perform ThinLTO
+  ///   function importing from Src.
+  Error move(std::unique_ptr<Module> Src, ArrayRef<GlobalValue *> ValuesToLink,
+             std::function<void(GlobalValue &GV, ValueAdder Add)> AddLazyFor,
+             bool IsPerformingImport);
+  Module &getModule() { return Composite; }
+
+private:
+  Module &Composite;
+  IdentifiedStructTypeSet IdentifiedStructTypes;
+  MDMapT SharedMDs; ///< A Metadata map to use for all calls to \a move().
+};
+
+} // End llvm namespace
+
+#endif
diff --git a/clang-r353983e/include/llvm/Linker/Linker.h b/clang-r353983e/include/llvm/Linker/Linker.h
new file mode 100644
index 00000000..c9b1d42b
--- /dev/null
+++ b/clang-r353983e/include/llvm/Linker/Linker.h
@@ -0,0 +1,58 @@
+//===- Linker.h - Module Linker Interface -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LINKER_LINKER_H
+#define LLVM_LINKER_LINKER_H
+
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Linker/IRMover.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 {
+  IRMover Mover;
+
+public:
+  enum Flags {
+    None = 0,
+    OverrideFromSrc = (1 << 0),
+    LinkOnlyNeeded = (1 << 1),
+  };
+
+  Linker(Module &M);
+
+  /// Link \p Src into the composite.
+  ///
+  /// Passing OverrideSymbols as true will have symbols from Src
+  /// shadow those in the Dest.
+  ///
+  /// Passing InternalizeCallback will have the linker call the function with
+  /// the new module and a list of global value names to be internalized by the
+  /// callback.
+  ///
+  /// Returns true on error.
+  bool linkInModule(std::unique_ptr<Module> Src, unsigned Flags = Flags::None,
+                    std::function<void(Module &, const StringSet<> &)>
+                        InternalizeCallback = {});
+
+  static bool linkModules(Module &Dest, std::unique_ptr<Module> Src,
+                          unsigned Flags = Flags::None,
+                          std::function<void(Module &, const StringSet<> &)>
+                              InternalizeCallback = {});
+};
+
+} // End llvm namespace
+
+#endif