24#define DEBUG_TYPE "orc"
38class SPSMachOExecutorSymbolFlags;
50 return SPSMachOJITDylibDepInfo::AsArgList::serialize(OB, DDI.
Sealed,
56 return SPSMachOJITDylibDepInfo::AsArgList::deserialize(IB, DDI.
Sealed,
65 using UT = std::underlying_type_t<MachOPlatform::MachOExecutorSymbolFlags>;
93using SPSRegisterSymbolsArgs =
96 SPSMachOExecutorSymbolFlags>>>;
98std::unique_ptr<jitlink::LinkGraph> createPlatformGraph(
MachOPlatform &MOP,
104 switch (
TT.getArch()) {
114 return std::make_unique<jitlink::LinkGraph>(std::move(
Name), TT, PointerSize,
120class MachOPlatformCompleteBootstrapMaterializationUnit
123 using SymbolTableVector =
127 MachOPlatformCompleteBootstrapMaterializationUnit(
137 MOP(MOP), PlatformJDName(PlatformJDName),
138 CompleteBootstrapSymbol(std::move(CompleteBootstrapSymbol)),
139 SymTab(std::move(SymTab)), DeferredAAs(std::move(DeferredAAs)),
140 MachOHeaderAddr(MachOHeaderAddr), PlatformBootstrap(PlatformBootstrap),
141 PlatformShutdown(PlatformShutdown), RegisterJITDylib(RegisterJITDylib),
142 DeregisterJITDylib(DeregisterJITDylib),
143 RegisterObjectSymbolTable(RegisterObjectSymbolTable),
144 DeregisterObjectSymbolTable(DeregisterObjectSymbolTable) {}
147 return "MachOPlatformCompleteBootstrap";
150 void materialize(std::unique_ptr<MaterializationResponsibility> R)
override {
151 using namespace jitlink;
152 auto G = createPlatformGraph(MOP,
"<OrcRTCompleteBootstrap>");
153 auto &PlaceholderSection =
154 G->createSection(
"__orc_rt_cplt_bs", MemProt::Read);
155 auto &PlaceholderBlock =
156 G->createZeroFillBlock(PlaceholderSection, 1,
ExecutorAddr(), 1, 0);
157 G->addDefinedSymbol(PlaceholderBlock, 0, *CompleteBootstrapSymbol, 1,
158 Linkage::Strong, Scope::Hidden,
false,
true);
161 G->allocActions().reserve(DeferredAAs.size() + 3);
164 G->allocActions().push_back(
170 G->allocActions().push_back(
173 RegisterJITDylib, PlatformJDName, MachOHeaderAddr)),
175 DeregisterJITDylib, MachOHeaderAddr))});
178 G->allocActions().push_back(
179 {
cantFail(WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
180 RegisterObjectSymbolTable, MachOHeaderAddr, SymTab)),
181 cantFail(WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
182 DeregisterObjectSymbolTable, MachOHeaderAddr, SymTab))});
185 std::move(DeferredAAs.begin(), DeferredAAs.end(),
186 std::back_inserter(
G->allocActions()));
197 SymbolTableVector SymTab;
208static StringRef ObjCRuntimeObjectSectionsData[] = {
213static StringRef ObjCRuntimeObjectSectionsText[] = {
220static StringRef ObjCRuntimeObjectSectionName =
221 "__llvm_jitlink_ObjCRuntimeRegistrationObject";
223static StringRef ObjCImageInfoSymbolName =
224 "__llvm_jitlink_macho_objc_imageinfo";
226struct ObjCImageInfoFlags {
229 bool HasCategoryClassProperties;
230 bool HasSignedObjCClassROs;
232 static constexpr uint32_t SIGNED_CLASS_RO = (1 << 4);
233 static constexpr uint32_t HAS_CATEGORY_CLASS_PROPERTIES = (1 << 6);
235 explicit ObjCImageInfoFlags(
uint32_t RawFlags) {
236 HasSignedObjCClassROs = RawFlags & SIGNED_CLASS_RO;
237 HasCategoryClassProperties = RawFlags & HAS_CATEGORY_CLASS_PROPERTIES;
238 SwiftABIVersion = (RawFlags >> 8) & 0xFF;
239 SwiftVersion = (RawFlags >> 16) & 0xFFFF;
244 if (HasCategoryClassProperties)
245 Result |= HAS_CATEGORY_CLASS_PROPERTIES;
246 if (HasSignedObjCClassROs)
247 Result |= SIGNED_CLASS_RO;
248 Result |= (SwiftABIVersion << 8);
249 Result |= (SwiftVersion << 16);
258std::optional<MachOPlatform::HeaderOptions::BuildVersionOpts>
264 switch (TT.getOS()) {
266 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_IOSSIMULATOR
267 : MachO::PLATFORM_IOS;
273 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_TVOSSIMULATOR
274 : MachO::PLATFORM_TVOS;
277 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_WATCHOSSIMULATOR
278 : MachO::PLATFORM_WATCHOS;
281 Platform = TT.isSimulatorEnvironment() ? MachO::PLATFORM_XROS_SIMULATOR
282 : MachO::PLATFORM_XROS;
293 JITDylib &PlatformJD, std::unique_ptr<DefinitionGenerator> OrcRuntime,
295 std::optional<SymbolAliasMap> RuntimeAliases) {
299 return make_error<StringError>(
"Unsupported MachOPlatform triple: " +
311 return std::move(Err);
314 if (
auto Err = PlatformJD.
define(
316 {EPC.getJITDispatchInfo().JITDispatchFunction,
318 {ES.
intern(
"___orc_rt_jit_dispatch_ctx"),
319 {EPC.getJITDispatchInfo().JITDispatchContext,
321 return std::move(Err);
326 ES, ObjLinkingLayer, PlatformJD, std::move(OrcRuntime),
327 std::move(PlatformJDOpts), std::move(BuildMachOHeaderMU), Err));
329 return std::move(Err);
335 JITDylib &PlatformJD,
const char *OrcRuntimePath,
338 std::optional<SymbolAliasMap> RuntimeAliases) {
341 auto OrcRuntimeArchiveGenerator =
343 if (!OrcRuntimeArchiveGenerator)
344 return OrcRuntimeArchiveGenerator.takeError();
346 return Create(ES, ObjLinkingLayer, PlatformJD,
347 std::move(*OrcRuntimeArchiveGenerator),
348 std::move(PlatformJDOpts), std::move(BuildMachOHeaderMU),
349 std::move(RuntimeAliases));
357 if (
auto Err = JD.
define(BuildMachOHeaderMU(*
this, std::move(Opts))))
360 return ES.lookup({&JD}, MachOHeaderStartSymbol).takeError();
364 std::lock_guard<std::mutex> Lock(PlatformMutex);
365 auto I = JITDylibToHeaderAddr.find(&JD);
366 if (
I != JITDylibToHeaderAddr.end()) {
367 assert(HeaderAddrToJITDylib.count(
I->second) &&
368 "HeaderAddrToJITDylib missing entry");
369 HeaderAddrToJITDylib.erase(
I->second);
370 JITDylibToHeaderAddr.erase(
I);
372 JITDylibToPThreadKey.erase(&JD);
383 RegisteredInitSymbols[&JD].add(InitSym,
386 dbgs() <<
"MachOPlatform: Registered init symbol " << *InitSym <<
" for MU "
397 ArrayRef<std::pair<const char *, const char *>> AL) {
398 for (
auto &KV : AL) {
399 auto AliasName = ES.
intern(KV.first);
400 assert(!Aliases.
count(AliasName) &&
"Duplicate symbol name in alias map");
401 Aliases[std::move(AliasName)] = {ES.
intern(KV.second),
415 static const std::pair<const char *, const char *> RequiredCXXAliases[] = {
416 {
"___cxa_atexit",
"___orc_rt_macho_cxa_atexit"}};
423 static const std::pair<const char *, const char *>
424 StandardRuntimeUtilityAliases[] = {
425 {
"___orc_rt_run_program",
"___orc_rt_macho_run_program"},
426 {
"___orc_rt_jit_dlerror",
"___orc_rt_macho_jit_dlerror"},
427 {
"___orc_rt_jit_dlopen",
"___orc_rt_macho_jit_dlopen"},
428 {
"___orc_rt_jit_dlclose",
"___orc_rt_macho_jit_dlclose"},
429 {
"___orc_rt_jit_dlsym",
"___orc_rt_macho_jit_dlsym"},
430 {
"___orc_rt_log_error",
"___orc_rt_log_error_to_stderr"}};
433 StandardRuntimeUtilityAliases);
436bool MachOPlatform::supportedTarget(
const Triple &TT) {
437 switch (TT.getArch()) {
447 switch (
G.getTargetTriple().getArch()) {
463 if (
Sym.isCallable())
469MachOPlatform::MachOPlatform(
472 std::unique_ptr<DefinitionGenerator> OrcRuntimeGenerator,
475 : ES(ES), PlatformJD(PlatformJD), ObjLinkingLayer(ObjLinkingLayer),
476 BuildMachOHeaderMU(
std::
move(BuildMachOHeaderMU)) {
478 ObjLinkingLayer.
addPlugin(std::make_unique<MachOPlatformPlugin>(*
this));
479 PlatformJD.
addGenerator(std::move(OrcRuntimeGenerator));
539 if ((Err = PlatformJD.
define(
540 this->BuildMachOHeaderMU(*
this, std::move(PlatformJDOpts)))))
542 if ((Err = ES.
lookup(&PlatformJD, MachOHeaderStartSymbol).takeError()))
549 {PlatformBootstrap.Name, PlatformShutdown.Name,
550 RegisterJITDylib.Name, DeregisterJITDylib.Name,
551 RegisterObjectSymbolTable.Name,
552 DeregisterObjectSymbolTable.Name,
553 RegisterObjectPlatformSections.Name,
554 DeregisterObjectPlatformSections.Name,
555 CreatePThreadKey.Name}))
561 std::unique_lock<std::mutex> Lock(BI.Mutex);
562 BI.CV.wait(Lock, [&]() {
return BI.ActiveGraphs == 0; });
567 auto BootstrapCompleteSymbol = ES.
intern(
"__orc_rt_macho_complete_bootstrap");
568 if ((Err = PlatformJD.
define(
569 std::make_unique<MachOPlatformCompleteBootstrapMaterializationUnit>(
570 *
this, PlatformJD.
getName(), BootstrapCompleteSymbol,
571 std::move(BI.SymTab), std::move(BI.DeferredAAs),
572 BI.MachOHeaderAddr, PlatformBootstrap.Addr,
573 PlatformShutdown.Addr, RegisterJITDylib.Addr,
574 DeregisterJITDylib.Addr, RegisterObjectSymbolTable.Addr,
575 DeregisterObjectSymbolTable.Addr))))
579 std::move(BootstrapCompleteSymbol))
584 if ((Err = associateRuntimeSupportFunctions()))
588Error MachOPlatform::associateRuntimeSupportFunctions() {
591 using PushInitializersSPSSig =
593 WFs[ES.
intern(
"___orc_rt_macho_push_initializers_tag")] =
595 this, &MachOPlatform::rt_pushInitializers);
597 using PushSymbolsSPSSig =
599 WFs[ES.
intern(
"___orc_rt_macho_push_symbols_tag")] =
601 &MachOPlatform::rt_pushSymbols);
606void MachOPlatform::pushInitializersLoop(
607 PushInitializersSendResultFn SendResult,
JITDylibSP JD) {
613 while (!Worklist.empty()) {
616 auto DepJD = Worklist.back();
620 if (JDDepMap.count(DepJD))
624 auto &DM = JDDepMap[DepJD];
625 DepJD->withLinkOrderDo([&](const JITDylibSearchOrder &O) {
627 if (KV.first == DepJD)
629 DM.push_back(KV.first);
630 Worklist.push_back(KV.first);
635 auto RISItr = RegisteredInitSymbols.find(DepJD);
636 if (RISItr != RegisteredInitSymbols.end()) {
637 NewInitSymbols[DepJD] = std::move(RISItr->second);
638 RegisteredInitSymbols.erase(RISItr);
645 if (NewInitSymbols.
empty()) {
654 std::lock_guard<std::mutex> Lock(PlatformMutex);
655 for (
auto &KV : JDDepMap) {
656 auto I = JITDylibToHeaderAddr.find(KV.first);
657 if (
I != JITDylibToHeaderAddr.end())
658 HeaderAddrs[KV.first] =
I->second;
663 MachOJITDylibDepInfoMap DIM;
664 DIM.reserve(JDDepMap.size());
665 for (
auto &KV : JDDepMap) {
666 auto HI = HeaderAddrs.
find(KV.first);
668 if (HI == HeaderAddrs.
end())
671 MachOJITDylibDepInfo DepInfo;
672 for (
auto &Dep : KV.second) {
673 auto HJ = HeaderAddrs.
find(Dep);
674 if (HJ != HeaderAddrs.
end())
675 DepInfo.DepHeaders.push_back(HJ->second);
677 DIM.push_back(std::make_pair(
H, std::move(DepInfo)));
684 lookupInitSymbolsAsync(
685 [
this, SendResult = std::move(SendResult), JD](
Error Err)
mutable {
687 SendResult(std::move(Err));
689 pushInitializersLoop(std::move(SendResult), JD);
691 ES, std::move(NewInitSymbols));
694void MachOPlatform::rt_pushInitializers(PushInitializersSendResultFn SendResult,
698 std::lock_guard<std::mutex> Lock(PlatformMutex);
699 auto I = HeaderAddrToJITDylib.find(JDHeaderAddr);
700 if (
I != HeaderAddrToJITDylib.end())
705 dbgs() <<
"MachOPlatform::rt_pushInitializers(" << JDHeaderAddr <<
") ";
707 dbgs() <<
"pushing initializers for " << JD->
getName() <<
"\n";
709 dbgs() <<
"No JITDylib for header address.\n";
713 SendResult(make_error<StringError>(
"No JITDylib with header addr " +
714 formatv(
"{0:x}", JDHeaderAddr),
719 pushInitializersLoop(std::move(SendResult), JD);
722void MachOPlatform::rt_pushSymbols(
723 PushSymbolsInSendResultFn SendResult,
ExecutorAddr Handle,
724 const std::vector<std::pair<StringRef, bool>> &SymbolNames) {
729 std::lock_guard<std::mutex> Lock(PlatformMutex);
730 auto I = HeaderAddrToJITDylib.find(Handle);
731 if (
I != HeaderAddrToJITDylib.end())
735 dbgs() <<
"MachOPlatform::rt_pushSymbols(";
739 dbgs() <<
"<invalid handle " << Handle <<
">, [ ";
740 for (
auto &
Name : SymbolNames)
741 dbgs() <<
"\"" <<
Name.first <<
"\" ";
746 SendResult(make_error<StringError>(
"No JITDylib associated with handle " +
753 for (
auto &[
Name, Required] : SymbolNames)
755 ? SymbolLookupFlags::RequiredSymbol
756 : SymbolLookupFlags::WeaklyReferencedSymbol);
759 LookupKind::DLSym, {{JD, JITDylibLookupFlags::MatchExportedSymbolsOnly}},
760 std::move(LS), SymbolState::Ready,
762 SendResult(
Result.takeError());
768 if (!CreatePThreadKey.Addr)
769 return make_error<StringError>(
770 "Attempting to create pthread key in target, but runtime support has "
771 "not been loaded yet",
776 CreatePThreadKey.Addr,
Result))
777 return std::move(Err);
781void MachOPlatform::MachOPlatformPlugin::modifyPassConfig(
785 using namespace jitlink;
787 bool InBootstrapPhase =
791 if (InBootstrapPhase) {
792 Config.PrePrunePasses.push_back(
793 [
this](LinkGraph &
G) {
return bootstrapPipelineStart(
G); });
794 Config.PostAllocationPasses.push_back([
this](LinkGraph &
G) {
795 return bootstrapPipelineRecordRuntimeFunctions(
G);
805 if (InitSymbol == MP.MachOHeaderStartSymbol && !InBootstrapPhase) {
806 Config.PostAllocationPasses.push_back([
this, &MR](LinkGraph &
G) {
807 return associateJITDylibHeaderSymbol(
G, MR);
815 Config.PrePrunePasses.push_back([
this, &MR](LinkGraph &
G) {
816 if (
auto Err = preserveImportantSections(
G, MR))
818 return processObjCImageInfo(
G, MR);
820 Config.PostPrunePasses.push_back(
821 [
this](LinkGraph &
G) {
return createObjCRuntimeObject(
G); });
822 Config.PostAllocationPasses.push_back(
823 [
this, &MR](LinkGraph &
G) {
return populateObjCRuntimeObject(
G, MR); });
828 Config.PostPrunePasses.insert(
829 Config.PostPrunePasses.begin(),
831 return fixTLVSectionsAndEdges(
G, JD);
837 auto JITSymTabInfo = std::make_shared<JITSymTabVector>();
838 Config.PostPrunePasses.push_back([
this, JITSymTabInfo](LinkGraph &
G) {
839 return prepareSymbolTableRegistration(
G, *JITSymTabInfo);
841 Config.PostFixupPasses.push_back([
this, &MR, JITSymTabInfo,
842 InBootstrapPhase](LinkGraph &
G) {
843 return addSymbolTableRegistration(
G, MR, *JITSymTabInfo, InBootstrapPhase);
848 Config.PostAllocationPasses.push_back(
850 return registerObjectPlatformSections(
G, JD, InBootstrapPhase);
855 if (InBootstrapPhase)
856 Config.PostFixupPasses.push_back(
857 [
this](LinkGraph &
G) {
return bootstrapPipelineEnd(
G); });
861MachOPlatform::MachOPlatformPlugin::getSyntheticSymbolDependencies(
863 std::lock_guard<std::mutex> Lock(PluginMutex);
864 auto I = InitSymbolDeps.find(&MR);
865 if (
I != InitSymbolDeps.end()) {
866 SyntheticSymbolDependenciesMap
Result;
868 InitSymbolDeps.erase(&MR);
871 return SyntheticSymbolDependenciesMap();
874Error MachOPlatform::MachOPlatformPlugin::bootstrapPipelineStart(
877 std::lock_guard<std::mutex> Lock(MP.Bootstrap.load()->Mutex);
878 ++MP.Bootstrap.load()->ActiveGraphs;
882Error MachOPlatform::MachOPlatformPlugin::
885 std::pair<StringRef, ExecutorAddr *> RuntimeSymbols[] = {
886 {*MP.MachOHeaderStartSymbol, &MP.Bootstrap.load()->MachOHeaderAddr},
887 {*MP.PlatformBootstrap.Name, &MP.PlatformBootstrap.Addr},
888 {*MP.PlatformShutdown.Name, &MP.PlatformShutdown.Addr},
889 {*MP.RegisterJITDylib.Name, &MP.RegisterJITDylib.Addr},
890 {*MP.DeregisterJITDylib.Name, &MP.DeregisterJITDylib.Addr},
891 {*MP.RegisterObjectSymbolTable.Name, &MP.RegisterObjectSymbolTable.Addr},
892 {*MP.DeregisterObjectSymbolTable.Name,
893 &MP.DeregisterObjectSymbolTable.Addr},
894 {*MP.RegisterObjectPlatformSections.Name,
895 &MP.RegisterObjectPlatformSections.Addr},
896 {*MP.DeregisterObjectPlatformSections.Name,
897 &MP.DeregisterObjectPlatformSections.Addr},
898 {*MP.CreatePThreadKey.Name, &MP.CreatePThreadKey.Addr},
899 {*MP.RegisterObjCRuntimeObject.Name, &MP.RegisterObjCRuntimeObject.Addr},
900 {*MP.DeregisterObjCRuntimeObject.Name,
901 &MP.DeregisterObjCRuntimeObject.Addr}};
903 bool RegisterMachOHeader =
false;
905 for (
auto *
Sym :
G.defined_symbols()) {
906 for (
auto &RTSym : RuntimeSymbols) {
907 if (
Sym->hasName() &&
Sym->getName() == RTSym.first) {
909 return make_error<StringError>(
910 "Duplicate " + RTSym.first +
911 " detected during MachOPlatform bootstrap",
914 if (
Sym->getName() == *MP.MachOHeaderStartSymbol)
915 RegisterMachOHeader =
true;
917 *RTSym.second =
Sym->getAddress();
922 if (RegisterMachOHeader) {
925 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
926 MP.JITDylibToHeaderAddr[&MP.PlatformJD] =
927 MP.Bootstrap.load()->MachOHeaderAddr;
928 MP.HeaderAddrToJITDylib[MP.Bootstrap.load()->MachOHeaderAddr] =
935Error MachOPlatform::MachOPlatformPlugin::bootstrapPipelineEnd(
937 std::lock_guard<std::mutex> Lock(MP.Bootstrap.load()->Mutex);
938 assert(MP.Bootstrap &&
"DeferredAAs reset before bootstrap completed");
939 --MP.Bootstrap.load()->ActiveGraphs;
942 if (MP.Bootstrap.load()->ActiveGraphs == 0)
943 MP.Bootstrap.load()->CV.notify_all();
947Error MachOPlatform::MachOPlatformPlugin::associateJITDylibHeaderSymbol(
950 return Sym->getName() == *MP.MachOHeaderStartSymbol;
952 assert(
I !=
G.defined_symbols().end() &&
"Missing MachO header start symbol");
955 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
956 auto HeaderAddr = (*I)->getAddress();
957 MP.JITDylibToHeaderAddr[&JD] = HeaderAddr;
958 MP.HeaderAddrToJITDylib[HeaderAddr] = &JD;
961 G.allocActions().push_back(
964 MP.RegisterJITDylib.Addr, JD.
getName(), HeaderAddr)),
966 MP.DeregisterJITDylib.Addr, HeaderAddr))});
970Error MachOPlatform::MachOPlatformPlugin::preserveImportantSections(
976 if (
auto *ObjCImageInfoSec =
978 if (ObjCImageInfoSec->blocks_size() != 1)
979 return make_error<StringError>(
980 "In " +
G.getName() +
981 "__DATA,__objc_imageinfo contains multiple blocks",
983 G.addAnonymousSymbol(**ObjCImageInfoSec->blocks().begin(), 0, 0,
false,
986 for (
auto *
B : ObjCImageInfoSec->blocks())
987 if (!
B->edges_empty())
988 return make_error<StringError>(
"In " +
G.getName() +
", " +
990 " contains references to symbols",
997 JITLinkSymbolSet InitSectionSymbols;
1005 auto *InitSection =
G.findSectionByName(InitSectionName);
1012 for (
auto &
Sym : InitSection->symbols()) {
1013 auto &
B =
Sym->getBlock();
1014 if (
Sym->isLive() &&
Sym->getOffset() == 0 &&
1015 Sym->getSize() ==
B.getSize() && !AlreadyLiveBlocks.
count(&
B)) {
1016 InitSectionSymbols.insert(
Sym);
1022 for (
auto *
B : InitSection->blocks())
1023 if (!AlreadyLiveBlocks.
count(
B))
1024 InitSectionSymbols.insert(
1025 &
G.addAnonymousSymbol(*
B, 0,
B->getSize(),
false,
true));
1028 if (!InitSectionSymbols.empty()) {
1029 std::lock_guard<std::mutex> Lock(PluginMutex);
1030 InitSymbolDeps[&MR] = std::move(InitSectionSymbols);
1036Error MachOPlatform::MachOPlatformPlugin::processObjCImageInfo(
1049 auto ObjCImageInfoBlocks = ObjCImageInfo->blocks();
1052 if (ObjCImageInfoBlocks.empty())
1054 " section in " +
G.getName(),
1058 if (std::next(ObjCImageInfoBlocks.begin()) != ObjCImageInfoBlocks.end())
1059 return make_error<StringError>(
"Multiple blocks in " +
1061 " section in " +
G.getName(),
1066 for (
auto &Sec :
G.sections()) {
1067 if (&Sec != ObjCImageInfo)
1068 for (
auto *
B : Sec.blocks())
1069 for (
auto &E :
B->edges())
1070 if (E.getTarget().isDefined() &&
1071 &E.getTarget().getBlock().getSection() == ObjCImageInfo)
1073 " is referenced within file " +
1078 auto &ObjCImageInfoBlock = **ObjCImageInfoBlocks.begin();
1079 auto *ObjCImageInfoData = ObjCImageInfoBlock.getContent().data();
1085 std::lock_guard<std::mutex> Lock(PluginMutex);
1088 if (ObjCImageInfoItr != ObjCImageInfos.end()) {
1091 if (ObjCImageInfoItr->second.Version !=
Version)
1092 return make_error<StringError>(
1093 "ObjC version in " +
G.getName() +
1094 " does not match first registered version",
1096 if (ObjCImageInfoItr->second.Flags != Flags)
1097 if (
Error E = mergeImageInfoFlags(
G, MR, ObjCImageInfoItr->second, Flags))
1101 for (
auto *S : ObjCImageInfo->symbols())
1102 G.removeDefinedSymbol(*S);
1103 G.removeBlock(ObjCImageInfoBlock);
1106 dbgs() <<
"MachOPlatform: Registered __objc_imageinfo for "
1108 <<
"; flags = " <<
formatv(
"{0:x4}", Flags) <<
"\n";
1112 G.addDefinedSymbol(ObjCImageInfoBlock, 0, ObjCImageInfoSymbolName,
1116 {{MR.getExecutionSession().intern(ObjCImageInfoSymbolName),
1117 JITSymbolFlags()}}))
1125Error MachOPlatform::MachOPlatformPlugin::mergeImageInfoFlags(
1127 ObjCImageInfo &Info,
uint32_t NewFlags) {
1128 if (
Info.Flags == NewFlags)
1131 ObjCImageInfoFlags Old(
Info.Flags);
1132 ObjCImageInfoFlags
New(NewFlags);
1135 if (Old.SwiftABIVersion &&
New.SwiftABIVersion &&
1136 Old.SwiftABIVersion !=
New.SwiftABIVersion)
1137 return make_error<StringError>(
"Swift ABI version in " +
G.getName() +
1138 " does not match first registered flags",
1144 if (
Info.Finalized && Old.HasCategoryClassProperties &&
1145 !
New.HasCategoryClassProperties)
1146 return make_error<StringError>(
"ObjC category class property support in " +
1148 " does not match first registered flags",
1150 if (
Info.Finalized && Old.HasSignedObjCClassROs && !
New.HasSignedObjCClassROs)
1151 return make_error<StringError>(
"ObjC class_ro_t pointer signing in " +
1153 " does not match first registered flags",
1162 if (Old.SwiftVersion &&
New.SwiftVersion)
1163 New.SwiftVersion = std::min(Old.SwiftVersion,
New.SwiftVersion);
1164 else if (Old.SwiftVersion)
1165 New.SwiftVersion = Old.SwiftVersion;
1167 if (!
New.SwiftABIVersion)
1168 New.SwiftABIVersion = Old.SwiftABIVersion;
1170 if (Old.HasCategoryClassProperties !=
New.HasCategoryClassProperties)
1171 New.HasCategoryClassProperties =
false;
1173 if (Old.HasSignedObjCClassROs !=
New.HasSignedObjCClassROs)
1174 New.HasSignedObjCClassROs =
false;
1177 dbgs() <<
"MachOPlatform: Merging __objc_imageinfo flags for "
1179 <<
formatv(
"{0:x4}", Old.rawFlags()) <<
")"
1180 <<
" with " <<
G.getName() <<
" (" <<
formatv(
"{0:x4}", NewFlags)
1182 <<
" -> " <<
formatv(
"{0:x4}",
New.rawFlags()) <<
"\n";
1189Error MachOPlatform::MachOPlatformPlugin::fixTLVSectionsAndEdges(
1193 for (
auto *
Sym :
G.external_symbols())
1194 if (
Sym->getName() ==
"__tlv_bootstrap") {
1195 Sym->setName(
"___orc_rt_macho_tlv_get_addr");
1201 std::optional<uint64_t>
Key;
1203 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1204 auto I = MP.JITDylibToPThreadKey.find(&JD);
1205 if (
I != MP.JITDylibToPThreadKey.end())
1210 if (
auto KeyOrErr = MP.createPThreadKey())
1213 return KeyOrErr.takeError();
1219 for (
auto *
B : ThreadDataSec->blocks()) {
1220 if (
B->getSize() != 3 *
G.getPointerSize())
1221 return make_error<StringError>(
"__thread_vars block at " +
1222 formatv(
"{0:x}",
B->getAddress()) +
1223 " has unexpected size",
1226 auto NewBlockContent =
G.allocateBuffer(
B->getSize());
1227 llvm::copy(
B->getContent(), NewBlockContent.data());
1228 memcpy(NewBlockContent.data() +
G.getPointerSize(), &PlatformKeyBits,
1229 G.getPointerSize());
1230 B->setContent(NewBlockContent);
1235 for (
auto *
B :
G.blocks())
1236 for (
auto &E :
B->edges())
1239 E.setKind(jitlink::x86_64::
1240 RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable);
1245std::optional<MachOPlatform::MachOPlatformPlugin::UnwindSections>
1246MachOPlatform::MachOPlatformPlugin::findUnwindSectionInfo(
1248 using namespace jitlink;
1256 if (Sec.blocks().empty())
1258 SecRange = (*Sec.blocks().begin())->
getRange();
1259 for (
auto *
B : Sec.blocks()) {
1260 auto R =
B->getRange();
1261 SecRange.Start = std::min(SecRange.Start,
R.Start);
1262 SecRange.End = std::max(SecRange.End,
R.End);
1263 for (
auto &E :
B->edges()) {
1264 if (!E.getTarget().isDefined())
1266 auto &TargetBlock = E.getTarget().getBlock();
1267 auto &TargetSection = TargetBlock.getSection();
1268 if ((TargetSection.getMemProt() & MemProt::Exec) == MemProt::Exec)
1275 ScanUnwindInfoSection(*EHFrameSec, US.DwarfSection);
1277 if (Section *CUInfoSec =
1279 ScanUnwindInfoSection(*CUInfoSec, US.CompactUnwindSection);
1283 if (CodeBlocks.
empty())
1284 return std::nullopt;
1289 return LHS->getAddress() <
RHS->getAddress();
1291 for (
auto *
B : CodeBlocks) {
1292 if (US.CodeRanges.empty() || US.CodeRanges.back().End !=
B->getAddress())
1293 US.CodeRanges.push_back(
B->getRange());
1295 US.CodeRanges.back().End =
B->getRange().End;
1299 dbgs() <<
"MachOPlatform identified unwind info in " <<
G.getName() <<
":\n"
1301 if (US.DwarfSection.Start)
1302 dbgs() << US.DwarfSection <<
"\n";
1305 dbgs() <<
" Compact-unwind: ";
1306 if (US.CompactUnwindSection.Start)
1307 dbgs() << US.CompactUnwindSection <<
"\n";
1310 <<
"for code ranges:\n";
1311 for (
auto &CR : US.CodeRanges)
1312 dbgs() <<
" " << CR <<
"\n";
1313 if (US.CodeRanges.size() >=
G.sections_size())
1314 dbgs() <<
"WARNING: High number of discontiguous code ranges! "
1315 "Padding may be interfering with coalescing.\n";
1321Error MachOPlatform::MachOPlatformPlugin::registerObjectPlatformSections(
1334 if (ThreadDataSection)
1335 G.mergeSections(*ThreadDataSection, *ThreadBSSSection);
1337 ThreadDataSection = ThreadBSSSection;
1346 for (
auto &SecName : DataSections) {
1347 if (
auto *Sec =
G.findSectionByName(SecName)) {
1350 MachOPlatformSecs.
push_back({SecName,
R.getRange()});
1356 if (ThreadDataSection) {
1365 ObjCRuntimeObjectSectionName};
1367 for (
auto &SecName : PlatformSections) {
1368 auto *Sec =
G.findSectionByName(SecName);
1375 MachOPlatformSecs.
push_back({SecName,
R.getRange()});
1381 if (
auto UI = findUnwindSectionInfo(
G))
1382 UnwindInfo = std::make_tuple(std::move(UI->CodeRanges), UI->DwarfSection,
1383 UI->CompactUnwindSection);
1385 if (!MachOPlatformSecs.
empty() || UnwindInfo) {
1388 dbgs() <<
"MachOPlatform: Scraped " <<
G.getName() <<
" init sections:\n";
1389 for (
auto &KV : MachOPlatformSecs)
1390 dbgs() <<
" " << KV.first <<
": " << KV.second <<
"\n";
1393 using SPSRegisterObjectPlatformSectionsArgs =
SPSArgList<
1401 : MP.Bootstrap.load()->DeferredAAs;
1405 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1406 auto I = MP.JITDylibToHeaderAddr.find(&JD);
1407 assert(
I != MP.JITDylibToHeaderAddr.end() &&
1408 "No header registered for JD");
1409 assert(
I->second &&
"Null header registered for JD");
1410 HeaderAddr =
I->second;
1412 allocActions.push_back(
1414 WrapperFunctionCall::Create<SPSRegisterObjectPlatformSectionsArgs>(
1415 MP.RegisterObjectPlatformSections.Addr, HeaderAddr, UnwindInfo,
1416 MachOPlatformSecs)),
1418 WrapperFunctionCall::Create<SPSRegisterObjectPlatformSectionsArgs>(
1419 MP.DeregisterObjectPlatformSections.Addr, HeaderAddr,
1420 UnwindInfo, MachOPlatformSecs))});
1426Error MachOPlatform::MachOPlatformPlugin::createObjCRuntimeObject(
1429 bool NeedTextSegment =
false;
1430 size_t NumRuntimeSections = 0;
1432 for (
auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsData)
1433 if (
G.findSectionByName(ObjCRuntimeSectionName))
1434 ++NumRuntimeSections;
1436 for (
auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsText) {
1437 if (
G.findSectionByName(ObjCRuntimeSectionName)) {
1438 ++NumRuntimeSections;
1439 NeedTextSegment =
true;
1444 if (NumRuntimeSections == 0)
1449 ++NumRuntimeSections;
1455 auto &Sec =
G.createSection(ObjCRuntimeObjectSectionName,
1456 MemProt::Read | MemProt::Write);
1457 G.createMutableContentBlock(Sec, MachOSize,
ExecutorAddr(), 16, 0,
true);
1462Error MachOPlatform::MachOPlatformPlugin::populateObjCRuntimeObject(
1465 auto *ObjCRuntimeObjectSec =
1466 G.findSectionByName(ObjCRuntimeObjectSectionName);
1468 if (!ObjCRuntimeObjectSec)
1471 switch (
G.getTargetTriple().getArch()) {
1477 return make_error<StringError>(
"Unrecognized MachO arch in triple " +
1478 G.getTargetTriple().str(),
1482 auto &SecBlock = **ObjCRuntimeObjectSec->blocks().begin();
1489 std::vector<SecDesc> TextSections, DataSections;
1495 memcpy(SD.Sec.segname, FQName.
data(), 6);
1496 SD.Sec.addr = SR.getStart() - SecBlock.getAddress();
1497 SD.Sec.size = SR.getSize();
1503 DataSections.push_back({});
1504 auto &SD = DataSections.back();
1505 memset(&SD.Sec, 0,
sizeof(SD.Sec));
1506 memcpy(SD.Sec.sectname,
"__objc_imageinfo", 16);
1507 strcpy(SD.Sec.segname,
"__DATA");
1509 SD.AddFixups = [&](
size_t RecordOffset) {
1510 auto PointerEdge = getPointerEdgeKind(
G);
1514 for (
auto *
Sym :
G.external_symbols())
1515 if (
Sym->getName() == ObjCImageInfoSymbolName) {
1516 ObjCImageInfoSym =
Sym;
1519 if (!ObjCImageInfoSym)
1520 for (
auto *
Sym :
G.absolute_symbols())
1521 if (
Sym->getName() == ObjCImageInfoSymbolName) {
1522 ObjCImageInfoSym =
Sym;
1525 if (!ObjCImageInfoSym)
1526 for (
auto *
Sym :
G.defined_symbols())
1527 if (
Sym->hasName() &&
Sym->getName() == ObjCImageInfoSymbolName) {
1528 ObjCImageInfoSym =
Sym;
1529 std::optional<uint32_t>
Flags;
1531 std::lock_guard<std::mutex> Lock(PluginMutex);
1533 if (It != ObjCImageInfos.end()) {
1534 It->second.Finalized =
true;
1535 Flags = It->second.Flags;
1542 auto Content =
Sym->getBlock().getMutableContent(
G);
1544 "__objc_image_info size should have been verified already");
1549 if (!ObjCImageInfoSym)
1551 &
G.addExternalSymbol(ObjCImageInfoSymbolName, 8,
false);
1553 SecBlock.addEdge(PointerEdge,
1554 RecordOffset + ((
char *)&SD.Sec.addr - (
char *)&SD.Sec),
1555 *ObjCImageInfoSym, -SecBlock.getAddress().getValue());
1559 for (
auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsData) {
1560 if (
auto *GraphSec =
G.findSectionByName(ObjCRuntimeSectionName)) {
1561 DataSections.push_back({});
1562 AddSection(DataSections.back(), *GraphSec);
1566 for (
auto ObjCRuntimeSectionName : ObjCRuntimeObjectSectionsText) {
1567 if (
auto *GraphSec =
G.findSectionByName(ObjCRuntimeSectionName)) {
1568 TextSections.push_back({});
1569 AddSection(TextSections.back(), *GraphSec);
1573 assert(ObjCRuntimeObjectSec->blocks_size() == 1 &&
1574 "Unexpected number of blocks in runtime sections object");
1580 switch (
G.getTargetTriple().getArch()) {
1594 Hdr.
ncmds = 1 + !TextSections.empty();
1601 auto SecContent = SecBlock.getAlreadyMutableContent();
1602 char *
P = SecContent.data();
1603 auto WriteMachOStruct = [&](
auto S) {
1606 memcpy(
P, &S,
sizeof(S));
1610 auto WriteSegment = [&](
StringRef Name, std::vector<SecDesc> &Secs) {
1612 memset(&SegLC, 0,
sizeof(SegLC));
1614 SegLC.
cmd = MachO::LC_SEGMENT_64;
1617 SegLC.
nsects = Secs.size();
1618 WriteMachOStruct(SegLC);
1619 for (
auto &SD : Secs) {
1621 SD.AddFixups(
P - SecContent.data());
1622 WriteMachOStruct(SD.Sec);
1626 WriteMachOStruct(Hdr);
1627 if (!TextSections.empty())
1628 WriteSegment(
"__TEXT", TextSections);
1629 if (!DataSections.empty())
1630 WriteSegment(
"__DATA", DataSections);
1632 assert(
P == SecContent.end() &&
"Underflow writing ObjC runtime object");
1636Error MachOPlatform::MachOPlatformPlugin::prepareSymbolTableRegistration(
1642 MemProt::Read | MemProt::Exec);
1646 for (
auto *
Sym : CStringSec->symbols()) {
1659 for (
auto *
Sym :
G.defined_symbols())
1661 for (
auto *
Sym :
G.absolute_symbols())
1664 for (
auto *
Sym : SymsToProcess) {
1665 if (!
Sym->hasName())
1668 auto I = ExistingStrings.
find(
Sym->getName());
1669 if (
I == ExistingStrings.
end()) {
1670 auto &NameBlock =
G.createMutableContentBlock(
1673 auto &SymbolNameSym =
G.addAnonymousSymbol(
1674 NameBlock, 0, NameBlock.getSize(),
false,
true);
1675 JITSymTabInfo.push_back({
Sym, &SymbolNameSym});
1677 JITSymTabInfo.push_back({
Sym,
I->second});
1684Error MachOPlatform::MachOPlatformPlugin::addSymbolTableRegistration(
1686 JITSymTabVector &JITSymTabInfo,
bool InBootstrapPhase) {
1690 std::lock_guard<std::mutex> Lock(MP.PlatformMutex);
1692 assert(
I != MP.JITDylibToHeaderAddr.end() &&
"No header registered for JD");
1693 assert(
I->second &&
"Null header registered for JD");
1694 HeaderAddr =
I->second;
1697 SymbolTableVector LocalSymTab;
1698 auto &SymTab =
LLVM_LIKELY(!InBootstrapPhase) ? LocalSymTab
1699 : MP.Bootstrap.load()->SymTab;
1700 for (
auto &[OriginalSymbol, NameSym] : JITSymTabInfo)
1701 SymTab.push_back({NameSym->getAddress(), OriginalSymbol->getAddress(),
1702 flagsForSymbol(*OriginalSymbol)});
1711 : MP.Bootstrap.load()->DeferredAAs;
1712 allocActions.push_back(
1713 {
cantFail(WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
1714 MP.RegisterObjectSymbolTable.Addr, HeaderAddr, SymTab)),
1715 cantFail(WrapperFunctionCall::Create<SPSRegisterSymbolsArgs>(
1716 MP.DeregisterObjectSymbolTable.Addr, HeaderAddr, SymTab))});
1721template <
typename MachOTraits>
1731 B.Header.cputype = HdrInfo.CPUType;
1732 B.Header.cpusubtype = HdrInfo.CPUSubType;
1735 B.template addLoadCommand<MachO::LC_ID_DYLIB>(
1737 Opts.
IDDylib->CurrentVersion, Opts.
IDDylib->CompatibilityVersion);
1739 B.template addLoadCommand<MachO::LC_ID_DYLIB>(JD.
getName(), 0, 0, 0);
1742 B.template addLoadCommand<MachO::LC_BUILD_VERSION>(
1743 BV.Platform, BV.MinOS, BV.SDK,
static_cast<uint32_t>(0));
1745 B.template addLoadCommand<MachO::LC_LOAD_DYLIB>(
1746 D.Name,
D.Timestamp,
D.CurrentVersion,
D.CompatibilityVersion);
1748 B.template addLoadCommand<MachO::LC_RPATH>(
P);
1750 auto HeaderContent =
G.allocateBuffer(
B.layout());
1751 B.write(HeaderContent);
1753 return G.createContentBlock(HeaderSection, HeaderContent,
ExecutorAddr(), 8,
1761 createHeaderInterface(MOP,
std::
move(HeaderStartSymbol))),
1762 MOP(MOP), Opts(
std::
move(Opts)) {}
1765 std::unique_ptr<MaterializationResponsibility> R) {
1766 auto G = createPlatformGraph(
MOP,
"<MachOHeaderMU>");
1767 addMachOHeader(R->getTargetJITDylib(), *
G, R->getInitializerSymbol());
1774void SimpleMachOHeaderMU::addMachOHeader(
1777 auto &HeaderSection =
G.createSection(
"__header",
MemProt::Read);
1781 G.addDefinedSymbol(HeaderBlock, 0, *InitializerSymbol, HeaderBlock.getSize(),
1784 for (
auto &HS : AdditionalHeaderSymbols)
1785 G.addDefinedSymbol(HeaderBlock, HS.Offset, HS.Name, HeaderBlock.getSize(),
1796 return ::createHeaderBlock<MachO64LE>(
MOP,
Opts, JD,
G, HeaderSection);
1807 for (
auto &HS : AdditionalHeaderSymbols)
1816 switch (TT.getArch()) {
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
#define LLVM_UNLIKELY(EXPR)
#define LLVM_LIKELY(EXPR)
static std::optional< ConstantRange > getRange(Value *V, const InstrInfoQuery &IIQ)
Helper method to get range from metadata or attribute.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
iterator find(const_arg_type_t< KeyT > Val)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
void reserve(size_type NumEntries)
Grow the densemap so that it can contain at least NumEntries items before resizing again.
Implements a dense probed hash-table based set.
Helper for Errors used as out-parameters.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
constexpr size_t size() const
size - Get the string size.
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Triple - Helper class for working with autoconf configuration names.
ArchType getArch() const
Get the parsed architecture type of this triple.
const std::string & str() const
std::pair< iterator, bool > insert(const ValueT &V)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
An Addressable with content and edges.
const std::string & getName() const
Get the name for this JITLinkDylib.
Represents a section address range via a pair of Block pointers to the first and last Blocks in the s...
Represents an object file section.
An ExecutionSession represents a running JIT program.
ExecutorProcessControl & getExecutorProcessControl()
Get the ExecutorProcessControl object associated with this ExecutionSession.
const Triple & getTargetTriple() const
Return the triple for the executor.
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
SymbolStringPtr intern(StringRef SymName)
Add a symbol name to the SymbolStringPool and return a pointer to it.
static JITDispatchHandlerFunction wrapAsyncWithSPS(HandlerT &&H)
Wrap a handler that takes concrete argument types (and a sender for a concrete return type) to produc...
void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder, SymbolLookupSet Symbols, SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete, RegisterDependenciesFunction RegisterDependencies)
Search the given JITDylibs for the given symbols.
Error registerJITDispatchHandlers(JITDylib &JD, JITDispatchHandlerAssociationMap WFs)
For each tag symbol name, associate the corresponding AsyncHandlerWrapperFunction with the address of...
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
Represents an address in the executor process.
Represents a JIT'd dynamic library.
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
GeneratorT & addGenerator(std::unique_ptr< GeneratorT > DefGenerator)
Adds a definition generator to this JITDylib and returns a referenece to it.
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
Error defineMaterializing(SymbolFlagsMap SymbolFlags)
Attempt to claim responsibility for new definitions.
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization pseudo-symbol, if any.
JITDylib & getTargetJITDylib() const
Returns the target JITDylib that these symbols are being materialized into.
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
virtual StringRef getName() const =0
Return the name of this materialization unit.
virtual void materialize(std::unique_ptr< MaterializationResponsibility > R)=0
Implementations of this method should materialize all symbols in the materialzation unit,...
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization symbol for this MaterializationUnit (if any).
An ObjectLayer implementation built on JITLink.
ObjectLinkingLayer & addPlugin(std::shared_ptr< Plugin > P)
Add a plugin.
void emit(std::unique_ptr< MaterializationResponsibility > R, std::unique_ptr< MemoryBuffer > O) override
Emit an object file.
API to remove / transfer ownership of JIT resources.
JITDylib & getJITDylib() const
Return the JITDylib targeted by this tracker.
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Load(ObjectLayer &L, const char *FileName, GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibraryDefinitionGenerator from the given path.
A set of symbols to look up, each associated with a SymbolLookupFlags value.
Pointer to a pooled string representing a symbol name.
A utility class for serializing to a blob from a variadic list.
SPS tag type for expecteds, which are either a T or a string representing an error.
SPS tag type for optionals.
Output char buffer with overflow check.
SPS tag type for sequences.
static size_t size(const MachOPlatform::MachOExecutorSymbolFlags &SF)
static bool deserialize(SPSInputBuffer &IB, MachOPlatform::MachOExecutorSymbolFlags &SF)
static bool serialize(SPSOutputBuffer &OB, const MachOPlatform::MachOExecutorSymbolFlags &SF)
static bool serialize(SPSOutputBuffer &OB, const MachOPlatform::MachOJITDylibDepInfo &DDI)
static size_t size(const MachOPlatform::MachOJITDylibDepInfo &DDI)
static bool deserialize(SPSInputBuffer &IB, MachOPlatform::MachOJITDylibDepInfo &DDI)
Specialize to describe how to serialize/deserialize to/from the given concrete type.
static Expected< WrapperFunctionCall > Create(ExecutorAddr FnAddr, const ArgTs &...Args)
Create a WrapperFunctionCall using the given SPS serializer to serialize the arguments.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ S_REGULAR
S_REGULAR - Regular section.
void swapStruct(fat_header &mh)
constexpr uint64_t PointerSize
aarch64 pointer size.
@ Pointer64
A plain 64-bit pointer value relocation.
@ RequestTLVPAndTransformToPCRel32TLVPLoadREXRelaxable
A TLVP entry getter/constructor, transformed to Delta32ToTLVPLoadREXRelaxable.
@ Pointer64
A plain 64-bit pointer value relocation.
const char * getGenericEdgeKindName(Edge::Kind K)
Returns the string name of the given generic edge kind, or "unknown" otherwise.
constexpr llvm::endianness Endianness
The endianness of all multi-byte encoded values in MessagePack.
SPSTuple< SPSExecutorAddr, SPSExecutorAddr > SPSExecutorAddrRange
std::vector< AllocActionCallPair > AllocActions
A vector of allocation actions to be run for this allocation.
StringRef MachOSwift5EntrySectionName
StringRef MachOThreadBSSSectionName
StringRef MachOThreadVarsSectionName
JITDylibSearchOrder makeJITDylibSearchOrder(ArrayRef< JITDylib * > JDs, JITDylibLookupFlags Flags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Convenience function for creating a search order from an ArrayRef of JITDylib*, all with the same fla...
StringRef MachOCompactUnwindInfoSectionName
std::unique_ptr< ReExportsMaterializationUnit > symbolAliases(SymbolAliasMap Aliases)
Create a ReExportsMaterializationUnit with the given aliases.
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
StringRef MachOSwift5ProtosSectionName
StringRef MachOEHFrameSectionName
StringRef MachOModInitFuncSectionName
StringRef MachOInitSectionNames[19]
StringRef MachOObjCConstSectionName
StringRef MachODataDataSectionName
StringRef MachOSwift5ProtoSectionName
static void addAliases(ExecutionSession &ES, SymbolAliasMap &Aliases, ArrayRef< std::pair< const char *, const char * > > AL)
StringRef MachOObjCCatListSectionName
StringRef MachOObjCClassRefsSectionName
StringRef MachOObjCDataSectionName
StringRef MachOObjCClassNameSectionName
StringRef MachOObjCMethNameSectionName
StringRef MachOObjCClassListSectionName
StringRef MachOObjCSelRefsSectionName
StringRef MachOSwift5FieldMetadataSectionName
StringRef MachOCStringSectionName
StringRef MachOObjCMethTypeSectionName
StringRef MachOSwift5TypesSectionName
jitlink::Block & createHeaderBlock(MachOPlatform &MOP, const MachOPlatform::HeaderOptions &Opts, JITDylib &JD, jitlink::LinkGraph &G, jitlink::Section &HeaderSection)
StringRef MachOObjCImageInfoSectionName
MachOHeaderInfo getMachOHeaderInfoFromTriple(const Triple &TT)
RegisterDependenciesFunction NoDependenciesToRegister
This can be used as the value for a RegisterDependenciesFunction if there are no dependants to regist...
StringRef MachOThreadDataSectionName
StringRef MachODataCommonSectionName
StringRef MachOSwift5TypeRefSectionName
value_type byte_swap(value_type value, endianness endian)
uint32_t read32(const void *P, endianness E)
void write32(void *P, uint32_t V, endianness E)
This is an optimization pass for GlobalISel generic memory operations.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
void sort(IteratorTy Start, IteratorTy End)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
OutputIt copy(R &&Range, OutputIt Out)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Implement std::hash so that hash_code can be used in STL containers.
An LinkGraph pass configuration, consisting of a list of pre-prune, post-prune, and post-fixup passes...
Represents an address range in the exceutor process.