MachO_arm64.cpp Source File (original) (raw)

22#define DEBUG_TYPE "jitlink"

24using namespace llvm;

27namespace {

30public:

32 std::shared_ptrorc::SymbolStringPool SSP,

36 NumSymbols(Obj.getSymtabLoadCommand().nsyms) {}

38private:

39 enum MachOARM64RelocationKind : Edge::Kind {

40 MachOBranch26 = Edge::FirstRelocation,

41 MachOPointer32,

42 MachOPointer64,

43 MachOPointer64Anon,

44 MachOPointer64Authenticated,

45 MachOPage21,

46 MachOPageOffset12,

47 MachOGOTPage21,

48 MachOGOTPageOffset12,

49 MachOTLVPage21,

50 MachOTLVPageOffset12,

51 MachOPointerToGOT,

52 MachOPairedAddend,

53 MachOLDRLiteral19,

54 MachODelta32,

55 MachODelta64,

56 MachONegDelta32,

57 MachONegDelta64,

58 };

66 CPUSubType &= ~MachO::CPU_SUBTYPE_MASK;

68 return Triple("arm64e-apple-darwin");

69 return Triple("arm64-apple-darwin");

70 }

78 return RI.r_extern ? MachOPointer64 : MachOPointer64Anon;

80 return MachOPointer32;

81 }

82 break;

89 return MachODelta32;

91 return MachODelta64;

92 }

93 break;

96 return MachOBranch26;

97 break;

100 return MachOPage21;

101 break;

104 return MachOPageOffset12;

105 break;

108 return MachOGOTPage21;

109 break;

112 return MachOGOTPageOffset12;

113 break;

116 return MachOPointerToGOT;

117 break;

120 return MachOPairedAddend;

121 break;

124 return MachOPointer64Authenticated;

125 break;

128 return MachOTLVPage21;

129 break;

132 return MachOTLVPageOffset12;

133 break;

134 }

135

137 "Unsupported arm64 relocation: address=" +

141 ", pc_rel=" + (RI.r_pcrel ? "true" : "false") +

142 ", extern=" + (RI.r_extern ? "true" : "false") +

144 }

145

146 using PairRelocInfo = std::tuple<Edge::Kind, Symbol *, uint64_t>;

147

148

149

151 parsePairRelocation(Block &BlockToFix, Edge::Kind SubtractorKind,

157

158 assert(((SubtractorKind == MachODelta32 && SubRI.r_length == 2) ||

159 (SubtractorKind == MachODelta64 && SubRI.r_length == 3)) &&

160 "Subtractor kind should match length");

161 assert(SubRI.r_extern && "SUBTRACTOR reloc symbol should be extern");

162 assert(!SubRI.r_pcrel && "SUBTRACTOR reloc should not be PCRel");

163

164 if (UnsignedRelItr == RelEnd)

166 "UNSIGNED relocation");

167

168 auto UnsignedRI = getRelocationInfo(UnsignedRelItr);

169

170 if (SubRI.r_address != UnsignedRI.r_address)

172 "point to different addresses");

173

174 if (SubRI.r_length != UnsignedRI.r_length)

176 "UNSIGNED reloc must match");

177

179 if (auto FromSymbolOrErr = findSymbolByIndex(SubRI.r_symbolnum))

180 FromSymbol = FromSymbolOrErr->GraphSymbol;

181 else

182 return FromSymbolOrErr.takeError();

183

184

187 FixupValue = *(const little64_t *)FixupContent;

188 else

189 FixupValue = *(const little32_t *)FixupContent;

190

191

192

193 Symbol *ToSymbol = nullptr;

194 if (UnsignedRI.r_extern) {

195

196 if (auto ToSymbolOrErr = findSymbolByIndex(UnsignedRI.r_symbolnum))

197 ToSymbol = ToSymbolOrErr->GraphSymbol;

198 else

199 return ToSymbolOrErr.takeError();

200 } else {

201 auto ToSymbolSec = findSectionByIndex(UnsignedRI.r_symbolnum - 1);

202 if (!ToSymbolSec)

203 return ToSymbolSec.takeError();

204 ToSymbol = getSymbolByAddress(*ToSymbolSec, ToSymbolSec->Address);

205 assert(ToSymbol && "No symbol for section");

207 }

