File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/include/llvm/ExecutionEngine/Orc

usr / src / contrib / llvm-project / llvm / include / llvm / ExecutionEngine / Orc /

📁 ..
📄 CompileOnDemandLayer.h(27.24 KB)
📄 CompileUtils.h(3.29 KB)
📄 Core.h(55.04 KB)
📄 DebugUtils.h(4.59 KB)
📄 ExecutionUtils.h(14.17 KB)
📄 GlobalMappingLayer.h(4.02 KB)
📄 IRCompileLayer.h(5.87 KB)
📄 IRTransformLayer.h(4.85 KB)
📄 IndirectionUtils.h(20.75 KB)
📄 JITTargetMachineBuilder.h(5.01 KB)
📄 LLJIT.h(15.66 KB)
📄 LambdaResolver.h(3.16 KB)
📄 Layer.h(6.29 KB)
📄 LazyEmittingLayer.h(10.08 KB)
📄 LazyReexports.h(6.64 KB)
📄 Legacy.h(7.73 KB)
📄 MachOPlatform.h(5.27 KB)
📄 Mangling.h(2.31 KB)
📄 NullResolver.h(1.47 KB)
📄 ObjectLinkingLayer.h(7.25 KB)
📄 ObjectTransformLayer.h(5.02 KB)
📄 OrcABISupport.h(14.54 KB)
📄 OrcError.h(2.04 KB)
📄 OrcRemoteTargetClient.h(25.06 KB)
📄 OrcRemoteTargetRPCAPI.h(11.49 KB)
📄 OrcRemoteTargetServer.h(17.19 KB)
📁 RPC
📄 RTDyldObjectLinkingLayer.h(18.95 KB)
📄 RemoteObjectLayer.h(19.84 KB)
📄 SpeculateAnalyses.h(2.87 KB)
📄 Speculation.h(7.31 KB)
📄 SymbolStringPool.h(5.39 KB)
📄 ThreadSafeModule.h(5.53 KB)

Editing: LazyReexports.h

//===------ LazyReexports.h -- Utilities for lazy reexports -----*- 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
//
//===----------------------------------------------------------------------===//
//
// Lazy re-exports are similar to normal re-exports, except that for callable
// symbols the definitions are replaced with trampolines that will look up and
// call through to the re-exported symbol at runtime. This can be used to
// enable lazy compilation.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_EXECUTIONENGINE_ORC_LAZYREEXPORTS_H
#define LLVM_EXECUTIONENGINE_ORC_LAZYREEXPORTS_H

#include "llvm/ADT/STLExtras.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
#include "llvm/ExecutionEngine/Orc/Speculation.h"

