1 //===------ MachOPlatform.cpp - Utilities for executing MachO in Orc ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
10 
11 #include "llvm/BinaryFormat/MachO.h"
12 #include "llvm/ExecutionEngine/Orc/DebugUtils.h"
13 #include "llvm/Support/BinaryByteStream.h"
14 #include "llvm/Support/Debug.h"
15 
16 #define DEBUG_TYPE "orc"
17 
18 namespace {
19 
20 struct objc_class;
21 struct objc_image_info;
22 struct objc_object;
23 struct objc_selector;
24 
25 using Class = objc_class *;
26 using id = objc_object *;
27 using SEL = objc_selector *;
28 
29 using ObjCMsgSendTy = id (*)(id, SEL, ...);
30 using ObjCReadClassPairTy = Class (*)(Class, const objc_image_info *);
31 using SelRegisterNameTy = SEL (*)(const char *);
32 
33 enum class ObjCRegistrationAPI { Uninitialized, Unavailable, Initialized };
34 
35 ObjCRegistrationAPI ObjCRegistrationAPIState =
36     ObjCRegistrationAPI::Uninitialized;
37 ObjCMsgSendTy objc_msgSend = nullptr;
38 ObjCReadClassPairTy objc_readClassPair = nullptr;
39 SelRegisterNameTy sel_registerName = nullptr;
40 
41 } // end anonymous namespace
42 
43 namespace llvm {
44 namespace orc {
45 
46 template <typename FnTy>
47 static Error setUpObjCRegAPIFunc(FnTy &Target, sys::DynamicLibrary &LibObjC,
48                                  const char *Name) {
49   if (void *Addr = LibObjC.getAddressOfSymbol(Name))
50     Target = reinterpret_cast<FnTy>(Addr);
51   else
52     return make_error<StringError>(
53         (Twine("Could not find address for ") + Name).str(),
54         inconvertibleErrorCode());
55   return Error::success();
56 }
57 
58 Error enableObjCRegistration(const char *PathToLibObjC) {
59   // If we've already tried to initialize then just bail out.
60   if (ObjCRegistrationAPIState != ObjCRegistrationAPI::Uninitialized)
61     return Error::success();
62 
63   ObjCRegistrationAPIState = ObjCRegistrationAPI::Unavailable;
64 
65   std::string ErrMsg;
66   auto LibObjC =
67       sys::DynamicLibrary::getPermanentLibrary(PathToLibObjC, &ErrMsg);
68 
69   if (!LibObjC.isValid())
70     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
71 
72   if (auto Err = setUpObjCRegAPIFunc(objc_msgSend, LibObjC, "objc_msgSend"))
73     return Err;
74   if (auto Err = setUpObjCRegAPIFunc(objc_readClassPair, LibObjC,
75                                      "objc_readClassPair"))
76     return Err;
77   if (auto Err =
78           setUpObjCRegAPIFunc(sel_registerName, LibObjC, "sel_registerName"))
79     return Err;
80 
81   ObjCRegistrationAPIState = ObjCRegistrationAPI::Initialized;
82   return Error::success();
83 }
84 
85 bool objCRegistrationEnabled() {
86   return ObjCRegistrationAPIState == ObjCRegistrationAPI::Initialized;
87 }
88 
89 void MachOJITDylibInitializers::runModInits() const {
90   for (const auto &ModInit : ModInitSections) {
91     for (uint64_t I = 0; I != ModInit.NumPtrs; ++I) {
92       auto *InitializerAddr = jitTargetAddressToPointer<uintptr_t *>(
93           ModInit.Address + (I * sizeof(uintptr_t)));
94       auto *Initializer =
95           jitTargetAddressToFunction<void (*)()>(*InitializerAddr);
96       Initializer();
97     }
98   }
99 }
100 
101 void MachOJITDylibInitializers::registerObjCSelectors() const {
102   assert(objCRegistrationEnabled() && "ObjC registration not enabled.");
103 
104   for (const auto &ObjCSelRefs : ObjCSelRefsSections) {
105     for (uint64_t I = 0; I != ObjCSelRefs.NumPtrs; ++I) {
106       auto SelEntryAddr = ObjCSelRefs.Address + (I * sizeof(uintptr_t));
107       const auto *SelName =
108           *jitTargetAddressToPointer<const char **>(SelEntryAddr);
109       auto Sel = sel_registerName(SelName);
110       *jitTargetAddressToPointer<SEL *>(SelEntryAddr) = Sel;
111     }
112   }
113 }
114 
115 Error MachOJITDylibInitializers::registerObjCClasses() const {
116   assert(objCRegistrationEnabled() && "ObjC registration not enabled.");
117 
118   struct ObjCClassCompiled {
119     void *Metaclass;
120     void *Parent;
121     void *Cache1;
122     void *Cache2;
123     void *Data;
124   };
125 
126   auto *ImageInfo =
127       jitTargetAddressToPointer<const objc_image_info *>(ObjCImageInfoAddr);
128   auto ClassSelector = sel_registerName("class");
129 
130   for (const auto &ObjCClassList : ObjCClassListSections) {
131     for (uint64_t I = 0; I != ObjCClassList.NumPtrs; ++I) {
132       auto ClassPtrAddr = ObjCClassList.Address + (I * sizeof(uintptr_t));
133       auto Cls = *jitTargetAddressToPointer<Class *>(ClassPtrAddr);
134       auto *ClassCompiled =
135           *jitTargetAddressToPointer<ObjCClassCompiled **>(ClassPtrAddr);
136       objc_msgSend(reinterpret_cast<id>(ClassCompiled->Parent), ClassSelector);
137       auto Registered = objc_readClassPair(Cls, ImageInfo);
138 
139       // FIXME: Improve diagnostic by reporting the failed class's name.
140       if (Registered != Cls)
141         return make_error<StringError>("Unable to register Objective-C class",
142                                        inconvertibleErrorCode());
143     }
144   }
145   return Error::success();
146 }
147 
148 MachOPlatform::MachOPlatform(
149     ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
150     std::unique_ptr<MemoryBuffer> StandardSymbolsObject)
151     : ES(ES), ObjLinkingLayer(ObjLinkingLayer),
152       StandardSymbolsObject(std::move(StandardSymbolsObject)) {
153   ObjLinkingLayer.addPlugin(std::make_unique<InitScraperPlugin>(*this));
154 }
155 
156 Error MachOPlatform::setupJITDylib(JITDylib &JD) {
157   auto ObjBuffer = MemoryBuffer::getMemBuffer(
158       StandardSymbolsObject->getMemBufferRef(), false);
159   return ObjLinkingLayer.add(JD, std::move(ObjBuffer));
160 }
161 
162 Error MachOPlatform::notifyAdding(JITDylib &JD, const MaterializationUnit &MU) {
163   const auto &InitSym = MU.getInitializerSymbol();
164   if (!InitSym)
165     return Error::success();
166 
167   RegisteredInitSymbols[&JD].add(InitSym);
168   LLVM_DEBUG({
169     dbgs() << "MachOPlatform: Registered init symbol " << *InitSym << " for MU "
170            << MU.getName() << "\n";
171   });
172   return Error::success();
173 }
174 
175 Error MachOPlatform::notifyRemoving(JITDylib &JD, VModuleKey K) {
176   llvm_unreachable("Not supported yet");
177 }
178 
179 Expected<MachOPlatform::InitializerSequence>
180 MachOPlatform::getInitializerSequence(JITDylib &JD) {
181 
182   LLVM_DEBUG({
183     dbgs() << "MachOPlatform: Building initializer sequence for "
184            << JD.getName() << "\n";
185   });
186 
187   std::vector<JITDylib *> DFSLinkOrder;
188 
189   while (true) {
190 
191     DenseMap<JITDylib *, SymbolLookupSet> NewInitSymbols;
192 
193     ES.runSessionLocked([&]() {
194       DFSLinkOrder = getDFSLinkOrder(JD);
195 
196       for (auto *InitJD : DFSLinkOrder) {
197         auto RISItr = RegisteredInitSymbols.find(InitJD);
198         if (RISItr != RegisteredInitSymbols.end()) {
199           NewInitSymbols[InitJD] = std::move(RISItr->second);
200           RegisteredInitSymbols.erase(RISItr);
201         }
202       }
203     });
204 
205     if (NewInitSymbols.empty())
206       break;
207 
208     LLVM_DEBUG({
209       dbgs() << "MachOPlatform: Issuing lookups for new init symbols: "
210                 "(lookup may require multiple rounds)\n";
211       for (auto &KV : NewInitSymbols)
212         dbgs() << "  \"" << KV.first->getName() << "\": " << KV.second << "\n";
213     });
214 
215     // Outside the lock, issue the lookup.
216     if (auto R = lookupInitSymbols(JD.getExecutionSession(), NewInitSymbols))
217       ; // Nothing to do in the success case.
218     else
219       return R.takeError();
220   }
221 
222   LLVM_DEBUG({
223     dbgs() << "MachOPlatform: Init symbol lookup complete, building init "
224               "sequence\n";
225   });
226 
227   // Lock again to collect the initializers.
228   InitializerSequence FullInitSeq;
229   {
230     std::lock_guard<std::mutex> Lock(InitSeqsMutex);
231     for (auto *InitJD : reverse(DFSLinkOrder)) {
232       LLVM_DEBUG({
233         dbgs() << "MachOPlatform: Appending inits for \"" << InitJD->getName()
234                << "\" to sequence\n";
235       });
236       auto ISItr = InitSeqs.find(InitJD);
237       if (ISItr != InitSeqs.end()) {
238         FullInitSeq.emplace_back(InitJD, std::move(ISItr->second));
239         InitSeqs.erase(ISItr);
240       }
241     }
242   }
243 
244   return FullInitSeq;
245 }
246 
247 Expected<MachOPlatform::DeinitializerSequence>
248 MachOPlatform::getDeinitializerSequence(JITDylib &JD) {
249   std::vector<JITDylib *> DFSLinkOrder = getDFSLinkOrder(JD);
250 
251   DeinitializerSequence FullDeinitSeq;
252   {
253     std::lock_guard<std::mutex> Lock(InitSeqsMutex);
254     for (auto *DeinitJD : DFSLinkOrder) {
255       FullDeinitSeq.emplace_back(DeinitJD, MachOJITDylibDeinitializers());
256     }
257   }
258 
259   return FullDeinitSeq;
260 }
261 
262 std::vector<JITDylib *> MachOPlatform::getDFSLinkOrder(JITDylib &JD) {
263   std::vector<JITDylib *> Result, WorkStack({&JD});
264   DenseSet<JITDylib *> Visited;
265 
266   while (!WorkStack.empty()) {
267     auto *NextJD = WorkStack.back();
268     WorkStack.pop_back();
269     if (Visited.count(NextJD))
270       continue;
271     Visited.insert(NextJD);
272     Result.push_back(NextJD);
273     NextJD->withSearchOrderDo([&](const JITDylibSearchOrder &SO) {
274       for (auto &KV : SO)
275         WorkStack.push_back(KV.first);
276     });
277   }
278 
279   return Result;
280 }
281 
282 void MachOPlatform::registerInitInfo(
283     JITDylib &JD, JITTargetAddress ObjCImageInfoAddr,
284     MachOJITDylibInitializers::SectionExtent ModInits,
285     MachOJITDylibInitializers::SectionExtent ObjCSelRefs,
286     MachOJITDylibInitializers::SectionExtent ObjCClassList) {
287   std::lock_guard<std::mutex> Lock(InitSeqsMutex);
288 
289   auto &InitSeq = InitSeqs[&JD];
290 
291   InitSeq.setObjCImageInfoAddr(ObjCImageInfoAddr);
292 
293   if (ModInits.Address)
294     InitSeq.addModInitsSection(std::move(ModInits));
295 
296   if (ObjCSelRefs.Address)
297     InitSeq.addObjCSelRefsSection(std::move(ObjCSelRefs));
298 
299   if (ObjCClassList.Address)
300     InitSeq.addObjCClassListSection(std::move(ObjCClassList));
301 }
302 
303 static Expected<MachOJITDylibInitializers::SectionExtent>
304 getSectionExtent(jitlink::LinkGraph &G, StringRef SectionName) {
305   auto *Sec = G.findSectionByName(SectionName);
306   if (!Sec)
307     return MachOJITDylibInitializers::SectionExtent();
308   jitlink::SectionRange R(*Sec);
309   if (R.getSize() % G.getPointerSize() != 0)
310     return make_error<StringError>(SectionName + " section size is not a "
311                                                  "multiple of the pointer size",
312                                    inconvertibleErrorCode());
313   return MachOJITDylibInitializers::SectionExtent(
314       R.getStart(), R.getSize() / G.getPointerSize());
315 }
316 
317 void MachOPlatform::InitScraperPlugin::modifyPassConfig(
318     MaterializationResponsibility &MR, const Triple &TT,
319     jitlink::PassConfiguration &Config) {
320 
321   Config.PrePrunePasses.push_back([this, &MR](jitlink::LinkGraph &G) -> Error {
322     JITLinkSymbolVector InitSectionSymbols;
323     preserveInitSectionIfPresent(InitSectionSymbols, G, "__mod_init_func");
324     preserveInitSectionIfPresent(InitSectionSymbols, G, "__objc_selrefs");
325     preserveInitSectionIfPresent(InitSectionSymbols, G, "__objc_classlist");
326 
327     if (!InitSymbolDeps.empty()) {
328       std::lock_guard<std::mutex> Lock(InitScraperMutex);
329       InitSymbolDeps[&MR] = std::move(InitSectionSymbols);
330     }
331 
332     if (auto Err = processObjCImageInfo(G, MR))
333       return Err;
334 
335     return Error::success();
336   });
337 
338   Config.PostFixupPasses.push_back([this, &JD = MR.getTargetJITDylib()](
339                                        jitlink::LinkGraph &G) -> Error {
340     MachOJITDylibInitializers::SectionExtent ModInits, ObjCSelRefs,
341         ObjCClassList;
342 
343     JITTargetAddress ObjCImageInfoAddr = 0;
344     if (auto *ObjCImageInfoSec = G.findSectionByName("__objc_image_info")) {
345       if (auto Addr = jitlink::SectionRange(*ObjCImageInfoSec).getStart()) {
346         ObjCImageInfoAddr = Addr;
347         dbgs() << "Recorded __objc_imageinfo @ " << formatv("{0:x16}", Addr);
348       }
349     }
350 
351     // Record __mod_init_func.
352     if (auto ModInitsOrErr = getSectionExtent(G, "__mod_init_func"))
353       ModInits = std::move(*ModInitsOrErr);
354     else
355       return ModInitsOrErr.takeError();
356 
357     // Record __objc_selrefs.
358     if (auto ObjCSelRefsOrErr = getSectionExtent(G, "__objc_selrefs"))
359       ObjCSelRefs = std::move(*ObjCSelRefsOrErr);
360     else
361       return ObjCSelRefsOrErr.takeError();
362 
363     // Record __objc_classlist.
364     if (auto ObjCClassListOrErr = getSectionExtent(G, "__objc_classlist"))
365       ObjCClassList = std::move(*ObjCClassListOrErr);
366     else
367       return ObjCClassListOrErr.takeError();
368 
369     // Dump the scraped inits.
370     LLVM_DEBUG({
371       dbgs() << "MachOPlatform: Scraped " << G.getName() << " init sections:\n";
372       dbgs() << "  __objc_selrefs: ";
373       if (ObjCSelRefs.NumPtrs)
374         dbgs() << ObjCSelRefs.NumPtrs << " pointer(s) at "
375                << formatv("{0:x16}", ObjCSelRefs.Address) << "\n";
376       else
377         dbgs() << "none\n";
378 
379       dbgs() << "  __objc_classlist: ";
380       if (ObjCClassList.NumPtrs)
381         dbgs() << ObjCClassList.NumPtrs << " pointer(s) at "
382                << formatv("{0:x16}", ObjCClassList.Address) << "\n";
383       else
384         dbgs() << "none\n";
385 
386       dbgs() << "  __mod_init_func: ";
387       if (ModInits.NumPtrs)
388         dbgs() << ModInits.NumPtrs << " pointer(s) at "
389                << formatv("{0:x16}", ModInits.Address) << "\n";
390       else
391         dbgs() << "none\n";
392     });
393 
394     MP.registerInitInfo(JD, ObjCImageInfoAddr, std::move(ModInits),
395                         std::move(ObjCSelRefs), std::move(ObjCClassList));
396 
397     return Error::success();
398   });
399 }
400 
401 ObjectLinkingLayer::Plugin::LocalDependenciesMap
402 MachOPlatform::InitScraperPlugin::getSyntheticSymbolLocalDependencies(
403     MaterializationResponsibility &MR) {
404   std::lock_guard<std::mutex> Lock(InitScraperMutex);
405   auto I = InitSymbolDeps.find(&MR);
406   if (I != InitSymbolDeps.end()) {
407     LocalDependenciesMap Result;
408     Result[MR.getInitializerSymbol()] = std::move(I->second);
409     InitSymbolDeps.erase(&MR);
410     return Result;
411   }
412   return LocalDependenciesMap();
413 }
414 
415 void MachOPlatform::InitScraperPlugin::preserveInitSectionIfPresent(
416     JITLinkSymbolVector &Symbols, jitlink::LinkGraph &G,
417     StringRef SectionName) {
418   if (auto *Sec = G.findSectionByName(SectionName)) {
419     auto SecBlocks = Sec->blocks();
420     if (!llvm::empty(SecBlocks))
421       Symbols.push_back(
422           &G.addAnonymousSymbol(**SecBlocks.begin(), 0, 0, false, true));
423   }
424 }
425 
426 Error MachOPlatform::InitScraperPlugin::processObjCImageInfo(
427     jitlink::LinkGraph &G, MaterializationResponsibility &MR) {
428 
429   // If there's an ObjC imagine info then either
430   //   (1) It's the first __objc_imageinfo we've seen in this JITDylib. In
431   //       this case we name and record it.
432   // OR
433   //   (2) We already have a recorded __objc_imageinfo for this JITDylib,
434   //       in which case we just verify it.
435   auto *ObjCImageInfo = G.findSectionByName("__objc_imageinfo");
436   if (!ObjCImageInfo)
437     return Error::success();
438 
439   auto ObjCImageInfoBlocks = ObjCImageInfo->blocks();
440 
441   // Check that the section is not empty if present.
442   if (llvm::empty(ObjCImageInfoBlocks))
443     return make_error<StringError>("Empty __objc_imageinfo section in " +
444                                        G.getName(),
445                                    inconvertibleErrorCode());
446 
447   // Check that there's only one block in the section.
448   if (std::next(ObjCImageInfoBlocks.begin()) != ObjCImageInfoBlocks.end())
449     return make_error<StringError>("Multiple blocks in __objc_imageinfo "
450                                    "section in " +
451                                        G.getName(),
452                                    inconvertibleErrorCode());
453 
454   // Check that the __objc_imageinfo section is unreferenced.
455   // FIXME: We could optimize this check if Symbols had a ref-count.
456   for (auto &Sec : G.sections()) {
457     if (&Sec != ObjCImageInfo)
458       for (auto *B : Sec.blocks())
459         for (auto &E : B->edges())
460           if (E.getTarget().isDefined() &&
461               &E.getTarget().getBlock().getSection() == ObjCImageInfo)
462             return make_error<StringError>("__objc_imageinfo is referenced "
463                                            "within file " +
464                                                G.getName(),
465                                            inconvertibleErrorCode());
466   }
467 
468   auto &ObjCImageInfoBlock = **ObjCImageInfoBlocks.begin();
469   auto *ObjCImageInfoData = ObjCImageInfoBlock.getContent().data();
470   auto Version = support::endian::read32(ObjCImageInfoData, G.getEndianness());
471   auto Flags =
472       support::endian::read32(ObjCImageInfoData + 4, G.getEndianness());
473 
474   // Lock the mutex while we verify / update the ObjCImageInfos map.
475   std::lock_guard<std::mutex> Lock(InitScraperMutex);
476 
477   auto ObjCImageInfoItr = ObjCImageInfos.find(&MR.getTargetJITDylib());
478   if (ObjCImageInfoItr != ObjCImageInfos.end()) {
479     // We've already registered an __objc_imageinfo section. Verify the
480     // content of this new section matches, then delete it.
481     if (ObjCImageInfoItr->second.first != Version)
482       return make_error<StringError>(
483           "ObjC version in " + G.getName() +
484               " does not match first registered version",
485           inconvertibleErrorCode());
486     if (ObjCImageInfoItr->second.second != Flags)
487       return make_error<StringError>("ObjC flags in " + G.getName() +
488                                          " do not match first registered flags",
489                                      inconvertibleErrorCode());
490 
491     // __objc_imageinfo is valid. Delete the block.
492     for (auto *S : ObjCImageInfo->symbols())
493       G.removeDefinedSymbol(*S);
494     G.removeBlock(ObjCImageInfoBlock);
495   } else {
496     // We haven't registered an __objc_imageinfo section yet. Register and
497     // move on. The section should already be marked no-dead-strip.
498     ObjCImageInfos[&MR.getTargetJITDylib()] = std::make_pair(Version, Flags);
499   }
500 
501   return Error::success();
502 }
503 
504 } // End namespace orc.
505 } // End namespace llvm.
506