208

209 Edge::Kind DeltaKind;

210 Symbol *TargetSymbol;

212

213 bool FixingFromSymbol = true;

216

217

218 if (ToSymbol->getAddress() > FixupAddress)

219 FixingFromSymbol = true;

220 else if (FromSymbol->getAddress() > FixupAddress)

221 FixingFromSymbol = false;

222 else

224 } else

225 FixingFromSymbol = true;

226 } else {

228 FixingFromSymbol = false;

229 else {

230

232 "either 'A' or 'B' (or a symbol in one "

233 "of their alt-entry groups)");

234 }

235 }

236

237 if (FixingFromSymbol) {

238 TargetSymbol = ToSymbol;

240 Addend = FixupValue + (FixupAddress - FromSymbol->getAddress());

241

242 } else {

243 TargetSymbol = &*FromSymbol;

244 DeltaKind =

246 Addend = FixupValue - (FixupAddress - ToSymbol->getAddress());

247 }

248

249 return PairRelocInfo(DeltaKind, TargetSymbol, Addend);

250 }

251

252 Error addRelocations() override {

255

257

258 for (auto &S : Obj.sections()) {

259

261

262

263 if (S.isVirtual()) {

264 if (!S.relocations().empty())

266 "relocations");

267 continue;

268 }

269

270 auto NSec =

271 findSectionByIndex(Obj.getSectionIndex(S.getRawDataRefImpl()));

272 if (!NSec)

273 return NSec.takeError();

274

275

276

277 {

278 if (!NSec->GraphSection) {

280 dbgs() << " Skipping relocations for MachO section "

281 << NSec->SegName << "/" << NSec->SectName

282 << " which has no associated graph section\n";

283 });

284 continue;

285 }

286 }

287

288 for (auto RelItr = S.relocation_begin(), RelEnd = S.relocation_end();

289 RelItr != RelEnd; ++RelItr) {

290

292

293

294 auto MachORelocKind = getRelocationKind(RI);

295 if (!MachORelocKind)

296 return MachORelocKind.takeError();

297

298

302 dbgs() << " " << NSec->SectName << " + "

304 });

305

306

307 Block *BlockToFix = nullptr;

308 {

309 auto SymbolToFixOrErr = findSymbolByAddress(*NSec, FixupAddress);

310 if (!SymbolToFixOrErr)

311 return SymbolToFixOrErr.takeError();

312 BlockToFix = &SymbolToFixOrErr->getBlock();

313 }

314

316 BlockToFix->getAddress() + BlockToFix->getContent().size())

318 "Relocation content extends past end of fixup block");

319

320 Edge::Kind Kind = Edge::Invalid;

321

322

323 const char *FixupContent = BlockToFix->getContent().data() +

324 (FixupAddress - BlockToFix->getAddress());

325

326

327 Symbol *TargetSymbol = nullptr;

329

330 if (*MachORelocKind == MachOPairedAddend) {

331

332

333

335

336 ++RelItr;

337 if (RelItr == RelEnd)

339 formatv("{0:x16}", FixupAddress));

340 RI = getRelocationInfo(RelItr);

341

342 MachORelocKind = getRelocationKind(RI);

343 if (!MachORelocKind)

344 return MachORelocKind.takeError();

345

346 if (*MachORelocKind != MachOBranch26 &&

347 *MachORelocKind != MachOPage21 &&

348 *MachORelocKind != MachOPageOffset12)

350 "Invalid relocation pair: Addend + " +

351 StringRef(getMachOARM64RelocationKindName(*MachORelocKind)));

352

354 dbgs() << " Addend: value = " << formatv("{0:x6}", Addend)

355 << ", pair is "

356 << getMachOARM64RelocationKindName(*MachORelocKind) << "\n";

