LLVM 18.0.0git
ELF_aarch64.cpp
Go to the documentation of this file.
1//===----- ELF_aarch64.cpp - JIT linker implementation for ELF/aarch64 ----===//
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// ELF/aarch64 jit-link implementation.
10//
11//===----------------------------------------------------------------------===//
12
14#include "EHFrameSupportImpl.h"
15#include "ELFLinkGraphBuilder.h"
16#include "JITLinkGeneric.h"
21#include "llvm/Support/Endian.h"
22
23#define DEBUG_TYPE "jitlink"
24
25using namespace llvm;
26using namespace llvm::jitlink;
27
28namespace {
29
30class ELFJITLinker_aarch64 : public JITLinker<ELFJITLinker_aarch64> {
31 friend class JITLinker<ELFJITLinker_aarch64>;
32
33public:
34 ELFJITLinker_aarch64(std::unique_ptr<JITLinkContext> Ctx,
35 std::unique_ptr<LinkGraph> G,
36 PassConfiguration PassConfig)
37 : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
38
39private:
40 Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
41 return aarch64::applyFixup(G, B, E);
42 }
43};
44
45template <typename ELFT>
46class ELFLinkGraphBuilder_aarch64 : public ELFLinkGraphBuilder<ELFT> {
47private:
48 enum ELFAArch64RelocationKind : Edge::Kind {
49 ELFCall26 = Edge::FirstRelocation,
50 ELFAdrLo21,
51 ELFAdrPage21,
52 ELFAddAbs12,
53 ELFLdSt8Abs12,
54 ELFLdSt16Abs12,
55 ELFLdSt32Abs12,
56 ELFLdSt64Abs12,
57 ELFLdSt128Abs12,
58 ELFMovwAbsG0,
59 ELFMovwAbsG1,
60 ELFMovwAbsG2,
61 ELFMovwAbsG3,
62 ELFTstBr14,
63 ELFCondBr19,
64 ELFAbs32,
65 ELFAbs64,
66 ELFPrel32,
67 ELFPrel64,
68 ELFAdrGOTPage21,
69 ELFLd64GOTLo12,
70 ELFTLSDescAdrPage21,
71 ELFTLSDescAddLo12,
72 ELFTLSDescLd64Lo12,
73 ELFTLSDescCall,
74 };
75
77 getRelocationKind(const uint32_t Type) {
78 using namespace aarch64;
79 switch (Type) {
80 case ELF::R_AARCH64_CALL26:
81 case ELF::R_AARCH64_JUMP26:
82 return ELFCall26;
83 case ELF::R_AARCH64_ADR_PREL_LO21:
84 return ELFAdrLo21;
85 case ELF::R_AARCH64_ADR_PREL_PG_HI21:
86 return ELFAdrPage21;
87 case ELF::R_AARCH64_ADD_ABS_LO12_NC:
88 return ELFAddAbs12;
89 case ELF::R_AARCH64_LDST8_ABS_LO12_NC:
90 return ELFLdSt8Abs12;
91 case ELF::R_AARCH64_LDST16_ABS_LO12_NC:
92 return ELFLdSt16Abs12;
93 case ELF::R_AARCH64_LDST32_ABS_LO12_NC:
94 return ELFLdSt32Abs12;
95 case ELF::R_AARCH64_LDST64_ABS_LO12_NC:
96 return ELFLdSt64Abs12;
97 case ELF::R_AARCH64_LDST128_ABS_LO12_NC:
98 return ELFLdSt128Abs12;
99 case ELF::R_AARCH64_MOVW_UABS_G0_NC:
100 return ELFMovwAbsG0;
101 case ELF::R_AARCH64_MOVW_UABS_G1_NC:
102 return ELFMovwAbsG1;
103 case ELF::R_AARCH64_MOVW_UABS_G2_NC:
104 return ELFMovwAbsG2;
105 case ELF::R_AARCH64_MOVW_UABS_G3:
106 return ELFMovwAbsG3;
107 case ELF::R_AARCH64_TSTBR14:
108 return ELFTstBr14;
109 case ELF::R_AARCH64_CONDBR19:
110 return ELFCondBr19;
111 case ELF::R_AARCH64_ABS32:
112 return ELFAbs32;
113 case ELF::R_AARCH64_ABS64:
114 return ELFAbs64;
115 case ELF::R_AARCH64_PREL32:
116 return ELFPrel32;
117 case ELF::R_AARCH64_PREL64:
118 return ELFPrel64;
119 case ELF::R_AARCH64_ADR_GOT_PAGE:
120 return ELFAdrGOTPage21;
121 case ELF::R_AARCH64_LD64_GOT_LO12_NC:
122 return ELFLd64GOTLo12;
123 case ELF::R_AARCH64_TLSDESC_ADR_PAGE21:
124 return ELFTLSDescAdrPage21;
125 case ELF::R_AARCH64_TLSDESC_ADD_LO12:
126 return ELFTLSDescAddLo12;
127 case ELF::R_AARCH64_TLSDESC_LD64_LO12:
128 return ELFTLSDescLd64Lo12;
129 case ELF::R_AARCH64_TLSDESC_CALL:
130 return ELFTLSDescCall;
131 }
132
133 return make_error<JITLinkError>(
134 "Unsupported aarch64 relocation:" + formatv("{0:d}: ", Type) +
136 }
137
138 Error addRelocations() override {
139 LLVM_DEBUG(dbgs() << "Processing relocations:\n");
140
142 using Self = ELFLinkGraphBuilder_aarch64<ELFT>;
143 for (const auto &RelSect : Base::Sections)
144 if (Error Err = Base::forEachRelaRelocation(RelSect, this,
145 &Self::addSingleRelocation))
146 return Err;
147
148 return Error::success();
149 }
150
151 Error addSingleRelocation(const typename ELFT::Rela &Rel,
152 const typename ELFT::Shdr &FixupSect,
153 Block &BlockToFix) {
156
157 uint32_t SymbolIndex = Rel.getSymbol(false);
158 auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
159 if (!ObjSymbol)
160 return ObjSymbol.takeError();
161
162 Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);
163 if (!GraphSymbol)
164 return make_error<StringError>(
165 formatv("Could not find symbol at given index, did you add it to "
166 "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}",
167 SymbolIndex, (*ObjSymbol)->st_shndx,
168 Base::GraphSymbols.size()),
170
171 uint32_t Type = Rel.getType(false);
172 Expected<ELFAArch64RelocationKind> RelocKind = getRelocationKind(Type);
173 if (!RelocKind)
174 return RelocKind.takeError();
175
176 int64_t Addend = Rel.r_addend;
177 orc::ExecutorAddr FixupAddress =
178 orc::ExecutorAddr(FixupSect.sh_addr) + Rel.r_offset;
179 Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
180
181 // Get a pointer to the fixup content.
182 const void *FixupContent = BlockToFix.getContent().data() +
183 (FixupAddress - BlockToFix.getAddress());
184
186
187 switch (*RelocKind) {
188 case ELFCall26: {
190 break;
191 }
192 case ELFAdrLo21: {
193 uint32_t Instr = *(const ulittle32_t *)FixupContent;
194 if (!aarch64::isADR(Instr))
195 return make_error<JITLinkError>(
196 "R_AARCH64_ADR_PREL_LO21 target is not an ADR instruction");
197
199 break;
200 }
201 case ELFAdrPage21: {
202 Kind = aarch64::Page21;
203 break;
204 }
205 case ELFAddAbs12: {
207 break;
208 }
209 case ELFLdSt8Abs12: {
210 uint32_t Instr = *(const ulittle32_t *)FixupContent;
211 if (!aarch64::isLoadStoreImm12(Instr) ||
213 return make_error<JITLinkError>(
214 "R_AARCH64_LDST8_ABS_LO12_NC target is not a "
215 "LDRB/STRB (imm12) instruction");
216
218 break;
219 }
220 case ELFLdSt16Abs12: {
221 uint32_t Instr = *(const ulittle32_t *)FixupContent;
222 if (!aarch64::isLoadStoreImm12(Instr) ||
224 return make_error<JITLinkError>(
225 "R_AARCH64_LDST16_ABS_LO12_NC target is not a "
226 "LDRH/STRH (imm12) instruction");
227
229 break;
230 }
231 case ELFLdSt32Abs12: {
232 uint32_t Instr = *(const ulittle32_t *)FixupContent;
233 if (!aarch64::isLoadStoreImm12(Instr) ||
235 return make_error<JITLinkError>(
236 "R_AARCH64_LDST32_ABS_LO12_NC target is not a "
237 "LDR/STR (imm12, 32 bit) instruction");
238
240 break;
241 }
242 case ELFLdSt64Abs12: {
243 uint32_t Instr = *(const ulittle32_t *)FixupContent;
244 if (!aarch64::isLoadStoreImm12(Instr) ||
246 return make_error<JITLinkError>(
247 "R_AARCH64_LDST64_ABS_LO12_NC target is not a "
248 "LDR/STR (imm12, 64 bit) instruction");
249
251 break;
252 }
253 case ELFLdSt128Abs12: {
254 uint32_t Instr = *(const ulittle32_t *)FixupContent;
255 if (!aarch64::isLoadStoreImm12(Instr) ||
257 return make_error<JITLinkError>(
258 "R_AARCH64_LDST128_ABS_LO12_NC target is not a "
259 "LDR/STR (imm12, 128 bit) instruction");
260
262 break;
263 }
264 case ELFMovwAbsG0: {
265 uint32_t Instr = *(const ulittle32_t *)FixupContent;
266 if (!aarch64::isMoveWideImm16(Instr) ||
267 aarch64::getMoveWide16Shift(Instr) != 0)
268 return make_error<JITLinkError>(
269 "R_AARCH64_MOVW_UABS_G0_NC target is not a "
270 "MOVK/MOVZ (imm16, LSL #0) instruction");
271
272 Kind = aarch64::MoveWide16;
273 break;
274 }
275 case ELFMovwAbsG1: {
276 uint32_t Instr = *(const ulittle32_t *)FixupContent;
277 if (!aarch64::isMoveWideImm16(Instr) ||
278 aarch64::getMoveWide16Shift(Instr) != 16)
279 return make_error<JITLinkError>(
280 "R_AARCH64_MOVW_UABS_G1_NC target is not a "
281 "MOVK/MOVZ (imm16, LSL #16) instruction");
282
283 Kind = aarch64::MoveWide16;
284 break;
285 }
286 case ELFMovwAbsG2: {
287 uint32_t Instr = *(const ulittle32_t *)FixupContent;
288 if (!aarch64::isMoveWideImm16(Instr) ||
289 aarch64::getMoveWide16Shift(Instr) != 32)
290 return make_error<JITLinkError>(
291 "R_AARCH64_MOVW_UABS_G2_NC target is not a "
292 "MOVK/MOVZ (imm16, LSL #32) instruction");
293
294 Kind = aarch64::MoveWide16;
295 break;
296 }
297 case ELFMovwAbsG3: {
298 uint32_t Instr = *(const ulittle32_t *)FixupContent;
299 if (!aarch64::isMoveWideImm16(Instr) ||
300 aarch64::getMoveWide16Shift(Instr) != 48)
301 return make_error<JITLinkError>(
302 "R_AARCH64_MOVW_UABS_G3 target is not a "
303 "MOVK/MOVZ (imm16, LSL #48) instruction");
304
305 Kind = aarch64::MoveWide16;
306 break;
307 }
308 case ELFTstBr14: {
309 uint32_t Instr = *(const ulittle32_t *)FixupContent;
311 return make_error<JITLinkError>("R_AARCH64_TSTBR14 target is not a "
312 "test and branch instruction");
313
315 break;
316 }
317 case ELFCondBr19: {
318 uint32_t Instr = *(const ulittle32_t *)FixupContent;
319 if (!aarch64::isCondBranchImm19(Instr) &&
321 return make_error<JITLinkError>("R_AARCH64_CONDBR19 target is not a "
322 "conditional branch instruction");
323
325 break;
326 }
327 case ELFAbs32: {
328 Kind = aarch64::Pointer32;
329 break;
330 }
331 case ELFAbs64: {
332 Kind = aarch64::Pointer64;
333 break;
334 }
335 case ELFPrel32: {
336 Kind = aarch64::Delta32;
337 break;
338 }
339 case ELFPrel64: {
340 Kind = aarch64::Delta64;
341 break;
342 }
343 case ELFAdrGOTPage21: {
345 break;
346 }
347 case ELFLd64GOTLo12: {
349 break;
350 }
351 case ELFTLSDescAdrPage21: {
353 break;
354 }
355 case ELFTLSDescAddLo12:
356 case ELFTLSDescLd64Lo12: {
358 break;
359 }
360 case ELFTLSDescCall: {
361 return Error::success();
362 }
363 };
364
365 Edge GE(Kind, Offset, *GraphSymbol, Addend);
366 LLVM_DEBUG({
367 dbgs() << " ";
368 printEdge(dbgs(), BlockToFix, GE, aarch64::getEdgeKindName(Kind));
369 dbgs() << "\n";
370 });
371
372 BlockToFix.addEdge(std::move(GE));
373
374 return Error::success();
375 }
376
377 /// Return the string name of the given ELF aarch64 edge kind.
378 const char *getELFAArch64RelocationKindName(Edge::Kind R) {
379 switch (R) {
380 case ELFCall26:
381 return "ELFCall26";
382 case ELFAdrPage21:
383 return "ELFAdrPage21";
384 case ELFAddAbs12:
385 return "ELFAddAbs12";
386 case ELFLdSt8Abs12:
387 return "ELFLdSt8Abs12";
388 case ELFLdSt16Abs12:
389 return "ELFLdSt16Abs12";
390 case ELFLdSt32Abs12:
391 return "ELFLdSt32Abs12";
392 case ELFLdSt64Abs12:
393 return "ELFLdSt64Abs12";
394 case ELFLdSt128Abs12:
395 return "ELFLdSt128Abs12";
396 case ELFMovwAbsG0:
397 return "ELFMovwAbsG0";
398 case ELFMovwAbsG1:
399 return "ELFMovwAbsG1";
400 case ELFMovwAbsG2:
401 return "ELFMovwAbsG2";
402 case ELFMovwAbsG3:
403 return "ELFMovwAbsG3";
404 case ELFAbs32:
405 return "ELFAbs32";
406 case ELFAbs64:
407 return "ELFAbs64";
408 case ELFPrel32:
409 return "ELFPrel32";
410 case ELFPrel64:
411 return "ELFPrel64";
412 case ELFAdrGOTPage21:
413 return "ELFAdrGOTPage21";
414 case ELFLd64GOTLo12:
415 return "ELFLd64GOTLo12";
416 case ELFTLSDescAdrPage21:
417 return "ELFTLSDescAdrPage21";
418 case ELFTLSDescAddLo12:
419 return "ELFTLSDescAddLo12";
420 case ELFTLSDescLd64Lo12:
421 return "ELFTLSDescLd64Lo12";
422 case ELFTLSDescCall:
423 return "ELFTLSDescCall";
424 default:
425 return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
426 }
427 }
428
429public:
430 ELFLinkGraphBuilder_aarch64(StringRef FileName,
431 const object::ELFFile<ELFT> &Obj, Triple TT,
432 SubtargetFeatures Features)
433 : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
434 FileName, aarch64::getEdgeKindName) {}
435};
436
437// TLS Info Builder.
438class TLSInfoTableManager_ELF_aarch64
439 : public TableManager<TLSInfoTableManager_ELF_aarch64> {
440public:
441 static StringRef getSectionName() { return "$__TLSINFO"; }
442
443 static const uint8_t TLSInfoEntryContent[16];
444
445 bool visitEdge(LinkGraph &G, Block *B, Edge &E) { return false; }
446
447 Symbol &createEntry(LinkGraph &G, Symbol &Target) {
448 // the TLS Info entry's key value will be written by the fixTLVSectionByName
449 // pass, so create mutable content.
450 auto &TLSInfoEntry = G.createMutableContentBlock(
451 getTLSInfoSection(G), G.allocateContent(getTLSInfoEntryContent()),
452 orc::ExecutorAddr(), 8, 0);
453 TLSInfoEntry.addEdge(aarch64::Pointer64, 8, Target, 0);
454 return G.addAnonymousSymbol(TLSInfoEntry, 0, 16, false, false);
455 }
456
457private:
458 Section &getTLSInfoSection(LinkGraph &G) {
459 if (!TLSInfoTable)
460 TLSInfoTable = &G.createSection(getSectionName(), orc::MemProt::Read);
461 return *TLSInfoTable;
462 }
463
464 ArrayRef<char> getTLSInfoEntryContent() const {
465 return {reinterpret_cast<const char *>(TLSInfoEntryContent),
466 sizeof(TLSInfoEntryContent)};
467 }
468
469 Section *TLSInfoTable = nullptr;
470};
471
472const uint8_t TLSInfoTableManager_ELF_aarch64::TLSInfoEntryContent[16] = {
473 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
474 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /*data address*/
475};
476
477// TLS Descriptor Builder.
478class TLSDescTableManager_ELF_aarch64
479 : public TableManager<TLSDescTableManager_ELF_aarch64> {
480public:
481 TLSDescTableManager_ELF_aarch64(
482 TLSInfoTableManager_ELF_aarch64 &TLSInfoTableManager)
483 : TLSInfoTableManager(TLSInfoTableManager) {}
484
485 static StringRef getSectionName() { return "$__TLSDESC"; }
486
487 static const uint8_t TLSDescEntryContent[16];
488
489 bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
490 Edge::Kind KindToSet = Edge::Invalid;
491 switch (E.getKind()) {
493 KindToSet = aarch64::Page21;
494 break;
495 }
497 KindToSet = aarch64::PageOffset12;
498 break;
499 }
500 default:
501 return false;
502 }
503 assert(KindToSet != Edge::Invalid &&
504 "Fell through switch, but no new kind to set");
505 DEBUG_WITH_TYPE("jitlink", {
506 dbgs() << " Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
507 << B->getFixupAddress(E) << " (" << B->getAddress() << " + "
508 << formatv("{0:x}", E.getOffset()) << ")\n";
509 });
510 E.setKind(KindToSet);
511 E.setTarget(getEntryForTarget(G, E.getTarget()));
512 return true;
513 }
514
515 Symbol &createEntry(LinkGraph &G, Symbol &Target) {
516 auto &EntryBlock =
517 G.createContentBlock(getTLSDescSection(G), getTLSDescBlockContent(),
518 orc::ExecutorAddr(), 8, 0);
519 EntryBlock.addEdge(aarch64::Pointer64, 0, getTLSDescResolver(G), 0);
520 EntryBlock.addEdge(aarch64::Pointer64, 8,
521 TLSInfoTableManager.getEntryForTarget(G, Target), 0);
522 return G.addAnonymousSymbol(EntryBlock, 0, 8, false, false);
523 }
524
525private:
526 Section &getTLSDescSection(LinkGraph &G) {
527 if (!GOTSection)
528 GOTSection = &G.createSection(getSectionName(), orc::MemProt::Read);
529 return *GOTSection;
530 }
531
532 Symbol &getTLSDescResolver(LinkGraph &G) {
533 if (!TLSDescResolver)
534 TLSDescResolver = &G.addExternalSymbol("__tlsdesc_resolver", 8, false);
535 return *TLSDescResolver;
536 }
537
538 ArrayRef<char> getTLSDescBlockContent() {
539 return {reinterpret_cast<const char *>(TLSDescEntryContent),
540 sizeof(TLSDescEntryContent)};
541 }
542
543 Section *GOTSection = nullptr;
544 Symbol *TLSDescResolver = nullptr;
545 TLSInfoTableManager_ELF_aarch64 &TLSInfoTableManager;
546};
547
548const uint8_t TLSDescTableManager_ELF_aarch64::TLSDescEntryContent[16] = {
549 0x00, 0x00, 0x00, 0x00,
550 0x00, 0x00, 0x00, 0x00, /*resolver function pointer*/
551 0x00, 0x00, 0x00, 0x00,
552 0x00, 0x00, 0x00, 0x00 /*pointer to tls info*/
553};
554
555Error buildTables_ELF_aarch64(LinkGraph &G) {
556 LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
557
560 TLSInfoTableManager_ELF_aarch64 TLSInfo;
561 TLSDescTableManager_ELF_aarch64 TLSDesc(TLSInfo);
562 visitExistingEdges(G, GOT, PLT, TLSDesc, TLSInfo);
563 return Error::success();
564}
565
566} // namespace
567
568namespace llvm {
569namespace jitlink {
570
573 LLVM_DEBUG({
574 dbgs() << "Building jitlink graph for new input "
575 << ObjectBuffer.getBufferIdentifier() << "...\n";
576 });
577
578 auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
579 if (!ELFObj)
580 return ELFObj.takeError();
581
582 auto Features = (*ELFObj)->getFeatures();
583 if (!Features)
584 return Features.takeError();
585
586 assert((*ELFObj)->getArch() == Triple::aarch64 &&
587 "Only AArch64 (little endian) is supported for now");
588
589 auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
590 return ELFLinkGraphBuilder_aarch64<object::ELF64LE>(
591 (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
592 (*ELFObj)->makeTriple(), std::move(*Features))
593 .buildGraph();
594}
595
596void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
597 std::unique_ptr<JITLinkContext> Ctx) {
599 const Triple &TT = G->getTargetTriple();
600 if (Ctx->shouldAddDefaultTargetPasses(TT)) {
601 // Add eh-frame passes.
602 Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
603 Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
604 ".eh_frame", 8, aarch64::Pointer32, aarch64::Pointer64,
606 Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
607
608 // Add a mark-live pass.
609 if (auto MarkLive = Ctx->getMarkLivePass(TT))
610 Config.PrePrunePasses.push_back(std::move(MarkLive));
611 else
612 Config.PrePrunePasses.push_back(markAllSymbolsLive);
613
614 // Add an in-place GOT/TLS/Stubs build pass.
615 Config.PostPrunePasses.push_back(buildTables_ELF_aarch64);
616 }
617
618 if (auto Err = Ctx->modifyPassConfig(*G, Config))
619 return Ctx->notifyFailed(std::move(Err));
620
621 ELFJITLinker_aarch64::link(std::move(Ctx), std::move(G), std::move(Config));
622}
623
624} // namespace jitlink
625} // namespace llvm
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_DEBUG(X)
Definition: Debug.h:101
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
Definition: Debug.h:64
RelaxConfig Config
Definition: ELF_riscv.cpp:495
#define G(x, y, z)
Definition: MD5.cpp:56
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
const T * data() const
Definition: ArrayRef.h:162
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
StringRef getBufferIdentifier() const
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Manages the enabling and disabling of subtarget specific features.
Target - Wrapper for Target specific information.
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
static Expected< std::unique_ptr< ObjectFile > > createELFObjectFile(MemoryBufferRef Object, bool InitContent=true)
Represents an address in the executor process.
@ EM_AARCH64
Definition: ELF.h:280
StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type)
Definition: ELF.cpp:23
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:440
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163