LLVM 17.0.0git
MachOLinkGraphBuilder.cpp
Go to the documentation of this file.
1//=--------- MachOLinkGraphBuilder.cpp - MachO LinkGraph builder ----------===//
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// Generic MachO LinkGraph buliding code.
10//
11//===----------------------------------------------------------------------===//
12
14#include <optional>
15
16#define DEBUG_TYPE "jitlink"
17
18static const char *CommonSectionName = "__common";
19
20namespace llvm {
21namespace jitlink {
22
24
26
27 // We only operate on relocatable objects.
28 if (!Obj.isRelocatableObject())
29 return make_error<JITLinkError>("Object is not a relocatable MachO");
30
31 if (auto Err = createNormalizedSections())
32 return std::move(Err);
33
34 if (auto Err = createNormalizedSymbols())
35 return std::move(Err);
36
37 if (auto Err = graphifyRegularSymbols())
38 return std::move(Err);
39
40 if (auto Err = graphifySectionsWithCustomParsers())
41 return std::move(Err);
42
43 if (auto Err = addRelocations())
44 return std::move(Err);
45
46 return std::move(G);
47}
48
50 const object::MachOObjectFile &Obj, Triple TT,
52 : Obj(Obj),
53 G(std::make_unique<LinkGraph>(
54 std::string(Obj.getFileName()), std::move(TT), getPointerSize(Obj),
55 getEndianness(Obj), std::move(GetEdgeKindName))) {
56 auto &MachHeader = Obj.getHeader64();
57 SubsectionsViaSymbols = MachHeader.flags & MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
58}
59
62 assert(!CustomSectionParserFunctions.count(SectionName) &&
63 "Custom parser for this section already exists");
64 CustomSectionParserFunctions[SectionName] = std::move(Parser);
65}
66
68 if ((Desc & MachO::N_WEAK_DEF) || (Desc & MachO::N_WEAK_REF))
69 return Linkage::Weak;
70 return Linkage::Strong;
71}
72
74 if (Type & MachO::N_EXT) {
75 if ((Type & MachO::N_PEXT) || Name.startswith("l"))
76 return Scope::Hidden;
77 else
78 return Scope::Default;
79 }
80 return Scope::Local;
81}
82
84 return NSym.Desc & MachO::N_ALT_ENTRY;
85}
86
88 return (NSec.Flags & MachO::S_ATTR_DEBUG &&
89 strcmp(NSec.SegName, "__DWARF") == 0);
90}
91
93 switch (NSec.Flags & MachO::SECTION_TYPE) {
97 return true;
98 default:
99 return false;
100 }
101}
102
103unsigned
104MachOLinkGraphBuilder::getPointerSize(const object::MachOObjectFile &Obj) {
105 return Obj.is64Bit() ? 8 : 4;
106}
107
109MachOLinkGraphBuilder::getEndianness(const object::MachOObjectFile &Obj) {
111}
112
113Section &MachOLinkGraphBuilder::getCommonSection() {
114 if (!CommonSection)
115 CommonSection = &G->createSection(CommonSectionName,
117 return *CommonSection;
118}
119
120Error MachOLinkGraphBuilder::createNormalizedSections() {
121 // Build normalized sections. Verifies that section data is in-range (for
122 // sections with content) and that address ranges are non-overlapping.
123
124 LLVM_DEBUG(dbgs() << "Creating normalized sections...\n");
125
126 for (auto &SecRef : Obj.sections()) {
127 NormalizedSection NSec;
128 uint32_t DataOffset = 0;
129
130 auto SecIndex = Obj.getSectionIndex(SecRef.getRawDataRefImpl());
131
132 if (Obj.is64Bit()) {
133 const MachO::section_64 &Sec64 =
134 Obj.getSection64(SecRef.getRawDataRefImpl());
135
136 memcpy(&NSec.SectName, &Sec64.sectname, 16);
137 NSec.SectName[16] = '\0';
138 memcpy(&NSec.SegName, Sec64.segname, 16);
139 NSec.SegName[16] = '\0';
140
141 NSec.Address = orc::ExecutorAddr(Sec64.addr);
142 NSec.Size = Sec64.size;
143 NSec.Alignment = 1ULL << Sec64.align;
144 NSec.Flags = Sec64.flags;
145 DataOffset = Sec64.offset;
146 } else {
147 const MachO::section &Sec32 = Obj.getSection(SecRef.getRawDataRefImpl());
148
149 memcpy(&NSec.SectName, &Sec32.sectname, 16);
150 NSec.SectName[16] = '\0';
151 memcpy(&NSec.SegName, Sec32.segname, 16);
152 NSec.SegName[16] = '\0';
153
154 NSec.Address = orc::ExecutorAddr(Sec32.addr);
155 NSec.Size = Sec32.size;
156 NSec.Alignment = 1ULL << Sec32.align;
157 NSec.Flags = Sec32.flags;
158 DataOffset = Sec32.offset;
159 }
160
161 LLVM_DEBUG({
162 dbgs() << " " << NSec.SegName << "," << NSec.SectName << ": "
163 << formatv("{0:x16}", NSec.Address) << " -- "
164 << formatv("{0:x16}", NSec.Address + NSec.Size)
165 << ", align: " << NSec.Alignment << ", index: " << SecIndex
166 << "\n";
167 });
168
169 // Get the section data if any.
170 if (!isZeroFillSection(NSec)) {
171 if (DataOffset + NSec.Size > Obj.getData().size())
172 return make_error<JITLinkError>(
173 "Section data extends past end of file");
174
175 NSec.Data = Obj.getData().data() + DataOffset;
176 }
177
178 // Get prot flags.
179 // FIXME: Make sure this test is correct (it's probably missing cases
180 // as-is).
181 orc::MemProt Prot;
182 if (NSec.Flags & MachO::S_ATTR_PURE_INSTRUCTIONS)
184 else
186
187 auto FullyQualifiedName =
188 G->allocateContent(StringRef(NSec.SegName) + "," + NSec.SectName);
189 NSec.GraphSection = &G->createSection(
190 StringRef(FullyQualifiedName.data(), FullyQualifiedName.size()), Prot);
191
192 // TODO: Are there any other criteria for NoAlloc lifetime?
193 if (NSec.Flags & MachO::S_ATTR_DEBUG)
194 NSec.GraphSection->setMemLifetimePolicy(orc::MemLifetimePolicy::NoAlloc);
195
196 IndexToSection.insert(std::make_pair(SecIndex, std::move(NSec)));
197 }
198
199 std::vector<NormalizedSection *> Sections;
200 Sections.reserve(IndexToSection.size());
201 for (auto &KV : IndexToSection)
202 Sections.push_back(&KV.second);
203
204 // If we didn't end up creating any sections then bail out. The code below
205 // assumes that we have at least one section.
206 if (Sections.empty())
207 return Error::success();
208
209 llvm::sort(Sections,
210 [](const NormalizedSection *LHS, const NormalizedSection *RHS) {
211 assert(LHS && RHS && "Null section?");
212 if (LHS->Address != RHS->Address)
213 return LHS->Address < RHS->Address;
214 return LHS->Size < RHS->Size;
215 });
216
217 for (unsigned I = 0, E = Sections.size() - 1; I != E; ++I) {
218 auto &Cur = *Sections[I];
219 auto &Next = *Sections[I + 1];
220 if (Next.Address < Cur.Address + Cur.Size)
221 return make_error<JITLinkError>(
222 "Address range for section " +
223 formatv("\"{0}/{1}\" [ {2:x16} -- {3:x16} ] ", Cur.SegName,
224 Cur.SectName, Cur.Address, Cur.Address + Cur.Size) +
225 "overlaps section \"" + Next.SegName + "/" + Next.SectName + "\"" +
226 formatv("\"{0}/{1}\" [ {2:x16} -- {3:x16} ] ", Next.SegName,
227 Next.SectName, Next.Address, Next.Address + Next.Size));
228 }
229
230 return Error::success();
231}
232
233Error MachOLinkGraphBuilder::createNormalizedSymbols() {
234 LLVM_DEBUG(dbgs() << "Creating normalized symbols...\n");
235
236 for (auto &SymRef : Obj.symbols()) {
237
238 unsigned SymbolIndex = Obj.getSymbolIndex(SymRef.getRawDataRefImpl());
240 uint32_t NStrX;
241 uint8_t Type;
242 uint8_t Sect;
243 uint16_t Desc;
244
245 if (Obj.is64Bit()) {
246 const MachO::nlist_64 &NL64 =
247 Obj.getSymbol64TableEntry(SymRef.getRawDataRefImpl());
248 Value = NL64.n_value;
249 NStrX = NL64.n_strx;
250 Type = NL64.n_type;
251 Sect = NL64.n_sect;
252 Desc = NL64.n_desc;
253 } else {
254 const MachO::nlist &NL32 =
255 Obj.getSymbolTableEntry(SymRef.getRawDataRefImpl());
256 Value = NL32.n_value;
257 NStrX = NL32.n_strx;
258 Type = NL32.n_type;
259 Sect = NL32.n_sect;
260 Desc = NL32.n_desc;
261 }
262
263 // Skip stabs.
264 // FIXME: Are there other symbols we should be skipping?
265 if (Type & MachO::N_STAB)
266 continue;
267
268 std::optional<StringRef> Name;
269 if (NStrX) {
270 if (auto NameOrErr = SymRef.getName())
271 Name = *NameOrErr;
272 else
273 return NameOrErr.takeError();
274 } else if (Type & MachO::N_EXT)
275 return make_error<JITLinkError>("Symbol at index " +
276 formatv("{0}", SymbolIndex) +
277 " has no name (string table index 0), "
278 "but N_EXT bit is set");
279
280 LLVM_DEBUG({
281 dbgs() << " ";
282 if (!Name)
283 dbgs() << "<anonymous symbol>";
284 else
285 dbgs() << *Name;
286 dbgs() << ": value = " << formatv("{0:x16}", Value)
287 << ", type = " << formatv("{0:x2}", Type)
288 << ", desc = " << formatv("{0:x4}", Desc) << ", sect = ";
289 if (Sect)
290 dbgs() << static_cast<unsigned>(Sect - 1);
291 else
292 dbgs() << "none";
293 dbgs() << "\n";
294 });
295
296 // If this symbol has a section, verify that the addresses line up.
297 if (Sect != 0) {
298 auto NSec = findSectionByIndex(Sect - 1);
299 if (!NSec)
300 return NSec.takeError();
301
302 if (orc::ExecutorAddr(Value) < NSec->Address ||
303 orc::ExecutorAddr(Value) > NSec->Address + NSec->Size)
304 return make_error<JITLinkError>("Address " + formatv("{0:x}", Value) +
305 " for symbol " + *Name +
306 " does not fall within section");
307
308 if (!NSec->GraphSection) {
309 LLVM_DEBUG({
310 dbgs() << " Skipping: Symbol is in section " << NSec->SegName << "/"
311 << NSec->SectName
312 << " which has no associated graph section.\n";
313 });
314 continue;
315 }
316 }
317
318 IndexToSymbol[SymbolIndex] =
319 &createNormalizedSymbol(*Name, Value, Type, Sect, Desc,
320 getLinkage(Desc), getScope(*Name, Type));
321 }
322
323 return Error::success();
324}
325
326void MachOLinkGraphBuilder::addSectionStartSymAndBlock(
327 unsigned SecIndex, Section &GraphSec, orc::ExecutorAddr Address,
328 const char *Data, orc::ExecutorAddrDiff Size, uint32_t Alignment,
329 bool IsLive) {
330 Block &B =
331 Data ? G->createContentBlock(GraphSec, ArrayRef<char>(Data, Size),
332 Address, Alignment, 0)
333 : G->createZeroFillBlock(GraphSec, Size, Address, Alignment, 0);
334 auto &Sym = G->addAnonymousSymbol(B, 0, Size, false, IsLive);
335 auto SecI = IndexToSection.find(SecIndex);
336 assert(SecI != IndexToSection.end() && "SecIndex invalid");
337 auto &NSec = SecI->second;
338 assert(!NSec.CanonicalSymbols.count(Sym.getAddress()) &&
339 "Anonymous block start symbol clashes with existing symbol address");
340 NSec.CanonicalSymbols[Sym.getAddress()] = &Sym;
341}
342
343Error MachOLinkGraphBuilder::graphifyRegularSymbols() {
344
345 LLVM_DEBUG(dbgs() << "Creating graph symbols...\n");
346
347 /// We only have 256 section indexes: Use a vector rather than a map.
348 std::vector<std::vector<NormalizedSymbol *>> SecIndexToSymbols;
349 SecIndexToSymbols.resize(256);
350
351 // Create commons, externs, and absolutes, and partition all other symbols by
352 // section.
353 for (auto &KV : IndexToSymbol) {
354 auto &NSym = *KV.second;
355
356 switch (NSym.Type & MachO::N_TYPE) {
357 case MachO::N_UNDF:
358 if (NSym.Value) {
359 if (!NSym.Name)
360 return make_error<JITLinkError>("Anonymous common symbol at index " +
361 Twine(KV.first));
362 NSym.GraphSymbol = &G->addDefinedSymbol(
363 G->createZeroFillBlock(getCommonSection(),
364 orc::ExecutorAddrDiff(NSym.Value),
365 orc::ExecutorAddr(),
366 1ull << MachO::GET_COMM_ALIGN(NSym.Desc), 0),
367 0, *NSym.Name, orc::ExecutorAddrDiff(NSym.Value), Linkage::Strong,
368 NSym.S, false, NSym.Desc & MachO::N_NO_DEAD_STRIP);
369 } else {
370 if (!NSym.Name)
371 return make_error<JITLinkError>("Anonymous external symbol at "
372 "index " +
373 Twine(KV.first));
374 NSym.GraphSymbol = &G->addExternalSymbol(
375 *NSym.Name, 0, (NSym.Desc & MachO::N_WEAK_REF) != 0);
376 }
377 break;
378 case MachO::N_ABS:
379 if (!NSym.Name)
380 return make_error<JITLinkError>("Anonymous absolute symbol at index " +
381 Twine(KV.first));
382 NSym.GraphSymbol = &G->addAbsoluteSymbol(
383 *NSym.Name, orc::ExecutorAddr(NSym.Value), 0, Linkage::Strong,
384 getScope(*NSym.Name, NSym.Type), NSym.Desc & MachO::N_NO_DEAD_STRIP);
385 break;
386 case MachO::N_SECT:
387 SecIndexToSymbols[NSym.Sect - 1].push_back(&NSym);
388 break;
389 case MachO::N_PBUD:
390 return make_error<JITLinkError>(
391 "Unupported N_PBUD symbol " +
392 (NSym.Name ? ("\"" + *NSym.Name + "\"") : Twine("<anon>")) +
393 " at index " + Twine(KV.first));
394 case MachO::N_INDR:
395 return make_error<JITLinkError>(
396 "Unupported N_INDR symbol " +
397 (NSym.Name ? ("\"" + *NSym.Name + "\"") : Twine("<anon>")) +
398 " at index " + Twine(KV.first));
399 default:
400 return make_error<JITLinkError>(
401 "Unrecognized symbol type " + Twine(NSym.Type & MachO::N_TYPE) +
402 " for symbol " +
403 (NSym.Name ? ("\"" + *NSym.Name + "\"") : Twine("<anon>")) +
404 " at index " + Twine(KV.first));
405 }
406 }
407
408 // Loop over sections performing regular graphification for those that
409 // don't have custom parsers.
410 for (auto &KV : IndexToSection) {
411 auto SecIndex = KV.first;
412 auto &NSec = KV.second;
413
414 if (!NSec.GraphSection) {
415 LLVM_DEBUG({
416 dbgs() << " " << NSec.SegName << "/" << NSec.SectName
417 << " has no graph section. Skipping.\n";
418 });
419 continue;
420 }
421
422 // Skip sections with custom parsers.
423 if (CustomSectionParserFunctions.count(NSec.GraphSection->getName())) {
424 LLVM_DEBUG({
425 dbgs() << " Skipping section " << NSec.GraphSection->getName()
426 << " as it has a custom parser.\n";
427 });
428 continue;
429 } else if ((NSec.Flags & MachO::SECTION_TYPE) ==
431 if (auto Err = graphifyCStringSection(
432 NSec, std::move(SecIndexToSymbols[SecIndex])))
433 return Err;
434 continue;
435 } else
436 LLVM_DEBUG({
437 dbgs() << " Graphifying regular section "
438 << NSec.GraphSection->getName() << "...\n";
439 });
440
441 bool SectionIsNoDeadStrip = NSec.Flags & MachO::S_ATTR_NO_DEAD_STRIP;
442 bool SectionIsText = NSec.Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
443
444 auto &SecNSymStack = SecIndexToSymbols[SecIndex];
445
446 // If this section is non-empty but there are no symbols covering it then
447 // create one block and anonymous symbol to cover the entire section.
448 if (SecNSymStack.empty()) {
449 if (NSec.Size > 0) {
450 LLVM_DEBUG({
451 dbgs() << " Section non-empty, but contains no symbols. "
452 "Creating anonymous block to cover "
453 << formatv("{0:x16}", NSec.Address) << " -- "
454 << formatv("{0:x16}", NSec.Address + NSec.Size) << "\n";
455 });
456 addSectionStartSymAndBlock(SecIndex, *NSec.GraphSection, NSec.Address,
457 NSec.Data, NSec.Size, NSec.Alignment,
458 SectionIsNoDeadStrip);
459 } else
460 LLVM_DEBUG({
461 dbgs() << " Section empty and contains no symbols. Skipping.\n";
462 });
463 continue;
464 }
465
466 // Sort the symbol stack in by address, alt-entry status, scope, and name.
467 // We sort in reverse order so that symbols will be visited in the right
468 // order when we pop off the stack below.
469 llvm::sort(SecNSymStack, [](const NormalizedSymbol *LHS,
470 const NormalizedSymbol *RHS) {
471 if (LHS->Value != RHS->Value)
472 return LHS->Value > RHS->Value;
474 return isAltEntry(*RHS);
475 if (LHS->S != RHS->S)
476 return static_cast<uint8_t>(LHS->S) < static_cast<uint8_t>(RHS->S);
477 return LHS->Name < RHS->Name;
478 });
479
480 // The first symbol in a section can not be an alt-entry symbol.
481 if (!SecNSymStack.empty() && isAltEntry(*SecNSymStack.back()))
482 return make_error<JITLinkError>(
483 "First symbol in " + NSec.GraphSection->getName() + " is alt-entry");
484
485 // If the section is non-empty but there is no symbol covering the start
486 // address then add an anonymous one.
487 if (orc::ExecutorAddr(SecNSymStack.back()->Value) != NSec.Address) {
488 auto AnonBlockSize =
489 orc::ExecutorAddr(SecNSymStack.back()->Value) - NSec.Address;
490 LLVM_DEBUG({
491 dbgs() << " Section start not covered by symbol. "
492 << "Creating anonymous block to cover [ " << NSec.Address
493 << " -- " << (NSec.Address + AnonBlockSize) << " ]\n";
494 });
495 addSectionStartSymAndBlock(SecIndex, *NSec.GraphSection, NSec.Address,
496 NSec.Data, AnonBlockSize, NSec.Alignment,
497 SectionIsNoDeadStrip);
498 }
499
500 // Visit section symbols in order by popping off the reverse-sorted stack,
501 // building graph symbols as we go.
502 //
503 // If MH_SUBSECTIONS_VIA_SYMBOLS is set we'll build a block for each
504 // alt-entry chain.
505 //
506 // If MH_SUBSECTIONS_VIA_SYMBOLS is not set then we'll just build one block
507 // for the whole section.
508 while (!SecNSymStack.empty()) {
509 SmallVector<NormalizedSymbol *, 8> BlockSyms;
510
511 // Get the symbols in this alt-entry chain, or the whole section (if
512 // !SubsectionsViaSymbols).
513 BlockSyms.push_back(SecNSymStack.back());
514 SecNSymStack.pop_back();
515 while (!SecNSymStack.empty() &&
516 (isAltEntry(*SecNSymStack.back()) ||
517 SecNSymStack.back()->Value == BlockSyms.back()->Value ||
518 !SubsectionsViaSymbols)) {
519 BlockSyms.push_back(SecNSymStack.back());
520 SecNSymStack.pop_back();
521 }
522
523 // BlockNSyms now contains the block symbols in reverse canonical order.
524 auto BlockStart = orc::ExecutorAddr(BlockSyms.front()->Value);
525 orc::ExecutorAddr BlockEnd =
526 SecNSymStack.empty() ? NSec.Address + NSec.Size
527 : orc::ExecutorAddr(SecNSymStack.back()->Value);
528 orc::ExecutorAddrDiff BlockOffset = BlockStart - NSec.Address;
529 orc::ExecutorAddrDiff BlockSize = BlockEnd - BlockStart;
530
531 LLVM_DEBUG({
532 dbgs() << " Creating block for " << formatv("{0:x16}", BlockStart)
533 << " -- " << formatv("{0:x16}", BlockEnd) << ": "
534 << NSec.GraphSection->getName() << " + "
535 << formatv("{0:x16}", BlockOffset) << " with "
536 << BlockSyms.size() << " symbol(s)...\n";
537 });
538
539 Block &B =
540 NSec.Data
541 ? G->createContentBlock(
542 *NSec.GraphSection,
543 ArrayRef<char>(NSec.Data + BlockOffset, BlockSize),
544 BlockStart, NSec.Alignment, BlockStart % NSec.Alignment)
545 : G->createZeroFillBlock(*NSec.GraphSection, BlockSize,
546 BlockStart, NSec.Alignment,
547 BlockStart % NSec.Alignment);
548
549 std::optional<orc::ExecutorAddr> LastCanonicalAddr;
550 auto SymEnd = BlockEnd;
551 while (!BlockSyms.empty()) {
552 auto &NSym = *BlockSyms.back();
553 BlockSyms.pop_back();
554
555 bool SymLive =
556 (NSym.Desc & MachO::N_NO_DEAD_STRIP) || SectionIsNoDeadStrip;
557
558 auto &Sym = createStandardGraphSymbol(
559 NSym, B, SymEnd - orc::ExecutorAddr(NSym.Value), SectionIsText,
560 SymLive, LastCanonicalAddr != orc::ExecutorAddr(NSym.Value));
561
562 if (LastCanonicalAddr != Sym.getAddress()) {
563 if (LastCanonicalAddr)
564 SymEnd = *LastCanonicalAddr;
565 LastCanonicalAddr = Sym.getAddress();
566 }
567 }
568 }
569 }
570
571 return Error::success();
572}
573
574Symbol &MachOLinkGraphBuilder::createStandardGraphSymbol(NormalizedSymbol &NSym,
575 Block &B, size_t Size,
576 bool IsText,
577 bool IsNoDeadStrip,
578 bool IsCanonical) {
579
580 LLVM_DEBUG({
581 dbgs() << " " << formatv("{0:x16}", NSym.Value) << " -- "
582 << formatv("{0:x16}", NSym.Value + Size) << ": ";
583 if (!NSym.Name)
584 dbgs() << "<anonymous symbol>";
585 else
586 dbgs() << NSym.Name;
587 if (IsText)
588 dbgs() << " [text]";
589 if (IsNoDeadStrip)
590 dbgs() << " [no-dead-strip]";
591 if (!IsCanonical)
592 dbgs() << " [non-canonical]";
593 dbgs() << "\n";
594 });
595
596 auto SymOffset = orc::ExecutorAddr(NSym.Value) - B.getAddress();
597 auto &Sym =
598 NSym.Name
599 ? G->addDefinedSymbol(B, SymOffset, *NSym.Name, Size, NSym.L, NSym.S,
600 IsText, IsNoDeadStrip)
601 : G->addAnonymousSymbol(B, SymOffset, Size, IsText, IsNoDeadStrip);
602 NSym.GraphSymbol = &Sym;
603
604 if (IsCanonical)
605 setCanonicalSymbol(getSectionByIndex(NSym.Sect - 1), Sym);
606
607 return Sym;
608}
609
610Error MachOLinkGraphBuilder::graphifySectionsWithCustomParsers() {
611 // Graphify special sections.
612 for (auto &KV : IndexToSection) {
613 auto &NSec = KV.second;
614
615 // Skip non-graph sections.
616 if (!NSec.GraphSection)
617 continue;
618
619 auto HI = CustomSectionParserFunctions.find(NSec.GraphSection->getName());
620 if (HI != CustomSectionParserFunctions.end()) {
621 auto &Parse = HI->second;
622 if (auto Err = Parse(NSec))
623 return Err;
624 }
625 }
626
627 return Error::success();
628}
629
630Error MachOLinkGraphBuilder::graphifyCStringSection(
631 NormalizedSection &NSec, std::vector<NormalizedSymbol *> NSyms) {
632 assert(NSec.GraphSection && "C string literal section missing graph section");
633 assert(NSec.Data && "C string literal section has no data");
634
635 LLVM_DEBUG({
636 dbgs() << " Graphifying C-string literal section "
637 << NSec.GraphSection->getName() << "\n";
638 });
639
640 if (NSec.Data[NSec.Size - 1] != '\0')
641 return make_error<JITLinkError>("C string literal section " +
642 NSec.GraphSection->getName() +
643 " does not end with null terminator");
644
645 /// Sort into reverse order to use as a stack.
646 llvm::sort(NSyms,
647 [](const NormalizedSymbol *LHS, const NormalizedSymbol *RHS) {
648 if (LHS->Value != RHS->Value)
649 return LHS->Value > RHS->Value;
650 if (LHS->L != RHS->L)
651 return LHS->L > RHS->L;
652 if (LHS->S != RHS->S)
653 return LHS->S > RHS->S;
654 if (RHS->Name) {
655 if (!LHS->Name)
656 return true;
657 return *LHS->Name > *RHS->Name;
658 }
659 return false;
660 });
661
662 bool SectionIsNoDeadStrip = NSec.Flags & MachO::S_ATTR_NO_DEAD_STRIP;
663 bool SectionIsText = NSec.Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
664 orc::ExecutorAddrDiff BlockStart = 0;
665
666 // Scan section for null characters.
667 for (size_t I = 0; I != NSec.Size; ++I) {
668 if (NSec.Data[I] == '\0') {
669 size_t BlockSize = I + 1 - BlockStart;
670 // Create a block for this null terminated string.
671 auto &B = G->createContentBlock(*NSec.GraphSection,
672 {NSec.Data + BlockStart, BlockSize},
673 NSec.Address + BlockStart, NSec.Alignment,
674 BlockStart % NSec.Alignment);
675
676 LLVM_DEBUG({
677 dbgs() << " Created block " << B.getRange()
678 << ", align = " << B.getAlignment()
679 << ", align-ofs = " << B.getAlignmentOffset() << " for \"";
680 for (size_t J = 0; J != std::min(B.getSize(), size_t(16)); ++J)
681 switch (B.getContent()[J]) {
682 case '\0': break;
683 case '\n': dbgs() << "\\n"; break;
684 case '\t': dbgs() << "\\t"; break;
685 default: dbgs() << B.getContent()[J]; break;
686 }
687 if (B.getSize() > 16)
688 dbgs() << "...";
689 dbgs() << "\"\n";
690 });
691
692 // If there's no symbol at the start of this block then create one.
693 if (NSyms.empty() ||
694 orc::ExecutorAddr(NSyms.back()->Value) != B.getAddress()) {
695 auto &S = G->addAnonymousSymbol(B, 0, BlockSize, false, false);
696 setCanonicalSymbol(NSec, S);
697 LLVM_DEBUG({
698 dbgs() << " Adding symbol for c-string block " << B.getRange()
699 << ": <anonymous symbol> at offset 0\n";
700 });
701 }
702
703 // Process any remaining symbols that point into this block.
704 auto LastCanonicalAddr = B.getAddress() + BlockSize;
705 while (!NSyms.empty() && orc::ExecutorAddr(NSyms.back()->Value) <
706 B.getAddress() + BlockSize) {
707 auto &NSym = *NSyms.back();
708 size_t SymSize = (B.getAddress() + BlockSize) -
709 orc::ExecutorAddr(NSyms.back()->Value);
710 bool SymLive =
711 (NSym.Desc & MachO::N_NO_DEAD_STRIP) || SectionIsNoDeadStrip;
712
713 bool IsCanonical = false;
714 if (LastCanonicalAddr != orc::ExecutorAddr(NSym.Value)) {
715 IsCanonical = true;
716 LastCanonicalAddr = orc::ExecutorAddr(NSym.Value);
717 }
718
719 auto &Sym = createStandardGraphSymbol(NSym, B, SymSize, SectionIsText,
720 SymLive, IsCanonical);
721 (void)Sym;
722 LLVM_DEBUG({
723 dbgs() << " Adding symbol for c-string block " << B.getRange()
724 << ": "
725 << (Sym.hasName() ? Sym.getName() : "<anonymous symbol>")
726 << " at offset " << formatv("{0:x}", Sym.getOffset()) << "\n";
727 });
728
729 NSyms.pop_back();
730 }
731
732 BlockStart += BlockSize;
733 }
734 }
735
736 assert(llvm::all_of(NSec.GraphSection->blocks(),
737 [](Block *B) { return isCStringBlock(*B); }) &&
738 "All blocks in section should hold single c-strings");
739
740 return Error::success();
741}
742
744 auto *CUSec = G.findSectionByName(CompactUnwindSectionName);
745 if (!CUSec)
746 return Error::success();
747
748 if (!G.getTargetTriple().isOSBinFormatMachO())
749 return make_error<JITLinkError>(
750 "Error linking " + G.getName() +
751 ": compact unwind splitting not supported on non-macho target " +
752 G.getTargetTriple().str());
753
754 unsigned CURecordSize = 0;
755 unsigned PersonalityEdgeOffset = 0;
756 unsigned LSDAEdgeOffset = 0;
757 switch (G.getTargetTriple().getArch()) {
758 case Triple::aarch64:
759 case Triple::x86_64:
760 // 64-bit compact-unwind record format:
761 // Range start: 8 bytes.
762 // Range size: 4 bytes.
763 // CU encoding: 4 bytes.
764 // Personality: 8 bytes.
765 // LSDA: 8 bytes.
766 CURecordSize = 32;
767 PersonalityEdgeOffset = 16;
768 LSDAEdgeOffset = 24;
769 break;
770 default:
771 return make_error<JITLinkError>(
772 "Error linking " + G.getName() +
773 ": compact unwind splitting not supported on " +
774 G.getTargetTriple().getArchName());
775 }
776
777 std::vector<Block *> OriginalBlocks(CUSec->blocks().begin(),
778 CUSec->blocks().end());
779 LLVM_DEBUG({
780 dbgs() << "In " << G.getName() << " splitting compact unwind section "
781 << CompactUnwindSectionName << " containing "
782 << OriginalBlocks.size() << " initial blocks...\n";
783 });
784
785 while (!OriginalBlocks.empty()) {
786 auto *B = OriginalBlocks.back();
787 OriginalBlocks.pop_back();
788
789 if (B->getSize() == 0) {
790 LLVM_DEBUG({
791 dbgs() << " Skipping empty block at "
792 << formatv("{0:x16}", B->getAddress()) << "\n";
793 });
794 continue;
795 }
796
797 LLVM_DEBUG({
798 dbgs() << " Splitting block at " << formatv("{0:x16}", B->getAddress())
799 << " into " << (B->getSize() / CURecordSize)
800 << " compact unwind record(s)\n";
801 });
802
803 if (B->getSize() % CURecordSize)
804 return make_error<JITLinkError>(
805 "Error splitting compact unwind record in " + G.getName() +
806 ": block at " + formatv("{0:x}", B->getAddress()) + " has size " +
807 formatv("{0:x}", B->getSize()) +
808 " (not a multiple of CU record size of " +
809 formatv("{0:x}", CURecordSize) + ")");
810
811 unsigned NumBlocks = B->getSize() / CURecordSize;
813
814 for (unsigned I = 0; I != NumBlocks; ++I) {
815 auto &CURec = G.splitBlock(*B, CURecordSize, &C);
816 bool AddedKeepAlive = false;
817
818 for (auto &E : CURec.edges()) {
819 if (E.getOffset() == 0) {
820 LLVM_DEBUG({
821 dbgs() << " Updating compact unwind record at "
822 << formatv("{0:x16}", CURec.getAddress()) << " to point to "
823 << (E.getTarget().hasName() ? E.getTarget().getName()
824 : StringRef())
825 << " (at " << formatv("{0:x16}", E.getTarget().getAddress())
826 << ")\n";
827 });
828
829 if (E.getTarget().isExternal())
830 return make_error<JITLinkError>(
831 "Error adding keep-alive edge for compact unwind record at " +
832 formatv("{0:x}", CURec.getAddress()) + ": target " +
833 E.getTarget().getName() + " is an external symbol");
834 auto &TgtBlock = E.getTarget().getBlock();
835 auto &CURecSym =
836 G.addAnonymousSymbol(CURec, 0, CURecordSize, false, false);
837 TgtBlock.addEdge(Edge::KeepAlive, 0, CURecSym, 0);
838 AddedKeepAlive = true;
839 } else if (E.getOffset() != PersonalityEdgeOffset &&
840 E.getOffset() != LSDAEdgeOffset)
841 return make_error<JITLinkError>("Unexpected edge at offset " +
842 formatv("{0:x}", E.getOffset()) +
843 " in compact unwind record at " +
844 formatv("{0:x}", CURec.getAddress()));
845 }
846
847 if (!AddedKeepAlive)
848 return make_error<JITLinkError>(
849 "Error adding keep-alive edge for compact unwind record at " +
850 formatv("{0:x}", CURec.getAddress()) +
851 ": no outgoing target edge at offset 0");
852 }
853 }
854 return Error::success();
855}
856
857} // end namespace jitlink
858} // end namespace llvm
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static const char * CommonSectionName
static Expected< StringRef > getFileName(const DebugStringTableSubsectionRef &Strings, const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID)
static uint64_t getPointerSize(const Value *V, const DataLayout &DL, const TargetLibraryInfo &TLI, const Function *F)
#define LLVM_DEBUG(X)
Definition: Debug.h:101
std::string Name
uint64_t Size
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
static const char * CommonSectionName
if(VerifyEach)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const int BlockSize
Definition: TarWriter.cpp:33
Value * RHS
Value * LHS
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
iterator end()
Definition: StringMap.h:204
iterator find(StringRef Key)
Definition: StringMap.h:217
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:256
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
StringRef getData() const
Definition: Binary.cpp:39
bool isLittleEndian() const
Definition: Binary.h:152
const MachO::mach_header_64 & getHeader64() const
Expected< SectionRef > getSection(unsigned SectionIndex) const
uint64_t getSymbolIndex(DataRefImpl Symb) const
MachO::nlist getSymbolTableEntry(DataRefImpl DRI) const
MachO::section_64 getSection64(DataRefImpl DRI) const
bool isRelocatableObject() const override
True if this is a relocatable object (.o/.obj).
MachO::nlist_64 getSymbol64TableEntry(DataRefImpl DRI) const
uint64_t getSectionIndex(DataRefImpl Sec) const override
section_iterator_range sections() const
Definition: ObjectFile.h:327
symbol_iterator_range symbols() const
Definition: ObjectFile.h:319
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ N_WEAK_DEF
Definition: MachO.h:346
@ N_NO_DEAD_STRIP
Definition: MachO.h:344
@ N_ALT_ENTRY
Definition: MachO.h:348
@ N_WEAK_REF
Definition: MachO.h:345
@ S_ATTR_DEBUG
S_ATTR_DEBUG - A debug section.
Definition: MachO.h:207
@ S_ATTR_NO_DEAD_STRIP
S_ATTR_NO_DEAD_STRIP - No dead stripping.
Definition: MachO.h:200
@ S_ATTR_PURE_INSTRUCTIONS
S_ATTR_PURE_INSTRUCTIONS - Section contains only true machine instructions.
Definition: MachO.h:192
@ S_GB_ZEROFILL
S_GB_ZEROFILL - Zero fill on demand section (that can be larger than 4 gigabytes).
Definition: MachO.h:155
@ S_THREAD_LOCAL_ZEROFILL
S_THREAD_LOCAL_ZEROFILL - Thread local zerofill section.
Definition: MachO.h:169
@ S_CSTRING_LITERALS
S_CSTRING_LITERALS - Section with literal C strings.
Definition: MachO.h:131
@ S_ZEROFILL
S_ZEROFILL - Zero fill on demand section.
Definition: MachO.h:129
uint8_t GET_COMM_ALIGN(uint16_t n_desc)
Definition: MachO.h:1543
@ SECTION_TYPE
Definition: MachO.h:114
@ MH_SUBSECTIONS_VIA_SYMBOLS
Definition: MachO.h:73
@ N_TYPE
Definition: MachO.h:309
@ N_PEXT
Definition: MachO.h:308
@ N_STAB
Definition: MachO.h:307
@ N_SECT
Definition: MachO.h:318
@ N_PBUD
Definition: MachO.h:319
@ N_INDR
Definition: MachO.h:320
@ N_UNDF
Definition: MachO.h:316
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:48
MemProt
Describes Read/Write/Exec permissions for memory.
Definition: MemoryFlags.h:27
uint64_t ExecutorAddrDiff
@ NoAlloc
NoAlloc memory should not be allocated by the JITLinkMemoryManager at all.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1819
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1744
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1946
Definition: BitVector.h:858