357 });

358

359

362 if (PairedFixupAddress != FixupAddress)

364 "different target");

365 }

366

367 switch (*MachORelocKind) {

368 case MachOBranch26: {

369 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

370 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

371 else

372 return TargetSymbolOrErr.takeError();

373 uint32_t Instr = *(const ulittle32_t *)FixupContent;

374 if ((Instr & 0x7fffffff) != 0x14000000)

376 "instruction with a zero addend");

378 break;

379 }

380 case MachOPointer32:

381 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

382 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

383 else

384 return TargetSymbolOrErr.takeError();

385 Addend = *(const ulittle32_t *)FixupContent;

387 break;

388 case MachOPointer64:

389 case MachOPointer64Authenticated:

390 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

391 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

392 else

393 return TargetSymbolOrErr.takeError();

394 Addend = *(const ulittle64_t *)FixupContent;

395 Kind = *MachORelocKind == MachOPointer64

398 break;

399 case MachOPointer64Anon: {

400 orc::ExecutorAddr TargetAddress(*(const ulittle64_t *)FixupContent);

401 auto TargetNSec = findSectionByIndex(RI.r_symbolnum - 1);

402 if (!TargetNSec)

403 return TargetNSec.takeError();

404 if (auto TargetSymbolOrErr =

405 findSymbolByAddress(*TargetNSec, TargetAddress))

406 TargetSymbol = &*TargetSymbolOrErr;

407 else

408 return TargetSymbolOrErr.takeError();

409 Addend = TargetAddress - TargetSymbol->getAddress();

411 break;

412 }

413 case MachOPage21:

414 case MachOGOTPage21:

415 case MachOTLVPage21: {

416 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

417 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

418 else

419 return TargetSymbolOrErr.takeError();

420 uint32_t Instr = *(const ulittle32_t *)FixupContent;

421 if ((Instr & 0xffffffe0) != 0x90000000)

423 "ADRP instruction with a zero "

424 "addend");

425

426 if (*MachORelocKind == MachOPage21) {

428 } else if (*MachORelocKind == MachOGOTPage21) {

430 } else if (*MachORelocKind == MachOTLVPage21) {

432 }

433 break;

434 }

435 case MachOPageOffset12: {

436 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

437 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

438 else

439 return TargetSymbolOrErr.takeError();

440 uint32_t Instr = *(const ulittle32_t *)FixupContent;

441 uint32_t EncodedAddend = (Instr & 0x003FFC00) >> 10;

442 if (EncodedAddend != 0)

444 "encoded addend");

446 break;

447 }

448 case MachOGOTPageOffset12:

449 case MachOTLVPageOffset12: {

450 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

451 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

452 else

453 return TargetSymbolOrErr.takeError();

454 uint32_t Instr = *(const ulittle32_t *)FixupContent;

455 if ((Instr & 0xfffffc00) != 0xf9400000)

457 "immediate instruction with a zero "

458 "addend");

459

460 if (*MachORelocKind == MachOGOTPageOffset12) {

462 } else if (*MachORelocKind == MachOTLVPageOffset12) {

464 }

465 break;

466 }

467 case MachOPointerToGOT:

468 if (auto TargetSymbolOrErr = findSymbolByIndex(RI.r_symbolnum))

469 TargetSymbol = TargetSymbolOrErr->GraphSymbol;

470 else

471 return TargetSymbolOrErr.takeError();

472

474 break;

475 case MachODelta32:

476 case MachODelta64: {

477

478

479

480

481

482 auto PairInfo =

483 parsePairRelocation(*BlockToFix, *MachORelocKind, RI,

484 FixupAddress, FixupContent, ++RelItr, RelEnd);

485 if (!PairInfo)

486 return PairInfo.takeError();

487 std::tie(Kind, TargetSymbol, Addend) = *PairInfo;

488 assert(TargetSymbol && "No target symbol from parsePairRelocation?");

489 break;

490 }

491 default:

492 llvm_unreachable("Special relocation kind should not appear in "

493 "mach-o file");

