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