LLVM 20.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
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:1431
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 emit(std::unique_ptr< MaterializationResponsibility > R, std::unique_ptr< MemoryBuffer > O) override
Emit the object.
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