494 }

495

497 dbgs() << " ";

498 Edge GE(Kind, FixupAddress - BlockToFix->getAddress(), *TargetSymbol,

499 Addend);

501 dbgs() << "\n";

502 });

503 BlockToFix->addEdge(Kind, FixupAddress - BlockToFix->getAddress(),

504 *TargetSymbol, Addend);

505 }

506 }

508 }

509

510

511 const char *getMachOARM64RelocationKindName(Edge::Kind R) {

512 switch (R) {

513 case MachOBranch26:

514 return "MachOBranch26";

515 case MachOPointer64:

516 return "MachOPointer64";

517 case MachOPointer64Anon:

518 return "MachOPointer64Anon";

519 case MachOPointer64Authenticated:

520 return "MachOPointer64Authenticated";

521 case MachOPage21:

522 return "MachOPage21";

523 case MachOPageOffset12:

524 return "MachOPageOffset12";

525 case MachOGOTPage21:

526 return "MachOGOTPage21";

527 case MachOGOTPageOffset12:

528 return "MachOGOTPageOffset12";

529 case MachOTLVPage21:

530 return "MachOTLVPage21";

531 case MachOTLVPageOffset12:

532 return "MachOTLVPageOffset12";

533 case MachOPointerToGOT:

534 return "MachOPointerToGOT";

535 case MachOPairedAddend:

536 return "MachOPairedAddend";

537 case MachOLDRLiteral19:

538 return "MachOLDRLiteral19";

539 case MachODelta32:

540 return "MachODelta32";

541 case MachODelta64:

542 return "MachODelta64";

543 case MachONegDelta32:

544 return "MachONegDelta32";

545 case MachONegDelta64:

546 return "MachONegDelta64";

547 default:

549 }

550 }

551

552 unsigned NumSymbols = 0;

553};

554

555}

556

557namespace llvm {

559

568

571

572public:

574 std::unique_ptr G,

577

578private:

581 }

582

584};

585

587 MemoryBufferRef ObjectBuffer, std::shared_ptrorc::SymbolStringPool SSP) {

589 if (!MachOObj)

590 return MachOObj.takeError();

591

592 auto Features = (*MachOObj)->getFeatures();

593 if (!Features)

594 return Features.takeError();

595

596 return MachOLinkGraphBuilder_arm64(**MachOObj, std::move(SSP),

597 std::move(*Features))

598 .buildGraph();

599}

600

602 assert(G.getTargetTriple().isArm64e() && "PAC signing only valid for arm64e");

603

604 if (auto *ModInitSec = G.findSectionByName("__DATA,__mod_init_func")) {

605 for (auto *B : ModInitSec->blocks()) {

606 for (auto &E : B->edges()) {

608

609

610 if (E.getAddend() >> 32)

612 "In " + G.getName() + ", __mod_init_func pointer at " +

613 formatv("{0:x}", B->getFixupAddress(E).getValue()) +

614 " has data in high bits of addend (addend >= 2^32)");

615

616

617

618 Edge::AddendT SigningBits = 0x1ULL << 63;

620 E.setAddend(E.getAddend() | SigningBits);

621 }

622 }

623 }

624 }

625

627}

628

631 8> {

632

633

634

635

637

640

642

644 constexpr uint32_t DWARFMode = 0x03000000;

646 }

647

649};

650

652 std::unique_ptr Ctx) {

653

655

656 if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {

657

658 if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))

659 Config.PrePrunePasses.push_back(std::move(MarkLive));

660 else

662

663

666

667

668 auto CompactUnwindMgr =

669 std::make_shared<CompactUnwindManager<CompactUnwindTraits_MachO_arm64>>(

672

673

675 return CompactUnwindMgr->prepareForPrune(G);

676 });

677

678

682

683

685

686

687 if (G->getTargetTriple().isArm64e()) {

693 }

694

695

697 return CompactUnwindMgr->processAndReserveUnwindInfo(G);

698 });

699

700

702 return CompactUnwindMgr->writeUnwindInfo(G);

