1 files changed, 255 insertions, 0 deletions
diff --git a/clang-r344140b/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h b/clang-r344140b/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
new file mode 100644
index 00000000..52250662
--- /dev/null
+++ b/clang-r344140b/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
@@ -0,0 +1,255 @@
+//===- ExecutionUtils.h - Utilities for executing code in Orc ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Contains utilities for executing code in Orc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H
+
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/OrcError.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include <algorithm>
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace llvm {
+
+class ConstantArray;
+class GlobalVariable;
+class Function;
+class Module;
+class TargetMachine;
+class Value;
+
+namespace orc {
+
+/// This iterator provides a convenient way to iterate over the elements
+///        of an llvm.global_ctors/llvm.global_dtors instance.
+///
+///   The easiest way to get hold of instances of this class is to use the
+/// getConstructors/getDestructors functions.
+class CtorDtorIterator {
+public:
+  /// Accessor for an element of the global_ctors/global_dtors array.
+  ///
+  ///   This class provides a read-only view of the element with any casts on
+  /// the function stripped away.
+  struct Element {
+    Element(unsigned Priority, Function *Func, Value *Data)
+      : Priority(Priority), Func(Func), Data(Data) {}
+
+    unsigned Priority;
+    Function *Func;
+    Value *Data;
+  };
+
+  /// Construct an iterator instance. If End is true then this iterator
+  ///        acts as the end of the range, otherwise it is the beginning.
+  CtorDtorIterator(const GlobalVariable *GV, bool End);
+
+  /// Test iterators for equality.
+  bool operator==(const CtorDtorIterator &Other) const;
+
+  /// Test iterators for inequality.
+  bool operator!=(const CtorDtorIterator &Other) const;
+
+  /// Pre-increment iterator.
+  CtorDtorIterator& operator++();
+
+  /// Post-increment iterator.
+  CtorDtorIterator operator++(int);
+
+  /// Dereference iterator. The resulting value provides a read-only view
+  ///        of this element of the global_ctors/global_dtors list.
+  Element operator*() const;
+
+private:
+  const ConstantArray *InitList;
+  unsigned I;
+};
+
+/// Create an iterator range over the entries of the llvm.global_ctors
+///        array.
+iterator_range<CtorDtorIterator> getConstructors(const Module &M);
+
+/// Create an iterator range over the entries of the llvm.global_ctors
+///        array.
+iterator_range<CtorDtorIterator> getDestructors(const Module &M);
+
+/// Convenience class for recording constructor/destructor names for
+///        later execution.
+template <typename JITLayerT>
+class CtorDtorRunner {
+public:
+  /// Construct a CtorDtorRunner for the given range using the given
+  ///        name mangling function.
+  CtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K)
+      : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
+
+  /// Run the recorded constructors/destructors through the given JIT
+  ///        layer.
+  Error runViaLayer(JITLayerT &JITLayer) const {
+    using CtorDtorTy = void (*)();
+
+    for (const auto &CtorDtorName : CtorDtorNames) {
+      if (auto CtorDtorSym = JITLayer.findSymbolIn(K, CtorDtorName, false)) {
+        if (auto AddrOrErr = CtorDtorSym.getAddress()) {
+          CtorDtorTy CtorDtor =
+            reinterpret_cast<CtorDtorTy>(static_cast<uintptr_t>(*AddrOrErr));
+          CtorDtor();
+        } else
+          return AddrOrErr.takeError();
+      } else {
+        if (auto Err = CtorDtorSym.takeError())
+          return Err;
+        else
+          return make_error<JITSymbolNotFound>(CtorDtorName);
+      }
+    }
+    return Error::success();
+  }
+
+private:
+  std::vector<std::string> CtorDtorNames;
+  orc::VModuleKey K;
+};
+
+class CtorDtorRunner2 {
+public:
+  CtorDtorRunner2(JITDylib &JD) : JD(JD) {}
+  void add(iterator_range<CtorDtorIterator> CtorDtors);
+  Error run();
+
+private:
+  using CtorDtorList = std::vector<SymbolStringPtr>;
+  using CtorDtorPriorityMap = std::map<unsigned, CtorDtorList>;
+
+  JITDylib &JD;
+  CtorDtorPriorityMap CtorDtorsByPriority;
+};
+
+/// Support class for static dtor execution. For hosted (in-process) JITs
+///        only!
+///
+///   If a __cxa_atexit function isn't found C++ programs that use static
+/// destructors will fail to link. However, we don't want to use the host
+/// process's __cxa_atexit, because it will schedule JIT'd destructors to run
+/// after the JIT has been torn down, which is no good. This class makes it easy
+/// to override __cxa_atexit (and the related __dso_handle).
+///
+///   To use, clients should manually call searchOverrides from their symbol
+/// resolver. This should generally be done after attempting symbol resolution
+/// inside the JIT, but before searching the host process's symbol table. When
+/// the client determines that destructors should be run (generally at JIT
+/// teardown or after a return from main), the runDestructors method should be
+/// called.
+class LocalCXXRuntimeOverridesBase {
+public:
+  /// Run any destructors recorded by the overriden __cxa_atexit function
+  /// (CXAAtExitOverride).
+  void runDestructors();
+
+protected:
+  template <typename PtrTy> JITTargetAddress toTargetAddress(PtrTy *P) {
+    return static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(P));
+  }
+
+  using DestructorPtr = void (*)(void *);
+  using CXXDestructorDataPair = std::pair<DestructorPtr, void *>;
+  using CXXDestructorDataPairList = std::vector<CXXDestructorDataPair>;
+  CXXDestructorDataPairList DSOHandleOverride;
+  static int CXAAtExitOverride(DestructorPtr Destructor, void *Arg,
+                               void *DSOHandle);
+};
+
+class LocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
+public:
+  /// Create a runtime-overrides class.
+  template <typename MangleFtorT>
+  LocalCXXRuntimeOverrides(const MangleFtorT &Mangle) {
+    addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride));
+    addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride));
+  }
+
+  /// Search overrided symbols.
+  JITEvaluatedSymbol searchOverrides(const std::string &Name) {
+    auto I = CXXRuntimeOverrides.find(Name);
+    if (I != CXXRuntimeOverrides.end())
+      return JITEvaluatedSymbol(I->second, JITSymbolFlags::Exported);
+    return nullptr;
+  }
+
+private:
+  void addOverride(const std::string &Name, JITTargetAddress Addr) {
+    CXXRuntimeOverrides.insert(std::make_pair(Name, Addr));
+  }
+
+  StringMap<JITTargetAddress> CXXRuntimeOverrides;
+};
+
+class LocalCXXRuntimeOverrides2 : public LocalCXXRuntimeOverridesBase {
+public:
+  Error enable(JITDylib &JD, MangleAndInterner &Mangler);
+};
+
+/// A utility class to expose symbols found via dlsym to the JIT.
+///
+/// If an instance of this class is attached to a JITDylib as a fallback
+/// definition generator, then any symbol found in the given DynamicLibrary that
+/// passes the 'Allow' predicate will be added to the JITDylib.
+class DynamicLibraryFallbackGenerator {
+public:
+  using SymbolPredicate = std::function<bool(SymbolStringPtr)>;
+
+  static bool AllowAll(SymbolStringPtr Name) { return true; }
+
+  /// Create a DynamicLibraryFallbackGenerator that searches for symbols in the
+  /// given sys::DynamicLibrary.
+  /// Only symbols that match the 'Allow' predicate will be searched for.
+  DynamicLibraryFallbackGenerator(sys::DynamicLibrary Dylib,
+                                  const DataLayout &DL,
+                                  SymbolPredicate Allow = AllowAll);
+
+  /// Permanently loads the library at the given path and, on success, returns
+  /// a DynamicLibraryFallbackGenerator that will search it for symbol
+  /// definitions matching the Allow predicate.
+  /// On failure returns the reason the library failed to load.
+  static Expected<DynamicLibraryFallbackGenerator>
+  Load(const char *FileName, const DataLayout &DL,
+       SymbolPredicate Allow = AllowAll);
+
+  /// Creates a DynamicLibraryFallbackGenerator that searches for symbols in
+  /// the current process.
+  static Expected<DynamicLibraryFallbackGenerator>
+  CreateForCurrentProcess(const DataLayout &DL,
+                          SymbolPredicate Allow = AllowAll) {
+    return Load(nullptr, DL, std::move(Allow));
+  }
+
+  SymbolNameSet operator()(JITDylib &JD, const SymbolNameSet &Names);
+
+private:
+  sys::DynamicLibrary Dylib;
+  SymbolPredicate Allow;
+  char GlobalPrefix;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H