LLVM 18.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/StringMap.h"
18#include "llvm/ADT/StringRef.h"
25#include "llvm/Support/Error.h"
26#include <algorithm>
27#include <cassert>
28#include <functional>
29#include <list>
30#include <memory>
31#include <utility>
32#include <vector>
33
34namespace llvm {
35namespace orc {
36
38 : public RTTIExtends<RTDyldObjectLinkingLayer, ObjectLayer>,
39 private ResourceManager {
40public:
41 static char ID;
42
43 /// Functor for receiving object-loaded notifications.
44 using NotifyLoadedFunction = std::function<void(
47
48 /// Functor for receiving finalization notifications.
49 using NotifyEmittedFunction = std::function<void(
50 MaterializationResponsibility &R, std::unique_ptr<MemoryBuffer>)>;
51
54
55 /// Construct an ObjectLinkingLayer with the given NotifyLoaded,
56 /// and NotifyEmitted functors.
58 GetMemoryManagerFunction GetMemoryManager);
59
61
62 /// Emit the object.
63 void emit(std::unique_ptr<MaterializationResponsibility> R,
64 std::unique_ptr<MemoryBuffer> O) override;
65
66 /// Set the NotifyLoaded callback.
68 this->NotifyLoaded = std::move(NotifyLoaded);
69 return *this;
70 }
71
72 /// Set the NotifyEmitted callback.
75 this->NotifyEmitted = std::move(NotifyEmitted);
76 return *this;
77 }
78
79 /// Set the 'ProcessAllSections' flag.
80 ///
81 /// If set to true, all sections in each object file will be allocated using
82 /// the memory manager, rather than just the sections required for execution.
83 ///
84 /// This is kludgy, and may be removed in the future.
86 this->ProcessAllSections = ProcessAllSections;
87 return *this;
88 }
89
90 /// Instructs this RTDyldLinkingLayer2 instance to override the symbol flags
91 /// returned by RuntimeDyld for any given object file with the flags supplied
92 /// by the MaterializationResponsibility instance. This is a workaround to
93 /// support symbol visibility in COFF, which does not use the libObject's
94 /// SF_Exported flag. Use only when generating / adding COFF object files.
95 ///
96 /// FIXME: We should be able to remove this if/when COFF properly tracks
97 /// exported symbols.
100 this->OverrideObjectFlags = OverrideObjectFlags;
101 return *this;
102 }
103
104 /// If set, this RTDyldObjectLinkingLayer instance will claim responsibility
105 /// for any symbols provided by a given object file that were not already in
106 /// the MaterializationResponsibility instance. Setting this flag allows
107 /// higher-level program representations (e.g. LLVM IR) to be added based on
108 /// only a subset of the symbols they provide, without having to write
109 /// intervening layers to scan and add the additional symbols. This trades
110 /// diagnostic quality for convenience however: If all symbols are enumerated
111 /// up-front then clashes can be detected and reported early (and usually
112 /// deterministically). If this option is set, clashes for the additional
113 /// symbols may not be detected until late, and detection may depend on
114 /// the flow of control through JIT'd code. Use with care.
116 setAutoClaimResponsibilityForObjectSymbols(bool AutoClaimObjectSymbols) {
117 this->AutoClaimObjectSymbols = AutoClaimObjectSymbols;
118 return *this;
119 }
120
121 /// Register a JITEventListener.
123
124 /// Unregister a JITEventListener.
126
127private:
128 using MemoryManagerUP = std::unique_ptr<RuntimeDyld::MemoryManager>;
129
131 const object::ObjectFile &Obj,
133 RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
134 std::map<StringRef, JITEvaluatedSymbol> Resolved,
135 std::set<StringRef> &InternalSymbols);
136
137 void onObjEmit(MaterializationResponsibility &R,
139 std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
140 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
141 Error Err);
142
143 Error handleRemoveResources(JITDylib &JD, ResourceKey K) override;
144 void handleTransferResources(JITDylib &JD, ResourceKey DstKey,
145 ResourceKey SrcKey) override;
146
147 mutable std::mutex RTDyldLayerMutex;
148 GetMemoryManagerFunction GetMemoryManager;
149 NotifyLoadedFunction NotifyLoaded;
150 NotifyEmittedFunction NotifyEmitted;
151 bool ProcessAllSections = false;
152 bool OverrideObjectFlags = false;
153 bool AutoClaimObjectSymbols = false;
155 std::vector<JITEventListener *> EventListeners;
156};
157
158} // end namespace orc
159} // end namespace llvm
160
161#endif // LLVM_EXECUTIONENGINE_ORC_RTDYLDOBJECTLINKINGLAYER_H
This file defines the StringMap class.
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:1389
Represents a JIT'd dynamic library.
Definition: Core.h:958
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
Definition: Core.h:527
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