1//===------ MachOPlatform.cpp - Utilities for executing MachO in Orc ------===//
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#include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
10
11#include "llvm/BinaryFormat/MachO.h"
12#include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
13#include "llvm/ExecutionEngine/JITLink/MachO.h"
14#include "llvm/ExecutionEngine/JITLink/aarch64.h"
15#include "llvm/ExecutionEngine/JITLink/x86_64.h"
16#include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h"
17#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
18#include "llvm/ExecutionEngine/Orc/MachOBuilder.h"
19#include "llvm/Support/Debug.h"
20#include <optional>
21
22#define DEBUG_TYPE "orc"
23
24using namespace llvm;
25using namespace llvm::orc;
26using namespace llvm::orc::shared;
27
28namespace llvm {
29namespace orc {
30namespace shared {
31
32using SPSMachOJITDylibDepInfo = SPSTuple<bool, SPSSequence<SPSExecutorAddr>>;
33using SPSMachOJITDylibDepInfoMap =
34 SPSSequence<SPSTuple<SPSExecutorAddr, SPSMachOJITDylibDepInfo>>;
35
36class SPSMachOExecutorSymbolFlags;
37
38template <>
39class SPSSerializationTraits<SPSMachOJITDylibDepInfo,
40 MachOPlatform::MachOJITDylibDepInfo> {
41public:
42 static size_t size(const MachOPlatform::MachOJITDylibDepInfo &DDI) {
43 return SPSMachOJITDylibDepInfo::AsArgList::size(Arg: DDI.Sealed, Args: DDI.DepHeaders);
44 }
45
46 static bool serialize(SPSOutputBuffer &OB,
47 const MachOPlatform::MachOJITDylibDepInfo &DDI) {
48 return SPSMachOJITDylibDepInfo::AsArgList::serialize(OB, Arg: DDI.Sealed,
49 Args: DDI.DepHeaders);
50 }
51
52 static bool deserialize(SPSInputBuffer &IB,
53 MachOPlatform::MachOJITDylibDepInfo &DDI) {
54 return SPSMachOJITDylibDepInfo::AsArgList::deserialize(IB, Arg&: DDI.Sealed,
55 Args&: DDI.DepHeaders);
56 }
57};
58
59template <>
60class SPSSerializationTraits<SPSMachOExecutorSymbolFlags,
61 MachOPlatform::MachOExecutorSymbolFlags> {
62private:
63 using UT = std::underlying_type_t<MachOPlatform::MachOExecutorSymbolFlags>;
64
65public:
66 static size_t size(const MachOPlatform::MachOExecutorSymbolFlags &SF) {
67 return sizeof(UT);
68 }
69
70 static bool serialize(SPSOutputBuffer &OB,
71 const MachOPlatform::MachOExecutorSymbolFlags &SF) {
72 return SPSArgList<UT>::serialize(OB, Arg: static_cast<UT>(SF));
73 }
74
75 static bool deserialize(SPSInputBuffer &IB,
76 MachOPlatform::MachOExecutorSymbolFlags &SF) {
77 UT Tmp;
78 if (!SPSArgList<UT>::deserialize(IB, Arg&: Tmp))
79 return false;
80 SF = static_cast<MachOPlatform::MachOExecutorSymbolFlags>(Tmp);
81 return true;
82 }
83};
84
85} // namespace shared
86} // namespace orc
87} // namespace llvm
88
89namespace {
90
91using SPSRegisterSymbolsArgs =
92 SPSArgList<SPSExecutorAddr,
93 SPSSequence<SPSTuple<SPSExecutorAddr, SPSExecutorAddr,
94 SPSMachOExecutorSymbolFlags>>>;
95
96std::unique_ptr<jitlink::LinkGraph> createPlatformGraph(MachOPlatform &MOP,
97 std::string Name) {
98 auto &ES = MOP.getExecutionSession();
99 return std::make_unique<jitlink::LinkGraph>(
100 args: std::move(Name), args: ES.getSymbolStringPool(), args: ES.getTargetTriple(),
101 args: SubtargetFeatures(), args&: jitlink::getGenericEdgeKindName);
102}
103
104// Creates a Bootstrap-Complete LinkGraph to run deferred actions.
105class MachOPlatformCompleteBootstrapMaterializationUnit
106 : public MaterializationUnit {
107public:
108 using SymbolTableVector =
109 SmallVector<std::tuple<ExecutorAddr, ExecutorAddr,
110 MachOPlatform::MachOExecutorSymbolFlags>>;
111
112 MachOPlatformCompleteBootstrapMaterializationUnit(
113 MachOPlatform &MOP, StringRef PlatformJDName,
114 SymbolStringPtr CompleteBootstrapSymbol, SymbolTableVector SymTab,
115 shared::AllocActions DeferredAAs, ExecutorAddr MachOHeaderAddr,
116 ExecutorAddr PlatformBootstrap, ExecutorAddr PlatformShutdown,
117 ExecutorAddr RegisterJITDylib, ExecutorAddr DeregisterJITDylib,
118 ExecutorAddr RegisterObjectSymbolTable,
119 ExecutorAddr DeregisterObjectSymbolTable)
120 : MaterializationUnit(
121 {{{CompleteBootstrapSymbol, JITSymbolFlags::None}}, nullptr}),
122 MOP(MOP), PlatformJDName(PlatformJDName),
123 CompleteBootstrapSymbol(std::move(CompleteBootstrapSymbol)),
124 SymTab(std::move(SymTab)), DeferredAAs(std::move(DeferredAAs)),
125 MachOHeaderAddr(MachOHeaderAddr), PlatformBootstrap(PlatformBootstrap),
126 PlatformShutdown(PlatformShutdown), RegisterJITDylib(RegisterJITDylib),
127 DeregisterJITDylib(DeregisterJITDylib),
128 RegisterObjectSymbolTable(RegisterObjectSymbolTable),
129 DeregisterObjectSymbolTable(DeregisterObjectSymbolTable) {}
130
131 StringRef getName() const override {
132 return "MachOPlatformCompleteBootstrap";
133 }
134
135 void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
136 using namespace jitlink;
137 auto G = createPlatformGraph(MOP, Name: "<OrcRTCompleteBootstrap>");
138 auto &PlaceholderSection =
139 G->createSection(Name: "__orc_rt_cplt_bs", Prot: MemProt::Read);
140 auto &PlaceholderBlock =
141 G->createZeroFillBlock(Parent&: PlaceholderSection, Size: 1, Address: ExecutorAddr(), Alignment: 1, AlignmentOffset: 0);
142 G->addDefinedSymbol(Content&: PlaceholderBlock, Offset: 0, Name: *CompleteBootstrapSymbol, Size: 1,
143 L: Linkage::Strong, S: Scope::Hidden, IsCallable: false, IsLive: true);
144
145 // Reserve space for the stolen actions, plus two extras.
146 G->allocActions().reserve(n: DeferredAAs.size() + 3);
147
148 // 1. Bootstrap the platform support code.
149 G->allocActions().push_back(
150 x: {.Finalize: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSArgList<>>(FnAddr: PlatformBootstrap)),
151 .Dealloc: cantFail(
152 ValOrErr: WrapperFunctionCall::Create<SPSArgList<>>(FnAddr: PlatformShutdown))});
153
154 // 2. Register the platform JITDylib.
155 G->allocActions().push_back(
156 x: {.Finalize: cantFail(ValOrErr: WrapperFunctionCall::Create<
157 SPSArgList<SPSString, SPSExecutorAddr>>(
158 FnAddr: RegisterJITDylib, Args: PlatformJDName, Args: MachOHeaderAddr)),
159 .Dealloc: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
160 FnAddr: DeregisterJITDylib, Args: MachOHeaderAddr))});
161
162 // 3. Register deferred symbols.
163 G->allocActions().push_back(
164 x: {.Finalize: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
165 FnAddr: RegisterObjectSymbolTable, Args: MachOHeaderAddr, Args: SymTab)),
166 .Dealloc: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
167 FnAddr: DeregisterObjectSymbolTable, Args: MachOHeaderAddr, Args: SymTab))});
168
169 // 4. Add the deferred actions to the graph.
170 std::move(first: DeferredAAs.begin(), last: DeferredAAs.end(),
171 result: std::back_inserter(x&: G->allocActions()));
172
173 MOP.getObjectLinkingLayer().emit(R: std::move(R), G: std::move(G));
174 }
175
176 void discard(const JITDylib &JD, const SymbolStringPtr &Sym) override {}
177
178private:
179 MachOPlatform &MOP;
180 StringRef PlatformJDName;
181 SymbolStringPtr CompleteBootstrapSymbol;
182 SymbolTableVector SymTab;
183 shared::AllocActions DeferredAAs;
184 ExecutorAddr MachOHeaderAddr;
185 ExecutorAddr PlatformBootstrap;
186 ExecutorAddr PlatformShutdown;
187 ExecutorAddr RegisterJITDylib;
188 ExecutorAddr DeregisterJITDylib;
189 ExecutorAddr RegisterObjectSymbolTable;
190 ExecutorAddr DeregisterObjectSymbolTable;
191};
192
193static StringRef ObjCRuntimeObjectSectionsData[] = {
194 MachOObjCCatListSectionName, MachOObjCCatList2SectionName,
195 MachOObjCClassListSectionName, MachOObjCClassRefsSectionName,
196 MachOObjCConstSectionName, MachOObjCDataSectionName,
197 MachOObjCProtoListSectionName, MachOObjCProtoRefsSectionName,
198 MachOObjCNLCatListSectionName, MachOObjCNLClassListSectionName,
199 MachOObjCSelRefsSectionName};
200
201static StringRef ObjCRuntimeObjectSectionsText[] = {
202 MachOObjCClassNameSectionName, MachOObjCMethNameSectionName,
203 MachOObjCMethTypeSectionName, MachOSwift5TypesSectionName,
204 MachOSwift5TypeRefSectionName, MachOSwift5FieldMetadataSectionName,
205 MachOSwift5EntrySectionName, MachOSwift5ProtoSectionName,
206 MachOSwift5ProtosSectionName};
207
208static StringRef ObjCRuntimeObjectSectionName =
209 "__llvm_jitlink_ObjCRuntimeRegistrationObject";
210
211static StringRef ObjCImageInfoSymbolName =
212 "__llvm_jitlink_macho_objc_imageinfo";
213
214struct ObjCImageInfoFlags {
215 uint16_t SwiftABIVersion;
216 uint16_t SwiftVersion;
217 bool HasCategoryClassProperties;
218 bool HasSignedObjCClassROs;
219
220 static constexpr uint32_t SIGNED_CLASS_RO = (1 << 4);
221 static constexpr uint32_t HAS_CATEGORY_CLASS_PROPERTIES = (1 << 6);
222
223 explicit ObjCImageInfoFlags(uint32_t RawFlags) {
224 HasSignedObjCClassROs = RawFlags & SIGNED_CLASS_RO;
225 HasCategoryClassProperties = RawFlags & HAS_CATEGORY_CLASS_PROPERTIES;
226 SwiftABIVersion = (RawFlags >> 8) & 0xFF;
227 SwiftVersion = (RawFlags >> 16) & 0xFFFF;
228 }
229
230 uint32_t rawFlags() const {
231 uint32_t Result = 0;
232 if (HasCategoryClassProperties)
233 Result |= HAS_CATEGORY_CLASS_PROPERTIES;
234 if (HasSignedObjCClassROs)
235 Result |= SIGNED_CLASS_RO;
236 Result |= (SwiftABIVersion << 8);
237 Result |= (SwiftVersion << 16);
238 return Result;
239 }
240};
241} // end anonymous namespace
242
243namespace llvm {
244namespace orc {
245
246std::optional<MachOPlatform::HeaderOptions::BuildVersionOpts>
247MachOPlatform::HeaderOptions::BuildVersionOpts::fromTriple(const Triple &TT,
248 uint32_t MinOS,
249 uint32_t SDK) {
250
251 uint32_t Platform;
252 switch (TT.getOS()) {
253 case Triple::IOS:
254 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_IOSSIMULATOR
255 : MachO::PLATFORM_IOS;
256 break;
257 case Triple::MacOSX:
258 Platform = MachO::PLATFORM_MACOS;
259 break;
260 case Triple::TvOS:
261 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_TVOSSIMULATOR
262 : MachO::PLATFORM_TVOS;
263 break;
264 case Triple::WatchOS:
265 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_WATCHOSSIMULATOR
266 : MachO::PLATFORM_WATCHOS;
267 break;
268 case Triple::XROS:
269 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_XROS_SIMULATOR
270 : MachO::PLATFORM_XROS;
271 break;
272 default:
273 return std::nullopt;
274 }
275
276 return MachOPlatform::HeaderOptions::BuildVersionOpts{.Platform: Platform, .MinOS: MinOS, .SDK: SDK};
277}
278
279Expected<std::unique_ptr<MachOPlatform>>
280MachOPlatform::Create(ObjectLinkingLayer &ObjLinkingLayer, JITDylib &PlatformJD,
281 std::unique_ptr<DefinitionGenerator> OrcRuntime,
282 HeaderOptionsBuilder BuildHeaderOpts,
283 HeaderOptions PlatformJDOpts,
284 MachOHeaderMUBuilder BuildMachOHeaderMU,
285 std::optional<SymbolAliasMap> RuntimeAliases) {
286
287 auto &ES = ObjLinkingLayer.getExecutionSession();
288
289 // If the target is not supported then bail out immediately.
290 if (!supportedTarget(TT: ES.getTargetTriple()))
291 return make_error<StringError>(Args: "Unsupported MachOPlatform triple: " +
292 ES.getTargetTriple().str(),
293 Args: inconvertibleErrorCode());
294
295 auto &EPC = ES.getExecutorProcessControl();
296
297 // Create default aliases if the caller didn't supply any.
298 if (!RuntimeAliases)
299 RuntimeAliases = standardPlatformAliases(ES);
300
301 // Define the aliases.
302 if (auto Err = PlatformJD.define(MU: symbolAliases(Aliases: std::move(*RuntimeAliases))))
303 return std::move(Err);
304
305 // Add JIT-dispatch function support symbols.
306 if (auto Err = PlatformJD.define(
307 MU: absoluteSymbols(Symbols: {{ES.intern(SymName: "___orc_rt_jit_dispatch"),
308 {EPC.getJITDispatchInfo().JITDispatchFunction,
309 JITSymbolFlags::Exported}},
310 {ES.intern(SymName: "___orc_rt_jit_dispatch_ctx"),
311 {EPC.getJITDispatchInfo().JITDispatchContext,
312 JITSymbolFlags::Exported}}})))
313 return std::move(Err);
314
315 // Create the instance.
316 Error Err = Error::success();
317 auto P = std::unique_ptr<MachOPlatform>(
318 new MachOPlatform(ObjLinkingLayer, PlatformJD, std::move(OrcRuntime),
319 std::move(BuildHeaderOpts), std::move(PlatformJDOpts),
320 std::move(BuildMachOHeaderMU), Err));
321 if (Err)
322 return std::move(Err);
323 return std::move(P);
324}
325
326Expected<std::unique_ptr<MachOPlatform>> MachOPlatform::Create(
327 ObjectLinkingLayer &ObjLinkingLayer, JITDylib &PlatformJD,
328 const char *OrcRuntimePath, HeaderOptionsBuilder BuildHeaderOpts,
329 HeaderOptions PlatformJDOpts, MachOHeaderMUBuilder BuildMachOHeaderMU,
330 std::optional<SymbolAliasMap> RuntimeAliases) {
331
332 // Create a generator for the ORC runtime archive.
333 auto OrcRuntimeArchiveGenerator =
334 StaticLibraryDefinitionGenerator::Load(L&: ObjLinkingLayer, FileName: OrcRuntimePath);
335 if (!OrcRuntimeArchiveGenerator)
336 return OrcRuntimeArchiveGenerator.takeError();
337
338 return Create(ObjLinkingLayer, PlatformJD,
339 OrcRuntime: std::move(*OrcRuntimeArchiveGenerator),
340 BuildHeaderOpts: std::move(BuildHeaderOpts), PlatformJDOpts: std::move(PlatformJDOpts),
341 BuildMachOHeaderMU: std::move(BuildMachOHeaderMU), RuntimeAliases: std::move(RuntimeAliases));
342}
343
344Error MachOPlatform::setupJITDylib(JITDylib &JD) {
345 return setupJITDylib(JD, Opts: BuildHeaderOpts(JD));
346}
347
348Error MachOPlatform::setupJITDylib(JITDylib &JD, HeaderOptions Opts) {
349 if (auto Err = JD.define(MU: BuildMachOHeaderMU(*this, std::move(Opts))))
350 return Err;
351
352 return ES.lookup(SearchOrder: {&JD}, Symbol: MachOHeaderStartSymbol).takeError();
353}
354
355Error MachOPlatform::teardownJITDylib(JITDylib &JD) {
356 std::lock_guard<std::mutex> Lock(PlatformMutex);
357 auto I = JITDylibToHeaderAddr.find(Val: &JD);
358 if (I != JITDylibToHeaderAddr.end()) {
359 assert(HeaderAddrToJITDylib.count(I->second) &&
360 "HeaderAddrToJITDylib missing entry");
361 HeaderAddrToJITDylib.erase(Val: I->second);
362 JITDylibToHeaderAddr.erase(I);
363 }
364 JITDylibToPThreadKey.erase(Val: &JD);
365 return Error::success();
366}
367
368Error MachOPlatform::notifyAdding(ResourceTracker &RT,
369 const MaterializationUnit &MU) {
370 auto &JD = RT.getJITDylib();
371 const auto &InitSym = MU.getInitializerSymbol();
372 if (!InitSym)
373 return Error::success();
374
375 RegisteredInitSymbols[&JD].add(Name: InitSym,
376 Flags: SymbolLookupFlags::WeaklyReferencedSymbol);
377 LLVM_DEBUG({
378 dbgs() << "MachOPlatform: Registered init symbol " << *InitSym << " for MU "
379 << MU.getName() << "\n";
380 });
381 return Error::success();
382}
383
384Error MachOPlatform::notifyRemoving(ResourceTracker &RT) {
385 llvm_unreachable("Not supported yet");
386}
387
388static void addAliases(ExecutionSession &ES, SymbolAliasMap &Aliases,
389 ArrayRef<std::pair<const char *, const char *>> AL) {
390 for (auto &KV : AL) {
391 auto AliasName = ES.intern(SymName: KV.first);
392 assert(!Aliases.count(AliasName) && "Duplicate symbol name in alias map");
393 Aliases[std::move(AliasName)] = {ES.intern(SymName: KV.second),
394 JITSymbolFlags::Exported};
395 }
396}
397
398SymbolAliasMap MachOPlatform::standardPlatformAliases(ExecutionSession &ES) {
399 SymbolAliasMap Aliases;
400 addAliases(ES, Aliases, AL: requiredCXXAliases());
401 addAliases(ES, Aliases, AL: standardRuntimeUtilityAliases());
402 addAliases(ES, Aliases, AL: standardLazyCompilationAliases());
403 return Aliases;
404}
405
406ArrayRef<std::pair<const char *, const char *>>
407MachOPlatform::requiredCXXAliases() {
408 static const std::pair<const char *, const char *> RequiredCXXAliases[] = {
409 {"___cxa_atexit", "___orc_rt_macho_cxa_atexit"}};
410
411 return ArrayRef<std::pair<const char *, const char *>>(RequiredCXXAliases);
412}
413
414ArrayRef<std::pair<const char *, const char *>>
415MachOPlatform::standardRuntimeUtilityAliases() {
416 static const std::pair<const char *, const char *>
417 StandardRuntimeUtilityAliases[] = {
418 {"___orc_rt_run_program", "___orc_rt_macho_run_program"},
419 {"___orc_rt_jit_dlerror", "___orc_rt_macho_jit_dlerror"},
420 {"___orc_rt_jit_dlopen", "___orc_rt_macho_jit_dlopen"},
421 {"___orc_rt_jit_dlupdate", "___orc_rt_macho_jit_dlupdate"},
422 {"___orc_rt_jit_dlclose", "___orc_rt_macho_jit_dlclose"},
423 {"___orc_rt_jit_dlsym", "___orc_rt_macho_jit_dlsym"},
424 {"___orc_rt_log_error", "___orc_rt_log_error_to_stderr"}};
425
426 return ArrayRef<std::pair<const char *, const char *>>(
427 StandardRuntimeUtilityAliases);
428}
429
430ArrayRef<std::pair<const char *, const char *>>
431MachOPlatform::standardLazyCompilationAliases() {
432 static const std::pair<const char *, const char *>
433 StandardLazyCompilationAliases[] = {
434 {"__orc_rt_reenter", "__orc_rt_sysv_reenter"},
435 {"__orc_rt_resolve_tag", "___orc_rt_resolve_tag"}};
436
437 return ArrayRef<std::pair<const char *, const char *>>(
438 StandardLazyCompilationAliases);
439}
440
441MachOPlatform::HeaderOptions MachOPlatform::defaultHeaderOpts(JITDylib &JD) {
442 return {};
443}
444
445bool MachOPlatform::supportedTarget(const Triple &TT) {
446 switch (TT.getArch()) {
447 case Triple::aarch64:
448 case Triple::x86_64:
449 return true;
450 default:
451 return false;
452 }
453}
454
455jitlink::Edge::Kind MachOPlatform::getPointerEdgeKind(jitlink::LinkGraph &G) {
456 switch (G.getTargetTriple().getArch()) {
457 case Triple::aarch64:
458 return jitlink::aarch64::Pointer64;
459 case Triple::x86_64:
460 return jitlink::x86_64::Pointer64;
461 default:
462 llvm_unreachable("Unsupported architecture");
463 }
464}
465
466MachOPlatform::MachOExecutorSymbolFlags
467MachOPlatform::flagsForSymbol(jitlink::Symbol &Sym) {
468 MachOPlatform::MachOExecutorSymbolFlags Flags{};
469 if (Sym.getLinkage() == jitlink::Linkage::Weak)
470 Flags |= MachOExecutorSymbolFlags::Weak;
471
472 if (Sym.isCallable())
473 Flags |= MachOExecutorSymbolFlags::Callable;
474
475 return Flags;
476}
477
478MachOPlatform::MachOPlatform(
479 ObjectLinkingLayer &ObjLinkingLayer, JITDylib &PlatformJD,
480 std::unique_ptr<DefinitionGenerator> OrcRuntimeGenerator,
481 HeaderOptionsBuilder BuildHeaderOpts, HeaderOptions PlatformJDOpts,
482 MachOHeaderMUBuilder BuildMachOHeaderMU, Error &Err)
483 : ES(ObjLinkingLayer.getExecutionSession()), PlatformJD(PlatformJD),
484 ObjLinkingLayer(ObjLinkingLayer),
485 BuildHeaderOpts(std::move(BuildHeaderOpts)),
486 BuildMachOHeaderMU(std::move(BuildMachOHeaderMU)) {
487 ErrorAsOutParameter _(Err);
488 ObjLinkingLayer.addPlugin(P: std::make_unique<MachOPlatformPlugin>(args&: *this));
489 PlatformJD.addGenerator(DefGenerator: std::move(OrcRuntimeGenerator));
490
491 {
492 // Check for force-eh-frame
493 std::optional<bool> ForceEHFrames;
494 if ((Err = ES.getBootstrapMapValue<bool, bool>(Key: "darwin-use-ehframes-only",
495 Val&: ForceEHFrames)))
496 return;
497 this->ForceEHFrames = ForceEHFrames.value_or(u: false);
498 }
499
500 BootstrapInfo BI;
501 Bootstrap = &BI;
502
503 // Bootstrap process -- here be phase-ordering dragons.
504 //
505 // The MachOPlatform class uses allocation actions to register metadata
506 // sections with the ORC runtime, however the runtime contains metadata
507 // registration functions that have their own metadata that they need to
508 // register (e.g. the frame-info registration functions have frame-info).
509 // We can't use an ordinary lookup to find these registration functions
510 // because their address is needed during the link of the containing graph
511 // itself (to build the allocation actions that will call the registration
512 // functions). Further complicating the situation (a) the graph containing
513 // the registration functions is allowed to depend on other graphs (e.g. the
514 // graph containing the ORC runtime RTTI support) so we need to handle an
515 // unknown set of dependencies during bootstrap, and (b) these graphs may
516 // be linked concurrently if the user has installed a concurrent dispatcher.
517 //
518 // We satisfy these constraints by implementing a bootstrap phase during which
519 // allocation actions generated by MachOPlatform are appended to a list of
520 // deferred allocation actions, rather than to the graphs themselves. At the
521 // end of the bootstrap process the deferred actions are attached to a final
522 // "complete-bootstrap" graph that causes them to be run.
523 //
524 // The bootstrap steps are as follows:
525 //
526 // 1. Request the graph containing the mach header. This graph is guaranteed
527 // not to have any metadata so the fact that the registration functions
528 // are not available yet is not a problem.
529 //
530 // 2. Look up the registration functions and discard the results. This will
531 // trigger linking of the graph containing these functions, and
532 // consequently any graphs that it depends on. We do not use the lookup
533 // result to find the addresses of the functions requested (as described
534 // above the lookup will return too late for that), instead we capture the
535 // addresses in a post-allocation pass injected by the platform runtime
536 // during bootstrap only.
537 //
538 // 3. During bootstrap the MachOPlatformPlugin keeps a count of the number of
539 // graphs being linked (potentially concurrently), and we block until all
540 // of these graphs have completed linking. This is to avoid a race on the
541 // deferred-actions vector: the lookup for the runtime registration
542 // functions may return while some functions (those that are being
543 // incidentally linked in, but aren't reachable via the runtime functions)
544 // are still being linked, and we need to capture any allocation actions
545 // for this incidental code before we proceed.
546 //
547 // 4. Once all active links are complete we transfer the deferred actions to
548 // a newly added CompleteBootstrap graph and then request a symbol from
549 // the CompleteBootstrap graph to trigger materialization. This will cause
550 // all deferred actions to be run, and once this lookup returns we can
551 // proceed.
552 //
553 // 5. Finally, we associate runtime support methods in MachOPlatform with
554 // the corresponding jit-dispatch tag variables in the ORC runtime to make
555 // the support methods callable. The bootstrap is now complete.
556
557 // Step (1) Add header materialization unit and request.
558 if ((Err = PlatformJD.define(
559 MU: this->BuildMachOHeaderMU(*this, std::move(PlatformJDOpts)))))
560 return;
561 if ((Err = ES.lookup(SearchOrder: &PlatformJD, Symbol: MachOHeaderStartSymbol).takeError()))
562 return;
563
564 // Step (2) Request runtime registration functions to trigger
565 // materialization..
566 if ((Err = ES.lookup(SearchOrder: makeJITDylibSearchOrder(JDs: &PlatformJD),
567 Symbols: SymbolLookupSet(
568 {PlatformBootstrap.Name, PlatformShutdown.Name,
569 RegisterJITDylib.Name, DeregisterJITDylib.Name,
570 RegisterObjectSymbolTable.Name,
571 DeregisterObjectSymbolTable.Name,
572 RegisterObjectPlatformSections.Name,
573 DeregisterObjectPlatformSections.Name,
574 CreatePThreadKey.Name}))
575 .takeError()))
576 return;
577
578 // Step (3) Wait for any incidental linker work to complete.
579 {
580 std::unique_lock<std::mutex> Lock(PlatformMutex);
581 BI.CV.wait(lock&: Lock, p: [&]() { return BI.ActiveGraphs == 0; });
582 Bootstrap = nullptr;
583 }
584
585 // Step (4) Add complete-bootstrap materialization unit and request.
586 auto BootstrapCompleteSymbol = ES.intern(SymName: "__orc_rt_macho_complete_bootstrap");
587 if ((Err = PlatformJD.define(
588 MU: std::make_unique<MachOPlatformCompleteBootstrapMaterializationUnit>(
589 args&: *this, args: PlatformJD.getName(), args&: BootstrapCompleteSymbol,
590 args: std::move(BI.SymTab), args: std::move(BI.DeferredAAs),
591 args&: BI.MachOHeaderAddr, args&: PlatformBootstrap.Addr,
592 args&: PlatformShutdown.Addr, args&: RegisterJITDylib.Addr,
593 args&: DeregisterJITDylib.Addr, args&: RegisterObjectSymbolTable.Addr,
594 args&: DeregisterObjectSymbolTable.Addr))))
595 return;
596 if ((Err = ES.lookup(SearchOrder: makeJITDylibSearchOrder(
597 JDs: &PlatformJD, Flags: JITDylibLookupFlags::MatchAllSymbols),
598 Symbol: std::move(BootstrapCompleteSymbol))
599 .takeError()))
600 return;
601
602 // (5) Associate runtime support functions.
603 // TODO: Consider moving this above (4) to make runtime support functions
604 // available to the bootstrap completion graph. We'd just need to be
605 // sure that the runtime support functions are fully usable before any
606 // bootstrap completion actions use them (e.g. the ORC runtime
607 // macho_platform object would have to have been created and
608 // initialized).
609 if ((Err = associateRuntimeSupportFunctions()))
610 return;
611}
612
613Error MachOPlatform::associateRuntimeSupportFunctions() {
614 ExecutionSession::JITDispatchHandlerAssociationMap WFs;
615
616 using PushInitializersSPSSig =
617 SPSExpected<SPSMachOJITDylibDepInfoMap>(SPSExecutorAddr);
618 WFs[ES.intern(SymName: "___orc_rt_macho_push_initializers_tag")] =
619 ES.wrapAsyncWithSPS<PushInitializersSPSSig>(
620 Instance: this, Method: &MachOPlatform::rt_pushInitializers);
621
622 using PushSymbolsSPSSig =
623 SPSError(SPSExecutorAddr, SPSSequence<SPSTuple<SPSString, bool>>);
624 WFs[ES.intern(SymName: "___orc_rt_macho_push_symbols_tag")] =
625 ES.wrapAsyncWithSPS<PushSymbolsSPSSig>(Instance: this,
626 Method: &MachOPlatform::rt_pushSymbols);
627
628 return ES.registerJITDispatchHandlers(JD&: PlatformJD, WFs: std::move(WFs));
629}
630
631void MachOPlatform::pushInitializersLoop(
632 PushInitializersSendResultFn SendResult, JITDylibSP JD) {
633 DenseMap<JITDylib *, SymbolLookupSet> NewInitSymbols;
634 DenseMap<JITDylib *, SmallVector<JITDylib *>> JDDepMap;
635 SmallVector<JITDylib *, 16> Worklist({JD.get()});
636
637 ES.runSessionLocked(F: [&]() {
638 while (!Worklist.empty()) {
639 // FIXME: Check for defunct dylibs.
640
641 auto DepJD = Worklist.back();
642 Worklist.pop_back();
643
644 // If we've already visited this JITDylib on this iteration then continue.
645 auto [It, Inserted] = JDDepMap.try_emplace(Key: DepJD);
646 if (!Inserted)
647 continue;
648
649 // Add dep info.
650 auto &DM = It->second;
651 DepJD->withLinkOrderDo(F: [&](const JITDylibSearchOrder &O) {
652 for (auto &KV : O) {
653 if (KV.first == DepJD)
654 continue;
655 DM.push_back(Elt: KV.first);
656 Worklist.push_back(Elt: KV.first);
657 }
658 });
659
660 // Add any registered init symbols.
661 auto RISItr = RegisteredInitSymbols.find(Val: DepJD);
662 if (RISItr != RegisteredInitSymbols.end()) {
663 NewInitSymbols[DepJD] = std::move(RISItr->second);
664 RegisteredInitSymbols.erase(I: RISItr);
665 }
666 }
667 });
668
669 // If there are no further init symbols to look up then send the link order
670 // (as a list of header addresses) to the caller.
671 if (NewInitSymbols.empty()) {
672
673 // To make the list intelligible to the runtime we need to convert all
674 // JITDylib pointers to their header addresses. Only include JITDylibs
675 // that appear in the JITDylibToHeaderAddr map (i.e. those that have been
676 // through setupJITDylib) -- bare JITDylibs aren't managed by the platform.
677 DenseMap<JITDylib *, ExecutorAddr> HeaderAddrs;
678 HeaderAddrs.reserve(NumEntries: JDDepMap.size());
679 {
680 std::lock_guard<std::mutex> Lock(PlatformMutex);
681 for (auto &KV : JDDepMap) {
682 auto I = JITDylibToHeaderAddr.find(Val: KV.first);
683 if (I != JITDylibToHeaderAddr.end())
684 HeaderAddrs[KV.first] = I->second;
685 }
686 }
687
688 // Build the dep info map to return.
689 MachOJITDylibDepInfoMap DIM;
690 DIM.reserve(n: JDDepMap.size());
691 for (auto &KV : JDDepMap) {
692 auto HI = HeaderAddrs.find(Val: KV.first);
693 // Skip unmanaged JITDylibs.
694 if (HI == HeaderAddrs.end())
695 continue;
696 auto H = HI->second;
697 MachOJITDylibDepInfo DepInfo;
698 for (auto &Dep : KV.second) {
699 auto HJ = HeaderAddrs.find(Val: Dep);
700 if (HJ != HeaderAddrs.end())
701 DepInfo.DepHeaders.push_back(x: HJ->second);
702 }
703 DIM.push_back(x: std::make_pair(x&: H, y: std::move(DepInfo)));
704 }
705 SendResult(DIM);
706 return;
707 }
708
709 // Otherwise issue a lookup and re-run this phase when it completes.
710 lookupInitSymbolsAsync(
711 OnComplete: [this, SendResult = std::move(SendResult), JD](Error Err) mutable {
712 if (Err)
713 SendResult(std::move(Err));
714 else
715 pushInitializersLoop(SendResult: std::move(SendResult), JD);
716 },
717 ES, InitSyms: std::move(NewInitSymbols));
718}
719
720void MachOPlatform::rt_pushInitializers(PushInitializersSendResultFn SendResult,
721 ExecutorAddr JDHeaderAddr) {
722 JITDylibSP JD;
723 {
724 std::lock_guard<std::mutex> Lock(PlatformMutex);
725 auto I = HeaderAddrToJITDylib.find(Val: JDHeaderAddr);
726 if (I != HeaderAddrToJITDylib.end())
727 JD = I->second;
728 }
729
730 LLVM_DEBUG({
731 dbgs() << "MachOPlatform::rt_pushInitializers(" << JDHeaderAddr << ") ";
732 if (JD)
733 dbgs() << "pushing initializers for " << JD->getName() << "\n";
734 else
735 dbgs() << "No JITDylib for header address.\n";
736 });
737
738 if (!JD) {
739 SendResult(make_error<StringError>(Args: "No JITDylib with header addr " +
740 formatv(Fmt: "{0:x}", Vals&: JDHeaderAddr),
741 Args: inconvertibleErrorCode()));
742 return;
743 }
744
745 pushInitializersLoop(SendResult: std::move(SendResult), JD);
746}
747
748void MachOPlatform::rt_pushSymbols(
749 PushSymbolsInSendResultFn SendResult, ExecutorAddr Handle,
750 const std::vector<std::pair<StringRef, bool>> &SymbolNames) {
751
752 JITDylib *JD = nullptr;
753
754 {
755 std::lock_guard<std::mutex> Lock(PlatformMutex);
756 auto I = HeaderAddrToJITDylib.find(Val: Handle);
757 if (I != HeaderAddrToJITDylib.end())
758 JD = I->second;
759 }
760 LLVM_DEBUG({
761 dbgs() << "MachOPlatform::rt_pushSymbols(";
762 if (JD)
763 dbgs() << "\"" << JD->getName() << "\", [ ";
764 else
765 dbgs() << "<invalid handle " << Handle << ">, [ ";
766 for (auto &Name : SymbolNames)
767 dbgs() << "\"" << Name.first << "\" ";
768 dbgs() << "])\n";
769 });
770
771 if (!JD) {
772 SendResult(make_error<StringError>(Args: "No JITDylib associated with handle " +
773 formatv(Fmt: "{0:x}", Vals&: Handle),
774 Args: inconvertibleErrorCode()));
775 return;
776 }
777
778 SymbolLookupSet LS;
779 for (auto &[Name, Required] : SymbolNames)
780 LS.add(Name: ES.intern(SymName: Name), Flags: Required
781 ? SymbolLookupFlags::RequiredSymbol
782 : SymbolLookupFlags::WeaklyReferencedSymbol);
783
784 ES.lookup(
785 K: LookupKind::DLSym, SearchOrder: {{JD, JITDylibLookupFlags::MatchExportedSymbolsOnly}},
786 Symbols: std::move(LS), RequiredState: SymbolState::Ready,
787 NotifyComplete: [SendResult = std::move(SendResult)](Expected<SymbolMap> Result) mutable {
788 SendResult(Result.takeError());
789 },
790 RegisterDependencies: NoDependenciesToRegister);
791}
792
793Expected<uint64_t> MachOPlatform::createPThreadKey() {
794 if (!CreatePThreadKey.Addr)
795 return make_error<StringError>(
796 Args: "Attempting to create pthread key in target, but runtime support has "
797 "not been loaded yet",
798 Args: inconvertibleErrorCode());
799
800 Expected<uint64_t> Result(0);
801 if (auto Err = ES.callSPSWrapper<SPSExpected<uint64_t>(void)>(
802 WrapperFnAddr: CreatePThreadKey.Addr, WrapperCallArgs&: Result))
803 return std::move(Err);
804 return Result;
805}
806
807void MachOPlatform::MachOPlatformPlugin::modifyPassConfig(
808 MaterializationResponsibility &MR, jitlink::LinkGraph &LG,
809 jitlink::PassConfiguration &Config) {
810
811 using namespace jitlink;
812
813 bool InBootstrapPhase = false;
814
815 ExecutorAddr HeaderAddr;
816 {
817 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
818 if (LLVM_UNLIKELY(&MR.getTargetJITDylib() == &MP.PlatformJD)) {
819 if (MP.Bootstrap) {
820 InBootstrapPhase = true;
821 ++MP.Bootstrap->ActiveGraphs;
822 }
823 }
824
825 // Get the dso-base address if available.
826 auto I = MP.JITDylibToHeaderAddr.find(Val: &MR.getTargetJITDylib());
827 if (I != MP.JITDylibToHeaderAddr.end())
828 HeaderAddr = I->second;
829 }
830
831 // If we're forcing eh-frame use then discard the compact-unwind section
832 // immediately to prevent FDEs from being stripped.
833 if (MP.ForceEHFrames)
834 if (auto *CUSec = LG.findSectionByName(Name: MachOCompactUnwindSectionName))
835 LG.removeSection(Sec&: *CUSec);
836
837 // Point the libunwind dso-base absolute symbol at the header for the
838 // JITDylib. This will prevent us from synthesizing a new header for
839 // every object.
840 if (HeaderAddr)
841 LG.addAbsoluteSymbol(Name: "__jitlink$libunwind_dso_base", Address: HeaderAddr, Size: 0,
842 L: Linkage::Strong, S: Scope::Local, IsLive: true);
843
844 // If we're in the bootstrap phase then increment the active graphs.
845 if (LLVM_UNLIKELY(InBootstrapPhase))
846 Config.PostAllocationPasses.push_back(x: [this](LinkGraph &G) {
847 return bootstrapPipelineRecordRuntimeFunctions(G);
848 });
849
850 // --- Handle Initializers ---
851 if (auto InitSymbol = MR.getInitializerSymbol()) {
852
853 // If the initializer symbol is the MachOHeader start symbol then just
854 // register it and then bail out -- the header materialization unit
855 // definitely doesn't need any other passes.
856 if (InitSymbol == MP.MachOHeaderStartSymbol && !InBootstrapPhase) {
857 Config.PostAllocationPasses.push_back(x: [this, &MR](LinkGraph &G) {
858 return associateJITDylibHeaderSymbol(G, MR);
859 });
860 return;
861 }
862
863 // If the object contains an init symbol other than the header start symbol
864 // then add passes to preserve, process and register the init
865 // sections/symbols.
866 Config.PrePrunePasses.push_back(x: [this, &MR](LinkGraph &G) {
867 if (auto Err = preserveImportantSections(G, MR))
868 return Err;
869 return processObjCImageInfo(G, MR);
870 });
871 Config.PostPrunePasses.push_back(
872 x: [this](LinkGraph &G) { return createObjCRuntimeObject(G); });
873 Config.PostAllocationPasses.push_back(
874 x: [this, &MR](LinkGraph &G) { return populateObjCRuntimeObject(G, MR); });
875 }
876
877 // Insert TLV lowering at the start of the PostPrunePasses, since we want
878 // it to run before GOT/PLT lowering.
879 Config.PostPrunePasses.insert(
880 position: Config.PostPrunePasses.begin(),
881 x: [this, &JD = MR.getTargetJITDylib()](LinkGraph &G) {
882 return fixTLVSectionsAndEdges(G, JD);
883 });
884
885 // Add symbol table prepare and register passes: These will add strings for
886 // all symbols to the c-strings section, and build a symbol table registration
887 // call.
888 auto JITSymTabInfo = std::make_shared<JITSymTabVector>();
889 Config.PostPrunePasses.push_back(x: [this, JITSymTabInfo](LinkGraph &G) {
890 return prepareSymbolTableRegistration(G, JITSymTabInfo&: *JITSymTabInfo);
891 });
892 Config.PostFixupPasses.push_back(x: [this, &MR, JITSymTabInfo,
893 InBootstrapPhase](LinkGraph &G) {
894 return addSymbolTableRegistration(G, MR, JITSymTabInfo&: *JITSymTabInfo, InBootstrapPhase);
895 });
896
897 // Add a pass to register the final addresses of any special sections in the
898 // object with the runtime.
899 Config.PostAllocationPasses.push_back(x: [this, &JD = MR.getTargetJITDylib(),
900 HeaderAddr,
901 InBootstrapPhase](LinkGraph &G) {
902 return registerObjectPlatformSections(G, JD, HeaderAddr, InBootstrapPhase);
903 });
904
905 // If we're in the bootstrap phase then steal allocation actions and then
906 // decrement the active graphs.
907 if (InBootstrapPhase)
908 Config.PostFixupPasses.push_back(
909 x: [this](LinkGraph &G) { return bootstrapPipelineEnd(G); });
910}
911
912Error MachOPlatform::MachOPlatformPlugin::
913 bootstrapPipelineRecordRuntimeFunctions(jitlink::LinkGraph &G) {
914 // Record bootstrap function names.
915 std::pair<StringRef, ExecutorAddr *> RuntimeSymbols[] = {
916 {*MP.MachOHeaderStartSymbol, &MP.Bootstrap->MachOHeaderAddr},
917 {*MP.PlatformBootstrap.Name, &MP.PlatformBootstrap.Addr},
918 {*MP.PlatformShutdown.Name, &MP.PlatformShutdown.Addr},
919 {*MP.RegisterJITDylib.Name, &MP.RegisterJITDylib.Addr},
920 {*MP.DeregisterJITDylib.Name, &MP.DeregisterJITDylib.Addr},
921 {*MP.RegisterObjectSymbolTable.Name, &MP.RegisterObjectSymbolTable.Addr},
922 {*MP.DeregisterObjectSymbolTable.Name,
923 &MP.DeregisterObjectSymbolTable.Addr},
924 {*MP.RegisterObjectPlatformSections.Name,
925 &MP.RegisterObjectPlatformSections.Addr},
926 {*MP.DeregisterObjectPlatformSections.Name,
927 &MP.DeregisterObjectPlatformSections.Addr},
928 {*MP.CreatePThreadKey.Name, &MP.CreatePThreadKey.Addr},
929 {*MP.RegisterObjCRuntimeObject.Name, &MP.RegisterObjCRuntimeObject.Addr},
930 {*MP.DeregisterObjCRuntimeObject.Name,
931 &MP.DeregisterObjCRuntimeObject.Addr}};
932
933 bool RegisterMachOHeader = false;
934
935 for (auto *Sym : G.defined_symbols()) {
936 for (auto &RTSym : RuntimeSymbols) {
937 if (Sym->hasName() && *Sym->getName() == RTSym.first) {
938 if (*RTSym.second)
939 return make_error<StringError>(
940 Args: "Duplicate " + RTSym.first +
941 " detected during MachOPlatform bootstrap",
942 Args: inconvertibleErrorCode());
943
944 if (Sym->getName() == MP.MachOHeaderStartSymbol)
945 RegisterMachOHeader = true;
946
947 *RTSym.second = Sym->getAddress();
948 }
949 }
950 }
951
952 if (RegisterMachOHeader) {
953 // If this graph defines the macho header symbol then create the internal
954 // mapping between it and PlatformJD.
955 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
956 MP.JITDylibToHeaderAddr[&MP.PlatformJD] = MP.Bootstrap->MachOHeaderAddr;
957 MP.HeaderAddrToJITDylib[MP.Bootstrap->MachOHeaderAddr] = &MP.PlatformJD;
958 }
959
960 return Error::success();
961}
962
963Error MachOPlatform::MachOPlatformPlugin::bootstrapPipelineEnd(
964 jitlink::LinkGraph &G) {
965 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
966
967 --MP.Bootstrap->ActiveGraphs;
968 // Notify Bootstrap->CV while holding the mutex because the mutex is
969 // also keeping Bootstrap->CV alive.
970 if (MP.Bootstrap->ActiveGraphs == 0)
971 MP.Bootstrap->CV.notify_all();
972 return Error::success();
973}
974
975Error MachOPlatform::MachOPlatformPlugin::associateJITDylibHeaderSymbol(
976 jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
977 auto I = llvm::find_if(Range: G.defined_symbols(), P: [this](jitlink::Symbol *Sym) {
978 return Sym->getName() == MP.MachOHeaderStartSymbol;
979 });
980 assert(I != G.defined_symbols().end() && "Missing MachO header start symbol");
981
982 auto &JD = MR.getTargetJITDylib();
983 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
984 auto HeaderAddr = (*I)->getAddress();
985 MP.JITDylibToHeaderAddr[&JD] = HeaderAddr;
986 MP.HeaderAddrToJITDylib[HeaderAddr] = &JD;
987 // We can unconditionally add these actions to the Graph because this pass
988 // isn't used during bootstrap.
989 G.allocActions().push_back(
990 x: {.Finalize: cantFail(
991 ValOrErr: WrapperFunctionCall::Create<SPSArgList<SPSString, SPSExecutorAddr>>(
992 FnAddr: MP.RegisterJITDylib.Addr, Args: JD.getName(), Args: HeaderAddr)),
993 .Dealloc: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
994 FnAddr: MP.DeregisterJITDylib.Addr, Args: HeaderAddr))});
995 return Error::success();
996}
997
998Error MachOPlatform::MachOPlatformPlugin::preserveImportantSections(
999 jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
1000 // __objc_imageinfo is "important": we want to preserve it and record its
1001 // address in the first graph that it appears in, then verify and discard it
1002 // in all subsequent graphs. In this pass we preserve unconditionally -- we'll
1003 // manually throw it away in the processObjCImageInfo pass.
1004 if (auto *ObjCImageInfoSec =
1005 G.findSectionByName(Name: MachOObjCImageInfoSectionName)) {
1006 if (ObjCImageInfoSec->blocks_size() != 1)
1007 return make_error<StringError>(
1008 Args: "In " + G.getName() +
1009 "__DATA,__objc_imageinfo contains multiple blocks",
1010 Args: inconvertibleErrorCode());
1011 G.addAnonymousSymbol(Content&: **ObjCImageInfoSec->blocks().begin(), Offset: 0, Size: 0, IsCallable: false,
1012 IsLive: true);
1013
1014 for (auto *B : ObjCImageInfoSec->blocks())
1015 if (!B->edges_empty())
1016 return make_error<StringError>(Args: "In " + G.getName() + ", " +
1017 MachOObjCImageInfoSectionName +
1018 " contains references to symbols",
1019 Args: inconvertibleErrorCode());
1020 }
1021
1022 // Init sections are important: We need to preserve them and so that their
1023 // addresses can be captured and reported to the ORC runtime in
1024 // registerObjectPlatformSections.
1025 if (const auto &InitSymName = MR.getInitializerSymbol()) {
1026
1027 jitlink::Symbol *InitSym = nullptr;
1028 for (auto &InitSectionName : MachOInitSectionNames) {
1029 // Skip ObjCImageInfo -- this shouldn't have any dependencies, and we may
1030 // remove it later.
1031 if (InitSectionName == MachOObjCImageInfoSectionName)
1032 continue;
1033
1034 // Skip non-init sections.
1035 auto *InitSection = G.findSectionByName(Name: InitSectionName);
1036 if (!InitSection || InitSection->empty())
1037 continue;
1038
1039 // Create the init symbol if it has not been created already and attach it
1040 // to the first block.
1041 if (!InitSym) {
1042 auto &B = **InitSection->blocks().begin();
1043 InitSym = &G.addDefinedSymbol(
1044 Content&: B, Offset: 0, Name: *InitSymName, Size: B.getSize(), L: jitlink::Linkage::Strong,
1045 S: jitlink::Scope::SideEffectsOnly, IsCallable: false, IsLive: true);
1046 }
1047
1048 // Add keep-alive edges to anonymous symbols in all other init blocks.
1049 for (auto *B : InitSection->blocks()) {
1050 if (B == &InitSym->getBlock())
1051 continue;
1052
1053 auto &S = G.addAnonymousSymbol(Content&: *B, Offset: 0, Size: B->getSize(), IsCallable: false, IsLive: true);
1054 InitSym->getBlock().addEdge(K: jitlink::Edge::KeepAlive, Offset: 0, Target&: S, Addend: 0);
1055 }
1056 }
1057 }
1058
1059 return Error::success();
1060}
1061
1062Error MachOPlatform::MachOPlatformPlugin::processObjCImageInfo(
1063 jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
1064
1065 // If there's an ObjC imagine info then either
1066 // (1) It's the first __objc_imageinfo we've seen in this JITDylib. In
1067 // this case we name and record it.
1068 // OR
1069 // (2) We already have a recorded __objc_imageinfo for this JITDylib,
1070 // in which case we just verify it.
1071 auto *ObjCImageInfo = G.findSectionByName(Name: MachOObjCImageInfoSectionName);
1072 if (!ObjCImageInfo)
1073 return Error::success();
1074
1075 auto ObjCImageInfoBlocks = ObjCImageInfo->blocks();
1076
1077 // Check that the section is not empty if present.
1078 if (ObjCImageInfoBlocks.empty())
1079 return make_error<StringError>(Args: "Empty " + MachOObjCImageInfoSectionName +
1080 " section in " + G.getName(),
1081 Args: inconvertibleErrorCode());
1082
1083 // Check that there's only one block in the section.
1084 if (std::next(x: ObjCImageInfoBlocks.begin()) != ObjCImageInfoBlocks.end())
1085 return make_error<StringError>(Args: "Multiple blocks in " +
1086 MachOObjCImageInfoSectionName +
1087 " section in " + G.getName(),
1088 Args: inconvertibleErrorCode());
1089
1090 // Check that the __objc_imageinfo section is unreferenced.
1091 // FIXME: We could optimize this check if Symbols had a ref-count.
1092 for (auto &Sec : G.sections()) {
1093 if (&Sec != ObjCImageInfo)
1094 for (auto *B : Sec.blocks())
1095 for (auto &E : B->edges())
1096 if (E.getTarget().isDefined() &&
1097 &E.getTarget().getSection() == ObjCImageInfo)
1098 return make_error<StringError>(Args: MachOObjCImageInfoSectionName +
1099 " is referenced within file " +
1100 G.getName(),
1101 Args: inconvertibleErrorCode());
1102 }
1103
1104 auto &ObjCImageInfoBlock = **ObjCImageInfoBlocks.begin();
1105 auto *ObjCImageInfoData = ObjCImageInfoBlock.getContent().data();
1106 auto Version = support::endian::read32(P: ObjCImageInfoData, E: G.getEndianness());
1107 auto Flags =
1108 support::endian::read32(P: ObjCImageInfoData + 4, E: G.getEndianness());
1109
1110 // Lock the mutex while we verify / update the ObjCImageInfos map.
1111 std::lock_guard<std::mutex> Lock(PluginMutex);
1112
1113 auto ObjCImageInfoItr = ObjCImageInfos.find(Val: &MR.getTargetJITDylib());
1114 if (ObjCImageInfoItr != ObjCImageInfos.end()) {
1115 // We've already registered an __objc_imageinfo section. Verify the
1116 // content of this new section matches, then delete it.
1117 if (ObjCImageInfoItr->second.Version != Version)
1118 return make_error<StringError>(
1119 Args: "ObjC version in " + G.getName() +
1120 " does not match first registered version",
1121 Args: inconvertibleErrorCode());
1122 if (ObjCImageInfoItr->second.Flags != Flags)
1123 if (Error E = mergeImageInfoFlags(G, MR, Info&: ObjCImageInfoItr->second, NewFlags: Flags))
1124 return E;
1125
1126 // __objc_imageinfo is valid. Delete the block.
1127 while (ObjCImageInfo->symbols_size() != 0)
1128 G.removeDefinedSymbol(Sym&: **ObjCImageInfo->symbols().begin());
1129 G.removeBlock(B&: ObjCImageInfoBlock);
1130 } else {
1131 LLVM_DEBUG({
1132 dbgs() << "MachOPlatform: Registered __objc_imageinfo for "
1133 << MR.getTargetJITDylib().getName() << " in " << G.getName()
1134 << "; flags = " << formatv("{0:x4}", Flags) << "\n";
1135 });
1136 // We haven't registered an __objc_imageinfo section yet. Register and
1137 // move on. The section should already be marked no-dead-strip.
1138 G.addDefinedSymbol(Content&: ObjCImageInfoBlock, Offset: 0, Name: ObjCImageInfoSymbolName,
1139 Size: ObjCImageInfoBlock.getSize(), L: jitlink::Linkage::Strong,
1140 S: jitlink::Scope::Hidden, IsCallable: false, IsLive: true);
1141 if (auto Err = MR.defineMaterializing(
1142 SymbolFlags: {{MR.getExecutionSession().intern(SymName: ObjCImageInfoSymbolName),
1143 JITSymbolFlags()}}))
1144 return Err;
1145 ObjCImageInfos[&MR.getTargetJITDylib()] = {.Version: Version, .Flags: Flags, .Finalized: false};
1146 }
1147
1148 return Error::success();
1149}
1150
1151Error MachOPlatform::MachOPlatformPlugin::mergeImageInfoFlags(
1152 jitlink::LinkGraph &G, MaterializationResponsibility &MR,
1153 ObjCImageInfo &Info, uint32_t NewFlags) {
1154 if (Info.Flags == NewFlags)
1155 return Error::success();
1156
1157 ObjCImageInfoFlags Old(Info.Flags);
1158 ObjCImageInfoFlags New(NewFlags);
1159
1160 // Check for incompatible flags.
1161 if (Old.SwiftABIVersion && New.SwiftABIVersion &&
1162 Old.SwiftABIVersion != New.SwiftABIVersion)
1163 return make_error<StringError>(Args: "Swift ABI version in " + G.getName() +
1164 " does not match first registered flags",
1165 Args: inconvertibleErrorCode());
1166
1167 // HasCategoryClassProperties and HasSignedObjCClassROs can be disabled before
1168 // they are registered, if necessary, but once they are in use must be
1169 // supported by subsequent objects.
1170 if (Info.Finalized && Old.HasCategoryClassProperties &&
1171 !New.HasCategoryClassProperties)
1172 return make_error<StringError>(Args: "ObjC category class property support in " +
1173 G.getName() +
1174 " does not match first registered flags",
1175 Args: inconvertibleErrorCode());
1176 if (Info.Finalized && Old.HasSignedObjCClassROs && !New.HasSignedObjCClassROs)
1177 return make_error<StringError>(Args: "ObjC class_ro_t pointer signing in " +
1178 G.getName() +
1179 " does not match first registered flags",
1180 Args: inconvertibleErrorCode());
1181
1182 // If we cannot change the flags, ignore any remaining differences. Adding
1183 // Swift or changing its version are unlikely to cause problems in practice.
1184 if (Info.Finalized)
1185 return Error::success();
1186
1187 // Use the minimum Swift version.
1188 if (Old.SwiftVersion && New.SwiftVersion)
1189 New.SwiftVersion = std::min(a: Old.SwiftVersion, b: New.SwiftVersion);
1190 else if (Old.SwiftVersion)
1191 New.SwiftVersion = Old.SwiftVersion;
1192 // Add a Swift ABI version if it was pure objc before.
1193 if (!New.SwiftABIVersion)
1194 New.SwiftABIVersion = Old.SwiftABIVersion;
1195 // Disable class properties if any object does not support it.
1196 if (Old.HasCategoryClassProperties != New.HasCategoryClassProperties)
1197 New.HasCategoryClassProperties = false;
1198 // Disable signed class ro data if any object does not support it.
1199 if (Old.HasSignedObjCClassROs != New.HasSignedObjCClassROs)
1200 New.HasSignedObjCClassROs = false;
1201
1202 LLVM_DEBUG({
1203 dbgs() << "MachOPlatform: Merging __objc_imageinfo flags for "
1204 << MR.getTargetJITDylib().getName() << " (was "
1205 << formatv("{0:x4}", Old.rawFlags()) << ")"
1206 << " with " << G.getName() << " (" << formatv("{0:x4}", NewFlags)
1207 << ")"
1208 << " -> " << formatv("{0:x4}", New.rawFlags()) << "\n";
1209 });
1210
1211 Info.Flags = New.rawFlags();
1212 return Error::success();
1213}
1214
1215Error MachOPlatform::MachOPlatformPlugin::fixTLVSectionsAndEdges(
1216 jitlink::LinkGraph &G, JITDylib &JD) {
1217 auto TLVBootStrapSymbolName = G.intern(SymbolName: "__tlv_bootstrap");
1218 // Rename external references to __tlv_bootstrap to ___orc_rt_tlv_get_addr.
1219 for (auto *Sym : G.external_symbols())
1220 if (Sym->getName() == TLVBootStrapSymbolName) {
1221 auto TLSGetADDR =
1222 MP.getExecutionSession().intern(SymName: "___orc_rt_macho_tlv_get_addr");
1223 Sym->setName(std::move(TLSGetADDR));
1224 break;
1225 }
1226
1227 // Store key in __thread_vars struct fields.
1228 if (auto *ThreadDataSec = G.findSectionByName(Name: MachOThreadVarsSectionName)) {
1229 std::optional<uint64_t> Key;
1230 {
1231 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1232 auto I = MP.JITDylibToPThreadKey.find(Val: &JD);
1233 if (I != MP.JITDylibToPThreadKey.end())
1234 Key = I->second;
1235 }
1236
1237 if (!Key) {
1238 if (auto KeyOrErr = MP.createPThreadKey())
1239 Key = *KeyOrErr;
1240 else
1241 return KeyOrErr.takeError();
1242 }
1243
1244 uint64_t PlatformKeyBits =
1245 support::endian::byte_swap(value: *Key, endian: G.getEndianness());
1246
1247 for (auto *B : ThreadDataSec->blocks()) {
1248 if (B->getSize() != 3 * G.getPointerSize())
1249 return make_error<StringError>(Args: "__thread_vars block at " +
1250 formatv(Fmt: "{0:x}", Vals: B->getAddress()) +
1251 " has unexpected size",
1252 Args: inconvertibleErrorCode());
1253
1254 auto NewBlockContent = G.allocateBuffer(Size: B->getSize());
1255 llvm::copy(Range: B->getContent(), Out: NewBlockContent.data());
1256 memcpy(dest: NewBlockContent.data() + G.getPointerSize(), src: &PlatformKeyBits,
1257 n: G.getPointerSize());
1258 B->setContent(NewBlockContent);
1259 }
1260 }
1261
1262 // Transform any TLV edges into GOT edges.
1263 for (auto *B : G.blocks())
1264 for (auto &E : B->edges())
1265 if (E.getKind() ==
1266 jitlink::x86_64::RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable)
1267 E.setKind(jitlink::x86_64::
1268 RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable);
1269
1270 return Error::success();
1271}
1272
1273std::optional<MachOPlatform::MachOPlatformPlugin::UnwindSections>
1274MachOPlatform::MachOPlatformPlugin::findUnwindSectionInfo(
1275 jitlink::LinkGraph &G) {
1276 using namespace jitlink;
1277
1278 UnwindSections US;
1279
1280 // ScanSection records a section range and adds any executable blocks that
1281 // that section points to to the CodeBlocks vector.
1282 SmallVector<Block *> CodeBlocks;
1283 auto ScanUnwindInfoSection = [&](Section &Sec, ExecutorAddrRange &SecRange,
1284 auto AddCodeBlocks) {
1285 if (Sec.blocks().empty())
1286 return;
1287 SecRange = (*Sec.blocks().begin())->getRange();
1288 for (auto *B : Sec.blocks()) {
1289 auto R = B->getRange();
1290 SecRange.Start = std::min(a: SecRange.Start, b: R.Start);
1291 SecRange.End = std::max(a: SecRange.End, b: R.End);
1292 AddCodeBlocks(*B);
1293 }
1294 };
1295
1296 if (Section *EHFrameSec = G.findSectionByName(Name: MachOEHFrameSectionName)) {
1297 ScanUnwindInfoSection(*EHFrameSec, US.DwarfSection, [&](Block &B) {
1298 if (auto *Fn = jitlink::EHFrameCFIBlockInspector::FromEdgeScan(B)
1299 .getPCBeginEdge())
1300 if (Fn->getTarget().isDefined())
1301 CodeBlocks.push_back(Elt: &Fn->getTarget().getBlock());
1302 });
1303 }
1304
1305 if (Section *CUInfoSec = G.findSectionByName(Name: MachOUnwindInfoSectionName)) {
1306 ScanUnwindInfoSection(
1307 *CUInfoSec, US.CompactUnwindSection, [&](Block &B) {
1308 for (auto &E : B.edges()) {
1309 assert(E.getTarget().isDefined() &&
1310 "unwind-info record edge has external target");
1311 assert(E.getKind() == Edge::KeepAlive &&
1312 "unwind-info record has unexpected edge kind");
1313 CodeBlocks.push_back(Elt: &E.getTarget().getBlock());
1314 }
1315 });
1316 }
1317
1318 // If we didn't find any pointed-to code-blocks then there's no need to
1319 // register any info.
1320 if (CodeBlocks.empty())
1321 return std::nullopt;
1322
1323 // We have info to register. Sort the code blocks into address order and
1324 // build a list of contiguous address ranges covering them all.
1325 llvm::sort(C&: CodeBlocks, Comp: [](const Block *LHS, const Block *RHS) {
1326 return LHS->getAddress() < RHS->getAddress();
1327 });
1328 for (auto *B : CodeBlocks) {
1329 if (US.CodeRanges.empty() || US.CodeRanges.back().End != B->getAddress())
1330 US.CodeRanges.push_back(Elt: B->getRange());
1331 else
1332 US.CodeRanges.back().End = B->getRange().End;
1333 }
1334
1335 LLVM_DEBUG({
1336 dbgs() << "MachOPlatform identified unwind info in " << G.getName() << ":\n"
1337 << " DWARF: ";
1338 if (US.DwarfSection.Start)
1339 dbgs() << US.DwarfSection << "\n";
1340 else
1341 dbgs() << "none\n";
1342 dbgs() << " Compact-unwind: ";
1343 if (US.CompactUnwindSection.Start)
1344 dbgs() << US.CompactUnwindSection << "\n";
1345 else
1346 dbgs() << "none\n"
1347 << "for code ranges:\n";
1348 for (auto &CR : US.CodeRanges)
1349 dbgs() << " " << CR << "\n";
1350 if (US.CodeRanges.size() >= G.sections_size())
1351 dbgs() << "WARNING: High number of discontiguous code ranges! "
1352 "Padding may be interfering with coalescing.\n";
1353 });
1354
1355 return US;
1356}
1357
1358Error MachOPlatform::MachOPlatformPlugin::registerObjectPlatformSections(
1359 jitlink::LinkGraph &G, JITDylib &JD, ExecutorAddr HeaderAddr,
1360 bool InBootstrapPhase) {
1361
1362 // Get a pointer to the thread data section if there is one. It will be used
1363 // below.
1364 jitlink::Section *ThreadDataSection =
1365 G.findSectionByName(Name: MachOThreadDataSectionName);
1366
1367 // Handle thread BSS section if there is one.
1368 if (auto *ThreadBSSSection = G.findSectionByName(Name: MachOThreadBSSSectionName)) {
1369 // If there's already a thread data section in this graph then merge the
1370 // thread BSS section content into it, otherwise just treat the thread
1371 // BSS section as the thread data section.
1372 if (ThreadDataSection)
1373 G.mergeSections(DstSection&: *ThreadDataSection, SrcSection&: *ThreadBSSSection);
1374 else
1375 ThreadDataSection = ThreadBSSSection;
1376 }
1377
1378 SmallVector<std::pair<StringRef, ExecutorAddrRange>, 8> MachOPlatformSecs;
1379
1380 // Collect data sections to register.
1381 StringRef DataSections[] = {MachODataDataSectionName,
1382 MachODataCommonSectionName,
1383 MachOEHFrameSectionName};
1384 for (auto &SecName : DataSections) {
1385 if (auto *Sec = G.findSectionByName(Name: SecName)) {
1386 jitlink::SectionRange R(*Sec);
1387 if (!R.empty())
1388 MachOPlatformSecs.push_back(Elt: {SecName, R.getRange()});
1389 }
1390 }
1391
1392 // Having merged thread BSS (if present) and thread data (if present),
1393 // record the resulting section range.
1394 if (ThreadDataSection) {
1395 jitlink::SectionRange R(*ThreadDataSection);
1396 if (!R.empty())
1397 MachOPlatformSecs.push_back(Elt: {MachOThreadDataSectionName, R.getRange()});
1398 }
1399
1400 // If any platform sections were found then add an allocation action to call
1401 // the registration function.
1402 StringRef PlatformSections[] = {MachOModInitFuncSectionName,
1403 ObjCRuntimeObjectSectionName};
1404
1405 for (auto &SecName : PlatformSections) {
1406 auto *Sec = G.findSectionByName(Name: SecName);
1407 if (!Sec)
1408 continue;
1409 jitlink::SectionRange R(*Sec);
1410 if (R.empty())
1411 continue;
1412
1413 MachOPlatformSecs.push_back(Elt: {SecName, R.getRange()});
1414 }
1415
1416 std::optional<std::tuple<SmallVector<ExecutorAddrRange>, ExecutorAddrRange,
1417 ExecutorAddrRange>>
1418 UnwindInfo;
1419 if (auto UI = findUnwindSectionInfo(G))
1420 UnwindInfo = std::make_tuple(args: std::move(UI->CodeRanges), args&: UI->DwarfSection,
1421 args&: UI->CompactUnwindSection);
1422
1423 if (!MachOPlatformSecs.empty() || UnwindInfo) {
1424 // Dump the scraped inits.
1425 LLVM_DEBUG({
1426 dbgs() << "MachOPlatform: Scraped " << G.getName() << " init sections:\n";
1427 for (auto &KV : MachOPlatformSecs)
1428 dbgs() << " " << KV.first << ": " << KV.second << "\n";
1429 });
1430
1431 assert(HeaderAddr && "Null header registered for JD");
1432 using SPSRegisterObjectPlatformSectionsArgs = SPSArgList<
1433 SPSExecutorAddr,
1434 SPSOptional<SPSTuple<SPSSequence<SPSExecutorAddrRange>,
1435 SPSExecutorAddrRange, SPSExecutorAddrRange>>,
1436 SPSSequence<SPSTuple<SPSString, SPSExecutorAddrRange>>>;
1437
1438 AllocActionCallPair AllocActions = {
1439 .Finalize: cantFail(
1440 ValOrErr: WrapperFunctionCall::Create<SPSRegisterObjectPlatformSectionsArgs>(
1441 FnAddr: MP.RegisterObjectPlatformSections.Addr, Args: HeaderAddr, Args: UnwindInfo,
1442 Args: MachOPlatformSecs)),
1443 .Dealloc: cantFail(
1444 ValOrErr: WrapperFunctionCall::Create<SPSRegisterObjectPlatformSectionsArgs>(
1445 FnAddr: MP.DeregisterObjectPlatformSections.Addr, Args: HeaderAddr,
1446 Args: UnwindInfo, Args: MachOPlatformSecs))};
1447
1448 if (LLVM_LIKELY(!InBootstrapPhase))
1449 G.allocActions().push_back(x: std::move(AllocActions));
1450 else {
1451 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1452 MP.Bootstrap->DeferredAAs.push_back(x: std::move(AllocActions));
1453 }
1454 }
1455
1456 return Error::success();
1457}
1458
1459Error MachOPlatform::MachOPlatformPlugin::createObjCRuntimeObject(
1460 jitlink::LinkGraph &G) {
1461
1462 bool NeedTextSegment = false;
1463 size_t NumRuntimeSections = 0;
1464
1465 for (auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsData)
1466 if (G.findSectionByName(Name: ObjCRuntimeSectionName))
1467 ++NumRuntimeSections;
1468
1469 for (auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsText) {
1470 if (G.findSectionByName(Name: ObjCRuntimeSectionName)) {
1471 ++NumRuntimeSections;
1472 NeedTextSegment = true;
1473 }
1474 }
1475
1476 // Early out for no runtime sections.
1477 if (NumRuntimeSections == 0)
1478 return Error::success();
1479
1480 // If there were any runtime sections then we need to add an __objc_imageinfo
1481 // section.
1482 ++NumRuntimeSections;
1483
1484 size_t MachOSize = sizeof(MachO::mach_header_64) +
1485 (NeedTextSegment + 1) * sizeof(MachO::segment_command_64) +
1486 NumRuntimeSections * sizeof(MachO::section_64);
1487
1488 auto &Sec = G.createSection(Name: ObjCRuntimeObjectSectionName,
1489 Prot: MemProt::Read | MemProt::Write);
1490 G.createMutableContentBlock(Parent&: Sec, ContentSize: MachOSize, Address: ExecutorAddr(), Alignment: 16, AlignmentOffset: 0, ZeroInitialize: true);
1491
1492 return Error::success();
1493}
1494
1495Error MachOPlatform::MachOPlatformPlugin::populateObjCRuntimeObject(
1496 jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
1497
1498 auto *ObjCRuntimeObjectSec =
1499 G.findSectionByName(Name: ObjCRuntimeObjectSectionName);
1500
1501 if (!ObjCRuntimeObjectSec)
1502 return Error::success();
1503
1504 switch (G.getTargetTriple().getArch()) {
1505 case Triple::aarch64:
1506 case Triple::x86_64:
1507 // Supported.
1508 break;
1509 default:
1510 return make_error<StringError>(Args: "Unrecognized MachO arch in triple " +
1511 G.getTargetTriple().str(),
1512 Args: inconvertibleErrorCode());
1513 }
1514
1515 auto &SecBlock = **ObjCRuntimeObjectSec->blocks().begin();
1516
1517 struct SecDesc {
1518 MachO::section_64 Sec;
1519 unique_function<void(size_t RecordOffset)> AddFixups;
1520 };
1521
1522 std::vector<SecDesc> TextSections, DataSections;
1523 auto AddSection = [&](SecDesc &SD, jitlink::Section &GraphSec) {
1524 jitlink::SectionRange SR(GraphSec);
1525 StringRef FQName = GraphSec.getName();
1526 memset(s: &SD.Sec, c: 0, n: sizeof(MachO::section_64));
1527 memcpy(dest: SD.Sec.sectname, src: FQName.drop_front(N: 7).data(), n: FQName.size() - 7);
1528 memcpy(dest: SD.Sec.segname, src: FQName.data(), n: 6);
1529 SD.Sec.addr = SR.getStart() - SecBlock.getAddress();
1530 SD.Sec.size = SR.getSize();
1531 SD.Sec.flags = MachO::S_REGULAR;
1532 };
1533
1534 // Add the __objc_imageinfo section.
1535 {
1536 DataSections.push_back(x: {});
1537 auto &SD = DataSections.back();
1538 memset(s: &SD.Sec, c: 0, n: sizeof(SD.Sec));
1539 memcpy(dest: SD.Sec.sectname, src: "__objc_imageinfo", n: 16);
1540 strcpy(dest: SD.Sec.segname, src: "__DATA");
1541 SD.Sec.size = 8;
1542 jitlink::Symbol *ObjCImageInfoSym = nullptr;
1543 SD.AddFixups = [&, ObjCImageInfoSym](size_t RecordOffset) mutable {
1544 auto PointerEdge = getPointerEdgeKind(G);
1545
1546 // Look for an existing __objc_imageinfo symbol.
1547 if (!ObjCImageInfoSym) {
1548 auto Name = G.intern(SymbolName: ObjCImageInfoSymbolName);
1549 ObjCImageInfoSym = G.findExternalSymbolByName(Name);
1550 if (!ObjCImageInfoSym)
1551 ObjCImageInfoSym = G.findAbsoluteSymbolByName(Name);
1552 if (!ObjCImageInfoSym) {
1553 ObjCImageInfoSym = G.findDefinedSymbolByName(Name);
1554 if (ObjCImageInfoSym) {
1555 std::optional<uint32_t> Flags;
1556 {
1557 std::lock_guard<std::mutex> Lock(PluginMutex);
1558 auto It = ObjCImageInfos.find(Val: &MR.getTargetJITDylib());
1559 if (It != ObjCImageInfos.end()) {
1560 It->second.Finalized = true;
1561 Flags = It->second.Flags;
1562 }
1563 }
1564
1565 if (Flags) {
1566 // We own the definition of __objc_image_info; write the final
1567 // merged flags value.
1568 auto Content = ObjCImageInfoSym->getBlock().getMutableContent(G);
1569 assert(
1570 Content.size() == 8 &&
1571 "__objc_image_info size should have been verified already");
1572 support::endian::write32(P: &Content[4], V: *Flags, E: G.getEndianness());
1573 }
1574 }
1575 }
1576 if (!ObjCImageInfoSym)
1577 ObjCImageInfoSym = &G.addExternalSymbol(Name: std::move(Name), Size: 8, IsWeaklyReferenced: false);
1578 }
1579
1580 SecBlock.addEdge(K: PointerEdge,
1581 Offset: RecordOffset + ((char *)&SD.Sec.addr - (char *)&SD.Sec),
1582 Target&: *ObjCImageInfoSym, Addend: -SecBlock.getAddress().getValue());
1583 };
1584 }
1585
1586 for (auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsData) {
1587 if (auto *GraphSec = G.findSectionByName(Name: ObjCRuntimeSectionName)) {
1588 DataSections.push_back(x: {});
1589 AddSection(DataSections.back(), *GraphSec);
1590 }
1591 }
1592
1593 for (auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsText) {
1594 if (auto *GraphSec = G.findSectionByName(Name: ObjCRuntimeSectionName)) {
1595 TextSections.push_back(x: {});
1596 AddSection(TextSections.back(), *GraphSec);
1597 }
1598 }
1599
1600 assert(ObjCRuntimeObjectSec->blocks_size() == 1 &&
1601 "Unexpected number of blocks in runtime sections object");
1602
1603 // Build the header struct up-front. This also gives us a chance to check
1604 // that the triple is supported, which we'll assume below.
1605 MachO::mach_header_64 Hdr;
1606 Hdr.magic = MachO::MH_MAGIC_64;
1607 switch (G.getTargetTriple().getArch()) {
1608 case Triple::aarch64:
1609 Hdr.cputype = MachO::CPU_TYPE_ARM64;
1610 Hdr.cpusubtype = MachO::CPU_SUBTYPE_ARM64_ALL;
1611 break;
1612 case Triple::x86_64:
1613 Hdr.cputype = MachO::CPU_TYPE_X86_64;
1614 Hdr.cpusubtype = MachO::CPU_SUBTYPE_X86_64_ALL;
1615 break;
1616 default:
1617 llvm_unreachable("Unsupported architecture");
1618 }
1619
1620 Hdr.filetype = MachO::MH_DYLIB;
1621 Hdr.ncmds = 1 + !TextSections.empty();
1622 Hdr.sizeofcmds =
1623 Hdr.ncmds * sizeof(MachO::segment_command_64) +
1624 (TextSections.size() + DataSections.size()) * sizeof(MachO::section_64);
1625 Hdr.flags = 0;
1626 Hdr.reserved = 0;
1627
1628 auto SecContent = SecBlock.getAlreadyMutableContent();
1629 char *P = SecContent.data();
1630 auto WriteMachOStruct = [&](auto S) {
1631 if (G.getEndianness() != llvm::endianness::native)
1632 MachO::swapStruct(S);
1633 memcpy(P, &S, sizeof(S));
1634 P += sizeof(S);
1635 };
1636
1637 auto WriteSegment = [&](StringRef Name, std::vector<SecDesc> &Secs) {
1638 MachO::segment_command_64 SegLC;
1639 memset(s: &SegLC, c: 0, n: sizeof(SegLC));
1640 memcpy(dest: SegLC.segname, src: Name.data(), n: Name.size());
1641 SegLC.cmd = MachO::LC_SEGMENT_64;
1642 SegLC.cmdsize = sizeof(MachO::segment_command_64) +
1643 Secs.size() * sizeof(MachO::section_64);
1644 SegLC.nsects = Secs.size();
1645 WriteMachOStruct(SegLC);
1646 for (auto &SD : Secs) {
1647 if (SD.AddFixups)
1648 SD.AddFixups(P - SecContent.data());
1649 WriteMachOStruct(SD.Sec);
1650 }
1651 };
1652
1653 WriteMachOStruct(Hdr);
1654 if (!TextSections.empty())
1655 WriteSegment("__TEXT", TextSections);
1656 if (!DataSections.empty())
1657 WriteSegment("__DATA", DataSections);
1658
1659 assert(P == SecContent.end() && "Underflow writing ObjC runtime object");
1660 return Error::success();
1661}
1662
1663Error MachOPlatform::MachOPlatformPlugin::prepareSymbolTableRegistration(
1664 jitlink::LinkGraph &G, JITSymTabVector &JITSymTabInfo) {
1665
1666 auto *CStringSec = G.findSectionByName(Name: MachOCStringSectionName);
1667 if (!CStringSec)
1668 CStringSec = &G.createSection(Name: MachOCStringSectionName,
1669 Prot: MemProt::Read | MemProt::Exec);
1670
1671 // Make a map of existing strings so that we can re-use them:
1672 DenseMap<StringRef, jitlink::Symbol *> ExistingStrings;
1673 for (auto *Sym : CStringSec->symbols()) {
1674
1675 // The LinkGraph builder should have created single strings blocks, and all
1676 // plugins should have maintained this invariant.
1677 auto Content = Sym->getBlock().getContent();
1678 ExistingStrings.insert(
1679 KV: std::make_pair(x: StringRef(Content.data(), Content.size()), y&: Sym));
1680 }
1681
1682 // Add all symbol names to the string section, and record the symbols for
1683 // those names.
1684 {
1685 SmallVector<jitlink::Symbol *> SymsToProcess;
1686 llvm::append_range(C&: SymsToProcess, R: G.defined_symbols());
1687 llvm::append_range(C&: SymsToProcess, R: G.absolute_symbols());
1688
1689 for (auto *Sym : SymsToProcess) {
1690 if (!Sym->hasName())
1691 continue;
1692
1693 auto I = ExistingStrings.find(Val: *Sym->getName());
1694 if (I == ExistingStrings.end()) {
1695 auto &NameBlock = G.createMutableContentBlock(
1696 Parent&: *CStringSec, MutableContent: G.allocateCString(Source: *Sym->getName()),
1697 Address: orc::ExecutorAddr(), Alignment: 1, AlignmentOffset: 0);
1698 auto &SymbolNameSym = G.addAnonymousSymbol(
1699 Content&: NameBlock, Offset: 0, Size: NameBlock.getSize(), IsCallable: false, IsLive: true);
1700 JITSymTabInfo.push_back(Elt: {.OriginalSym: Sym, .NameSym: &SymbolNameSym});
1701 } else
1702 JITSymTabInfo.push_back(Elt: {.OriginalSym: Sym, .NameSym: I->second});
1703 }
1704 }
1705
1706 return Error::success();
1707}
1708
1709Error MachOPlatform::MachOPlatformPlugin::addSymbolTableRegistration(
1710 jitlink::LinkGraph &G, MaterializationResponsibility &MR,
1711 JITSymTabVector &JITSymTabInfo, bool InBootstrapPhase) {
1712
1713 ExecutorAddr HeaderAddr;
1714 {
1715 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1716 auto I = MP.JITDylibToHeaderAddr.find(Val: &MR.getTargetJITDylib());
1717 assert(I != MP.JITDylibToHeaderAddr.end() && "No header registered for JD");
1718 assert(I->second && "Null header registered for JD");
1719 HeaderAddr = I->second;
1720 }
1721
1722 if (LLVM_UNLIKELY(InBootstrapPhase)) {
1723 // If we're in the bootstrap phase then just record these symbols in the
1724 // bootstrap object and then bail out -- registration will be attached to
1725 // the bootstrap graph.
1726 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1727 auto &SymTab = MP.Bootstrap->SymTab;
1728 for (auto &[OriginalSymbol, NameSym] : JITSymTabInfo)
1729 SymTab.push_back(Elt: {NameSym->getAddress(), OriginalSymbol->getAddress(),
1730 flagsForSymbol(Sym&: *OriginalSymbol)});
1731 return Error::success();
1732 }
1733
1734 SymbolTableVector SymTab;
1735 for (auto &[OriginalSymbol, NameSym] : JITSymTabInfo)
1736 SymTab.push_back(Elt: {NameSym->getAddress(), OriginalSymbol->getAddress(),
1737 flagsForSymbol(Sym&: *OriginalSymbol)});
1738
1739 G.allocActions().push_back(
1740 x: {.Finalize: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
1741 FnAddr: MP.RegisterObjectSymbolTable.Addr, Args: HeaderAddr, Args: SymTab)),
1742 .Dealloc: cantFail(ValOrErr: WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
1743 FnAddr: MP.DeregisterObjectSymbolTable.Addr, Args: HeaderAddr, Args: SymTab))});
1744
1745 return Error::success();
1746}
1747
1748template <typename MachOTraits>
1749jitlink::Block &createHeaderBlock(MachOPlatform &MOP,
1750 const MachOPlatform::HeaderOptions &Opts,
1751 JITDylib &JD, jitlink::LinkGraph &G,
1752 jitlink::Section &HeaderSection) {
1753 auto HdrInfo =
1754 getMachOHeaderInfoFromTriple(TT: MOP.getExecutionSession().getTargetTriple());
1755 MachOBuilder<MachOTraits> B(HdrInfo.PageSize);
1756
1757 B.Header.filetype = MachO::MH_DYLIB;
1758 B.Header.cputype = HdrInfo.CPUType;
1759 B.Header.cpusubtype = HdrInfo.CPUSubType;
1760
1761 if (Opts.IDDylib)
1762 B.template addLoadCommand<MachO::LC_ID_DYLIB>(
1763 Opts.IDDylib->Name, Opts.IDDylib->Timestamp,
1764 Opts.IDDylib->CurrentVersion, Opts.IDDylib->CompatibilityVersion);
1765 else
1766 B.template addLoadCommand<MachO::LC_ID_DYLIB>(JD.getName(), 0, 0, 0);
1767
1768 if (Opts.UUID)
1769 B.template addLoadCommand<MachO::LC_UUID>(*Opts.UUID);
1770
1771 for (auto &BV : Opts.BuildVersions)
1772 B.template addLoadCommand<MachO::LC_BUILD_VERSION>(
1773 BV.Platform, BV.MinOS, BV.SDK, static_cast<uint32_t>(0));
1774
1775 using LoadKind = MachOPlatform::HeaderOptions::LoadDylibCmd::LoadKind;
1776 for (auto &LD : Opts.LoadDylibs) {
1777 switch (LD.K) {
1778 case LoadKind::Default:
1779 B.template addLoadCommand<MachO::LC_LOAD_DYLIB>(
1780 LD.D.Name, LD.D.Timestamp, LD.D.CurrentVersion,
1781 LD.D.CompatibilityVersion);
1782 break;
1783 case LoadKind::Weak:
1784 B.template addLoadCommand<MachO::LC_LOAD_WEAK_DYLIB>(
1785 LD.D.Name, LD.D.Timestamp, LD.D.CurrentVersion,
1786 LD.D.CompatibilityVersion);
1787 break;
1788 }
1789 }
1790 for (auto &P : Opts.RPaths)
1791 B.template addLoadCommand<MachO::LC_RPATH>(P);
1792
1793 auto HeaderContent = G.allocateBuffer(Size: B.layout());
1794 B.write(HeaderContent);
1795
1796 return G.createContentBlock(Parent&: HeaderSection, Content: HeaderContent, Address: ExecutorAddr(), Alignment: 8,
1797 AlignmentOffset: 0);
1798}
1799
1800SimpleMachOHeaderMU::SimpleMachOHeaderMU(MachOPlatform &MOP,
1801 SymbolStringPtr HeaderStartSymbol,
1802 MachOPlatform::HeaderOptions Opts)
1803 : MaterializationUnit(
1804 createHeaderInterface(MOP, HeaderStartSymbol: std::move(HeaderStartSymbol))),
1805 MOP(MOP), Opts(std::move(Opts)) {}
1806
1807void SimpleMachOHeaderMU::materialize(
1808 std::unique_ptr<MaterializationResponsibility> R) {
1809 auto G = createPlatformGraph(MOP, Name: "<MachOHeaderMU>");
1810 addMachOHeader(JD&: R->getTargetJITDylib(), G&: *G, InitializerSymbol: R->getInitializerSymbol());
1811 MOP.getObjectLinkingLayer().emit(R: std::move(R), G: std::move(G));
1812}
1813
1814void SimpleMachOHeaderMU::discard(const JITDylib &JD,
1815 const SymbolStringPtr &Sym) {}
1816
1817void SimpleMachOHeaderMU::addMachOHeader(
1818 JITDylib &JD, jitlink::LinkGraph &G,
1819 const SymbolStringPtr &InitializerSymbol) {
1820 auto &HeaderSection = G.createSection(Name: "__header", Prot: MemProt::Read);
1821 auto &HeaderBlock = createHeaderBlock(JD, G, HeaderSection);
1822
1823 // Init symbol is header-start symbol.
1824 G.addDefinedSymbol(Content&: HeaderBlock, Offset: 0, Name: *InitializerSymbol, Size: HeaderBlock.getSize(),
1825 L: jitlink::Linkage::Strong, S: jitlink::Scope::Default, IsCallable: false,
1826 IsLive: true);
1827 for (auto &HS : AdditionalHeaderSymbols)
1828 G.addDefinedSymbol(Content&: HeaderBlock, Offset: HS.Offset, Name: HS.Name, Size: HeaderBlock.getSize(),
1829 L: jitlink::Linkage::Strong, S: jitlink::Scope::Default, IsCallable: false,
1830 IsLive: true);
1831}
1832
1833jitlink::Block &
1834SimpleMachOHeaderMU::createHeaderBlock(JITDylib &JD, jitlink::LinkGraph &G,
1835 jitlink::Section &HeaderSection) {
1836 switch (MOP.getExecutionSession().getTargetTriple().getArch()) {
1837 case Triple::aarch64:
1838 case Triple::x86_64:
1839 return ::createHeaderBlock<MachO64LE>(MOP, Opts, JD, G, HeaderSection);
1840 default:
1841 llvm_unreachable("Unsupported architecture");
1842 }
1843}
1844
1845MaterializationUnit::Interface SimpleMachOHeaderMU::createHeaderInterface(
1846 MachOPlatform &MOP, const SymbolStringPtr &HeaderStartSymbol) {
1847 SymbolFlagsMap HeaderSymbolFlags;
1848
1849 HeaderSymbolFlags[HeaderStartSymbol] = JITSymbolFlags::Exported;
1850 for (auto &HS : AdditionalHeaderSymbols)
1851 HeaderSymbolFlags[MOP.getExecutionSession().intern(SymName: HS.Name)] =
1852 JITSymbolFlags::Exported;
1853
1854 return MaterializationUnit::Interface(std::move(HeaderSymbolFlags),
1855 HeaderStartSymbol);
1856}
1857
1858MachOHeaderInfo getMachOHeaderInfoFromTriple(const Triple &TT) {
1859 switch (TT.getArch()) {
1860 case Triple::aarch64:
1861 return {/* PageSize = */ 16 * 1024,
1862 /* CPUType = */ MachO::CPU_TYPE_ARM64,
1863 /* CPUSubType = */ MachO::CPU_SUBTYPE_ARM64_ALL};
1864 case Triple::x86_64:
1865 return {/* PageSize = */ 4 * 1024,
1866 /* CPUType = */ MachO::CPU_TYPE_X86_64,
1867 /* CPUSubType = */ MachO::CPU_SUBTYPE_X86_64_ALL};
1868 default:
1869 llvm_unreachable("Unrecognized architecture");
1870 }
1871}
1872
1873} // End namespace orc.
1874} // End namespace llvm.
1875