namespace llvm {

class Triple;

namespace orc {

/// Manages a set of 'lazy call-through' trampolines. These are compiler
/// re-entry trampolines that are pre-bound to look up a given symbol in a given
/// JITDylib, then jump to that address. Since compilation of symbols is
/// triggered on first lookup, these call-through trampolines can be used to
/// implement lazy compilation.
///
/// The easiest way to construct these call-throughs is using the lazyReexport
/// function.
class LazyCallThroughManager {
public:
  using NotifyResolvedFunction =
      unique_function<Error(JITTargetAddress ResolvedAddr)>;

// Return a free call-through trampoline and bind it to look up and call
  // through to the given symbol.
  Expected<JITTargetAddress>
  getCallThroughTrampoline(JITDylib &SourceJD, SymbolStringPtr SymbolName,
                           NotifyResolvedFunction NotifyResolved);

void resolveTrampolineLandingAddress(
      JITTargetAddress TrampolineAddr,
      TrampolinePool::NotifyLandingResolvedFunction NotifyLandingResolved);

virtual ~LazyCallThroughManager() = default;

protected:
  using NotifyLandingResolvedFunction =
      TrampolinePool::NotifyLandingResolvedFunction;

LazyCallThroughManager(ExecutionSession &ES,
                         JITTargetAddress ErrorHandlerAddr, TrampolinePool *TP);

struct ReexportsEntry {
    JITDylib *SourceJD;
    SymbolStringPtr SymbolName;
  };

JITTargetAddress reportCallThroughError(Error Err);
  Expected<ReexportsEntry> findReexport(JITTargetAddress TrampolineAddr);
  Error notifyResolved(JITTargetAddress TrampolineAddr,
                       JITTargetAddress ResolvedAddr);
  void setTrampolinePool(TrampolinePool &TP) { this->TP = &TP; }

private:
  using ReexportsMap = std::map<JITTargetAddress, ReexportsEntry>;

using NotifiersMap = std::map<JITTargetAddress, NotifyResolvedFunction>;

std::mutex LCTMMutex;
  ExecutionSession &ES;
  JITTargetAddress ErrorHandlerAddr;
  TrampolinePool *TP = nullptr;
  ReexportsMap Reexports;
  NotifiersMap Notifiers;
};

/// A lazy call-through manager that builds trampolines in the current process.
class LocalLazyCallThroughManager : public LazyCallThroughManager {
private:
  using NotifyTargetResolved = unique_function<void(JITTargetAddress)>;

LocalLazyCallThroughManager(ExecutionSession &ES,
                              JITTargetAddress ErrorHandlerAddr)
      : LazyCallThroughManager(ES, ErrorHandlerAddr, nullptr) {}

template <typename ORCABI> Error init() {
    auto TP = LocalTrampolinePool<ORCABI>::Create(
        [this](JITTargetAddress TrampolineAddr,
               TrampolinePool::NotifyLandingResolvedFunction
                   NotifyLandingResolved) {
          resolveTrampolineLandingAddress(TrampolineAddr,
                                          std::move(NotifyLandingResolved));
        });

if (!TP)
      return TP.takeError();

this->TP = std::move(*TP);
    setTrampolinePool(*this->TP);
    return Error::success();
  }

std::unique_ptr<TrampolinePool> TP;

public:
  /// Create a LocalLazyCallThroughManager using the given ABI. See
  /// createLocalLazyCallThroughManager.
  template <typename ORCABI>
  static Expected<std::unique_ptr<LocalLazyCallThroughManager>>
  Create(ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) {
    auto LLCTM = std::unique_ptr<LocalLazyCallThroughManager>(
        new LocalLazyCallThroughManager(ES, ErrorHandlerAddr));

if (auto Err = LLCTM->init<ORCABI>())
      return std::move(Err);

return std::move(LLCTM);
  }
};

/// Create a LocalLazyCallThroughManager from the given triple and execution
/// session.
Expected<std::unique_ptr<LazyCallThroughManager>>
createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES,
                                  JITTargetAddress ErrorHandlerAddr);

/// A materialization unit that builds lazy re-exports. These are callable
/// entry points that call through to the given symbols.
/// Unlike a 'true' re-export, the address of the lazy re-export will not
/// match the address of the re-exported symbol, but calling it will behave
/// the same as calling the re-exported symbol.
class LazyReexportsMaterializationUnit : public MaterializationUnit {
public:
  LazyReexportsMaterializationUnit(LazyCallThroughManager &LCTManager,
                                   IndirectStubsManager &ISManager,
                                   JITDylib &SourceJD,
                                   SymbolAliasMap CallableAliases,
                                   ImplSymbolMap *SrcJDLoc, VModuleKey K);

StringRef getName() const override;

private:
  void materialize(MaterializationResponsibility R) override;
  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
  static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases);

LazyCallThroughManager &LCTManager;
  IndirectStubsManager &ISManager;
  JITDylib &SourceJD;
  SymbolAliasMap CallableAliases;
  ImplSymbolMap *AliaseeTable;
};

/// Define lazy-reexports based on the given SymbolAliasMap. Each lazy re-export
/// is a callable symbol that will look up and dispatch to the given aliasee on
/// first call. All subsequent calls will go directly to the aliasee.
inline std::unique_ptr<LazyReexportsMaterializationUnit>
lazyReexports(LazyCallThroughManager &LCTManager,
              IndirectStubsManager &ISManager, JITDylib &SourceJD,
              SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc = nullptr,
              VModuleKey K = VModuleKey()) {
  return std::make_unique<LazyReexportsMaterializationUnit>(
      LCTManager, ISManager, SourceJD, std::move(CallableAliases), SrcJDLoc,
      std::move(K));
}

} // End namespace orc
} // End namespace llvm

#endif // LLVM_EXECUTIONENGINE_ORC_LAZYREEXPORTS_H

003 File Manager

Editing: LazyReexports.h

Upload File

Create Folder