703 });

704 }

705

706 if (auto Err = Ctx->modifyPassConfig(*G, Config))

707 return Ctx->notifyFailed(std::move(Err));

708

709

711}

712

716

722}

723

724}

725}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static Error getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr, const uint64_t Size=sizeof(T))

#define LLVM_UNLIKELY(EXPR)

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.

StringRef - Represent a constant reference to a string, i.e.

Manages the enabling and disabling of subtarget specific features.

Triple - Helper class for working with autoconf configuration names.

An Addressable with content and edges.

A LinkGraph pass that splits blocks in a section that follows the DWARF Record format into sub-blocks...

A LinkGraph pass that adds missing FDE-to-CIE, FDE-to-PC and FDE-to-LSDA edges.

Represents fixups and constraints in the LinkGraph.

static void link(ArgTs &&... Args)

MachOJITLinker_arm64(std::unique_ptr< JITLinkContext > Ctx, std::unique_ptr< LinkGraph > G, PassConfiguration PassConfig)

Definition MachO_arm64.cpp:573

Addressable & getAddressable()

Return the addressable that this symbol points to.

orc::ExecutorAddr getAddress() const

Returns the address of this symbol.

Global Offset Table Builder.

Procedure Linkage Table Builder.

static Expected< std::unique_ptr< MachOObjectFile > > createMachOObjectFile(MemoryBufferRef Object, uint32_t UniversalCputype=0, uint32_t UniversalIndex=0, size_t MachOFilesetEntryOffset=0)

Create a MachOObjectFile instance from a given buffer.

Represents an address in the executor process.

uint64_t getValue() const

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ ARM64_RELOC_POINTER_TO_GOT

@ ARM64_RELOC_AUTHENTICATED_POINTER

@ ARM64_RELOC_GOT_LOAD_PAGE21

@ ARM64_RELOC_TLVP_LOAD_PAGEOFF12

@ ARM64_RELOC_GOT_LOAD_PAGEOFF12

@ ARM64_RELOC_TLVP_LOAD_PAGE21

constexpr uint64_t PointerSize

aarch64 pointer size.

Error applyFixup(LinkGraph &G, Block &B, const Edge &E, const Symbol *GOTSymbol)

Apply fixup expression for edge to block content.

LLVM_ABI Error createEmptyPointerSigningFunction(LinkGraph &G)

Creates a pointer signing function section, block, and symbol to reserve space for a signing function...

LLVM_ABI Error lowerPointer64AuthEdgesToSigningFunction(LinkGraph &G)

Given a LinkGraph containing Pointer64Authenticated edges, transform those edges to Pointer64 and add...

LLVM_ABI const char * getEdgeKindName(Edge::Kind K)

Returns a string name for the given aarch64 edge.

@ Pointer64Authenticated

An arm64e authenticated pointer relocation.

@ RequestTLVPAndTransformToPageOffset12

A TLVP entry getter/constructor, transformed to PageOffset12.

@ Page21

The signed 21-bit delta from the fixup page to the page containing the target.

@ Branch26PCRel

A 26-bit PC-relative branch.

@ Pointer64

A plain 64-bit pointer value relocation.

@ Pointer32

A plain 32-bit pointer value relocation.

@ RequestTLVPAndTransformToPage21

A TLVP entry getter/constructor, transformed to Page21.

@ RequestGOTAndTransformToPage21

A GOT entry getter/constructor, transformed to Page21 pointing at the GOT entry for the original targ...

@ RequestGOTAndTransformToPageOffset12

A GOT entry getter/constructor, transformed to Pageoffset12 pointing at the GOT entry for the origina...

@ NegDelta32

A 32-bit negative delta.

@ NegDelta64

A 64-bit negative delta.

@ RequestGOTAndTransformToDelta32

A GOT entry getter/constructor, transformed to Delta32 pointing at the GOT entry for the original tar...

@ PageOffset12

The 12-bit (potentially shifted) offset of the target within its page.

