LLVM 19.0.0git
RTDyldObjectLinkingLayer.h
Go to the documentation of this file.
1//===- RTDyldObjectLinkingLayer.h - RTDyld-based jit linking ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Contains the definition for an RTDyld-based, in-process object linking layer.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_ORC_RTDYLDOBJECTLINKINGLAYER_H
14#define LLVM_EXECUTIONENGINE_ORC_RTDYLDOBJECTLINKINGLAYER_H
15
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/StringRef.h"
24#include "llvm/Support/Error.h"
25#include <algorithm>
26#include <cassert>
27#include <functional>
28#include <list>
29#include <memory>
30#include <utility>
31#include <vector>
32
33namespace llvm {
34namespace orc {
35
37 : public RTTIExtends<RTDyldObjectLinkingLayer, ObjectLayer>,
38 private ResourceManager {
39public:
40 static char ID;
41
42 /// Functor for receiving object-loaded notifications.
43 using NotifyLoadedFunction = std::function<void(
46
47 /// Functor for receiving finalization notifications.
48 using NotifyEmittedFunction = std::function<void(
49 MaterializationResponsibility &R, std::unique_ptr<MemoryBuffer>)>;
50
53
54 /// Construct an ObjectLinkingLayer with the given NotifyLoaded,
55 /// and NotifyEmitted functors.
57 GetMemoryManagerFunction GetMemoryManager);
58
60
61 /// Emit the object.
62 void emit(std::unique_ptr<MaterializationResponsibility> R,
63 std::unique_ptr<MemoryBuffer> O) override;
64
65 /// Set the NotifyLoaded callback.
67 this->NotifyLoaded = std::move(NotifyLoaded);
68 return *this;
69 }
70
71 /// Set the NotifyEmitted callback.
74 this->NotifyEmitted = std::move(NotifyEmitted);
75 return *this;
76 }
77
78 /// Set the 'ProcessAllSections' flag.
79 ///
80 /// If set to true, all sections in each object file will be allocated using
81 /// the memory manager, rather than just the sections required for execution.
82 ///
83 /// This is kludgy, and may be removed in the future.
85 this->ProcessAllSections = ProcessAllSections;
86 return *this;
87 }
88
89 /// Instructs this RTDyldLinkingLayer2 instance to override the symbol flags
90 /// returned by RuntimeDyld for any given object file with the flags supplied
91 /// by the MaterializationResponsibility instance. This is a workaround to
92 /// support symbol visibility in COFF, which does not use the libObject's
93 /// SF_Exported flag. Use only when generating / adding COFF object files.
94 ///
95 /// FIXME: We should be able to remove this if/when COFF properly tracks
96 /// exported symbols.
99 this->OverrideObjectFlags = OverrideObjectFlags;
100 return *this;
101 }
102
103 /// If set, this RTDyldObjectLinkingLayer instance will claim responsibility
104 /// for any symbols provided by a given object file that were not already in
105 /// the MaterializationResponsibility instance. Setting this flag allows
106 /// higher-level program representations (e.g. LLVM IR) to be added based on
107 /// only a subset of the symbols they provide, without having to write
108 /// intervening layers to scan and add the additional symbols. This trades
109 /// diagnostic quality for convenience however: If all symbols are enumerated
110 /// up-front then clashes can be detected and reported early (and usually
111 /// deterministically). If this option is set, clashes for the additional
112 /// symbols may not be detected until late, and detection may depend on
113 /// the flow of control through JIT'd code. Use with care.
115 setAutoClaimResponsibilityForObjectSymbols(bool AutoClaimObjectSymbols) {
116 this->AutoClaimObjectSymbols = AutoClaimObjectSymbols;
117 return *this;
118 }
119
120 /// Register a JITEventListener.
122
123 /// Unregister a JITEventListener.
125
126private:
127 using MemoryManagerUP = std::unique_ptr<RuntimeDyld::MemoryManager>;
128
130 const object::ObjectFile &Obj,
132 RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
133 std::map<StringRef, JITEvaluatedSymbol> Resolved,
134 std::set<StringRef> &InternalSymbols);
135
136 void onObjEmit(MaterializationResponsibility &R,
138 std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
139 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
140 std::unique_ptr<SymbolDependenceMap> Deps, Error Err);
141
142 Error handleRemoveResources(JITDylib &JD, ResourceKey K) override;
143 void handleTransferResources(JITDylib &JD, ResourceKey DstKey,
144 ResourceKey SrcKey) override;
145
146 mutable std::mutex RTDyldLayerMutex;
147 GetMemoryManagerFunction GetMemoryManager;
148 NotifyLoadedFunction NotifyLoaded;
149 NotifyEmittedFunction NotifyEmitted;
150 bool ProcessAllSections = false;
151 bool OverrideObjectFlags = false;
152 bool AutoClaimObjectSymbols = false;
154 std::vector<JITEventListener *> EventListeners;
155};
156
157} // end namespace orc
158} // end namespace llvm
159
160#endif // LLVM_EXECUTIONENGINE_ORC_RTDYLDOBJECTLINKINGLAYER_H
dxil metadata emit
This file contains some templates that are useful if you are working with the STL at all.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
JITEventListener - Abstract interface for use by the JIT to notify clients about significant events d...
Inheritance utility for extensible RTTI.
Information about the loaded object.
Definition: RuntimeDyld.h:69
This class is the base class for all object file types.
Definition: ObjectFile.h:229
An ExecutionSession represents a running JIT program.
Definition: Core.h:1425
Represents a JIT'd dynamic library.
Definition: Core.h:989
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
Definition: Core.h:555
RTDyldObjectLinkingLayer & setNotifyLoaded(NotifyLoadedFunction NotifyLoaded)
Set the NotifyLoaded callback.
std::function< void(MaterializationResponsibility &R, std::unique_ptr< MemoryBuffer >)> NotifyEmittedFunction
Functor for receiving finalization notifications.
unique_function< std::unique_ptr< RuntimeDyld::MemoryManager >()> GetMemoryManagerFunction
RTDyldObjectLinkingLayer & setNotifyEmitted(NotifyEmittedFunction NotifyEmitted)
Set the NotifyEmitted callback.
void unregisterJITEventListener(JITEventListener &L)
Unregister a JITEventListener.
RTDyldObjectLinkingLayer & setAutoClaimResponsibilityForObjectSymbols(bool AutoClaimObjectSymbols)
If set, this RTDyldObjectLinkingLayer instance will claim responsibility for any symbols provided by ...
RTDyldObjectLinkingLayer & setProcessAllSections(bool ProcessAllSections)
Set the 'ProcessAllSections' flag.
RTDyldObjectLinkingLayer & setOverrideObjectFlagsWithResponsibilityFlags(bool OverrideObjectFlags)
Instructs this RTDyldLinkingLayer2 instance to override the symbol flags returned by RuntimeDyld for ...
void registerJITEventListener(JITEventListener &L)
Register a JITEventListener.
std::function< void(MaterializationResponsibility &R, const object::ObjectFile &Obj, const RuntimeDyld::LoadedObjectInfo &)> NotifyLoadedFunction
Functor for receiving object-loaded notifications.
Listens for ResourceTracker operations.
Definition: Core.h:104
@ Resolved
Queried, materialization begun.
uintptr_t ResourceKey
Definition: Core.h:53
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18