unique_function< Error(LinkGraph &)> LinkGraphPassFunction

A function for mutating LinkGraphs.

LLVM_ABI const char * getGenericEdgeKindName(Edge::Kind K)

Returns the string name of the given generic edge kind, or "unknown" otherwise.

LLVM_ABI void link_MachO_arm64(std::unique_ptr< LinkGraph > G, std::unique_ptr< JITLinkContext > Ctx)

jit-link the given object buffer, which must be a MachO arm64 object file.

Definition MachO_arm64.cpp:651

LLVM_ABI LinkGraphPassFunction createEHFrameEdgeFixerPass_MachO_arm64()

Returns a pass suitable for fixing missing edges in an __eh_frame section in a MachO/x86-64 object.

Definition MachO_arm64.cpp:717

LLVM_ABI LinkGraphPassFunction createEHFrameSplitterPass_MachO_arm64()

Returns a pass suitable for splitting __eh_frame sections in MachO/x86-64 objects.

Definition MachO_arm64.cpp:713

void visitExistingEdges(LinkGraph &G, VisitorTs &&...Vs)

For each edge in the given graph, apply a list of visitors to the edge, stopping when the first visit...

LLVM_ABI Error markAllSymbolsLive(LinkGraph &G)

Marks all symbols in a graph live.

Error buildTables_MachO_arm64(LinkGraph &G)

Definition MachO_arm64.cpp:560

LLVM_ABI void printEdge(raw_ostream &OS, const Block &B, const Edge &E, StringRef EdgeKindName)

LLVM_ABI Expected< std::unique_ptr< LinkGraph > > createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer, std::shared_ptr< orc::SymbolStringPool > SSP)

Create a LinkGraph from a MachO/arm64 relocatable object.

Definition MachO_arm64.cpp:586

DefineExternalSectionStartAndEndSymbols< SymbolIdentifierFunction > createDefineExternalSectionStartAndEndSymbolsPass(SymbolIdentifierFunction &&F)

Returns a JITLink pass (as a function class) that uses the given symbol identification function to id...

SectionRangeSymbolDesc identifyMachOSectionStartAndEndSymbols(LinkGraph &G, Symbol &Sym)

MachO section start/end symbol detection.

static Error applyPACSigningToModInitPointers(LinkGraph &G)

Definition MachO_arm64.cpp:601

content_iterator< RelocationRef > relocation_iterator

LLVM_ABI StringRef MachOEHFrameSectionName

uint64_t ExecutorAddrDiff

LLVM_ABI StringRef MachOCompactUnwindSectionName

LLVM_ABI StringRef MachOUnwindInfoSectionName

detail::packed_endian_specific_integral< uint32_t, llvm::endianness::little, unaligned > ulittle32_t

This is an optimization pass for GlobalISel generic memory operations.

auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

constexpr int64_t SignExtend64(uint64_t x)

Sign-extend the number in the bottom B bits of X to a 64-bit integer.

Implement std::hash so that hash_code can be used in STL containers.

Definition MachO_arm64.cpp:631

static bool encodingSpecifiesDWARF(uint32_t Encoding)

Definition MachO_arm64.cpp:643

static bool encodingCannotBeMerged(uint32_t Encoding)

Definition MachO_arm64.cpp:648

static constexpr uint32_t EncodingModeMask

Definition MachO_arm64.cpp:638

static constexpr uint32_t DWARFSectionOffsetMask

Definition MachO_arm64.cpp:639

static constexpr endianness Endianness

Definition MachO_arm64.cpp:636

aarch64::GOTTableManager GOTManager

Definition MachO_arm64.cpp:641

CRTP base for compact unwind traits classes.

An LinkGraph pass configuration, consisting of a list of pre-prune, post-prune, and post-fixup passes...

LinkGraphPassList PostAllocationPasses

Post-allocation passes.

LinkGraphPassList PreFixupPasses

Pre-fixup passes.

LinkGraphPassList PostPrunePasses

Post-prune passes.

LinkGraphPassList PrePrunePasses

Pre-prune passes.