LLVM 17.0.0git
ELFObject.h
Go to the documentation of this file.
1//===- ELFObject.h ----------------------------------------------*- C++ -*-===//
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#ifndef LLVM_LIB_OBJCOPY_ELF_ELFOBJECT_H
10#define LLVM_LIB_OBJCOPY_ELF_ELFOBJECT_H
11
12#include "llvm/ADT/ArrayRef.h"
13#include "llvm/ADT/StringRef.h"
14#include "llvm/ADT/Twine.h"
19#include "llvm/Support/Errc.h"
22#include <cstddef>
23#include <cstdint>
24#include <functional>
25#include <memory>
26#include <set>
27#include <vector>
28
29namespace llvm {
30enum class DebugCompressionType;
31namespace objcopy {
32namespace elf {
33
34class SectionBase;
35class Section;
36class OwnedDataSection;
37class StringTableSection;
38class SymbolTableSection;
39class RelocationSection;
40class DynamicRelocationSection;
41class GnuDebugLinkSection;
42class GroupSection;
43class SectionIndexSection;
44class CompressedSection;
45class DecompressedSection;
46class Segment;
47class Object;
48struct Symbol;
49
52
53public:
55
56 explicit SectionTableRef(ArrayRef<std::unique_ptr<SectionBase>> Secs)
57 : Sections(Secs) {}
58 SectionTableRef(const SectionTableRef &) = default;
59
60 iterator begin() const { return iterator(Sections.data()); }
61 iterator end() const { return iterator(Sections.data() + Sections.size()); }
62 size_t size() const { return Sections.size(); }
63
65
66 template <class T>
68 Twine TypeErrMsg);
69};
70
72
74public:
75 virtual ~SectionVisitor() = default;
76
77 virtual Error visit(const Section &Sec) = 0;
78 virtual Error visit(const OwnedDataSection &Sec) = 0;
79 virtual Error visit(const StringTableSection &Sec) = 0;
80 virtual Error visit(const SymbolTableSection &Sec) = 0;
81 virtual Error visit(const RelocationSection &Sec) = 0;
82 virtual Error visit(const DynamicRelocationSection &Sec) = 0;
83 virtual Error visit(const GnuDebugLinkSection &Sec) = 0;
84 virtual Error visit(const GroupSection &Sec) = 0;
85 virtual Error visit(const SectionIndexSection &Sec) = 0;
86 virtual Error visit(const CompressedSection &Sec) = 0;
87 virtual Error visit(const DecompressedSection &Sec) = 0;
88};
89
91public:
92 virtual ~MutableSectionVisitor() = default;
93
94 virtual Error visit(Section &Sec) = 0;
95 virtual Error visit(OwnedDataSection &Sec) = 0;
96 virtual Error visit(StringTableSection &Sec) = 0;
97 virtual Error visit(SymbolTableSection &Sec) = 0;
98 virtual Error visit(RelocationSection &Sec) = 0;
100 virtual Error visit(GnuDebugLinkSection &Sec) = 0;
101 virtual Error visit(GroupSection &Sec) = 0;
102 virtual Error visit(SectionIndexSection &Sec) = 0;
103 virtual Error visit(CompressedSection &Sec) = 0;
104 virtual Error visit(DecompressedSection &Sec) = 0;
105};
106
108protected:
110
111public:
112 virtual ~SectionWriter() = default;
113
114 Error visit(const Section &Sec) override;
115 Error visit(const OwnedDataSection &Sec) override;
116 Error visit(const StringTableSection &Sec) override;
117 Error visit(const DynamicRelocationSection &Sec) override;
118 Error visit(const SymbolTableSection &Sec) override = 0;
119 Error visit(const RelocationSection &Sec) override = 0;
120 Error visit(const GnuDebugLinkSection &Sec) override = 0;
121 Error visit(const GroupSection &Sec) override = 0;
122 Error visit(const SectionIndexSection &Sec) override = 0;
123 Error visit(const CompressedSection &Sec) override = 0;
124 Error visit(const DecompressedSection &Sec) override = 0;
125
126 explicit SectionWriter(WritableMemoryBuffer &Buf) : Out(Buf) {}
127};
128
129template <class ELFT> class ELFSectionWriter : public SectionWriter {
130private:
131 using Elf_Word = typename ELFT::Word;
132 using Elf_Rel = typename ELFT::Rel;
133 using Elf_Rela = typename ELFT::Rela;
134 using Elf_Sym = typename ELFT::Sym;
135
136public:
137 virtual ~ELFSectionWriter() {}
138 Error visit(const SymbolTableSection &Sec) override;
139 Error visit(const RelocationSection &Sec) override;
140 Error visit(const GnuDebugLinkSection &Sec) override;
141 Error visit(const GroupSection &Sec) override;
142 Error visit(const SectionIndexSection &Sec) override;
143 Error visit(const CompressedSection &Sec) override;
144 Error visit(const DecompressedSection &Sec) override;
145
147};
148
149template <class ELFT> class ELFSectionSizer : public MutableSectionVisitor {
150private:
151 using Elf_Rel = typename ELFT::Rel;
152 using Elf_Rela = typename ELFT::Rela;
153 using Elf_Sym = typename ELFT::Sym;
154 using Elf_Word = typename ELFT::Word;
155 using Elf_Xword = typename ELFT::Xword;
156
157public:
158 Error visit(Section &Sec) override;
159 Error visit(OwnedDataSection &Sec) override;
160 Error visit(StringTableSection &Sec) override;
161 Error visit(DynamicRelocationSection &Sec) override;
162 Error visit(SymbolTableSection &Sec) override;
163 Error visit(RelocationSection &Sec) override;
164 Error visit(GnuDebugLinkSection &Sec) override;
165 Error visit(GroupSection &Sec) override;
166 Error visit(SectionIndexSection &Sec) override;
167 Error visit(CompressedSection &Sec) override;
168 Error visit(DecompressedSection &Sec) override;
169};
170
171#define MAKE_SEC_WRITER_FRIEND \
172 friend class SectionWriter; \
173 friend class IHexSectionWriterBase; \
174 friend class IHexSectionWriter; \
175 template <class ELFT> friend class ELFSectionWriter; \
176 template <class ELFT> friend class ELFSectionSizer;
177
179public:
181
182 Error visit(const SymbolTableSection &Sec) override;
183 Error visit(const RelocationSection &Sec) override;
184 Error visit(const GnuDebugLinkSection &Sec) override;
185 Error visit(const GroupSection &Sec) override;
186 Error visit(const SectionIndexSection &Sec) override;
187 Error visit(const CompressedSection &Sec) override;
188 Error visit(const DecompressedSection &Sec) override;
189
191 : SectionWriter(Buf) {}
192};
193
195
197 // Memory address of the record.
199 // Record type (see below).
201 // Record data in hexadecimal form.
203
204 // Helper method to get file length of the record
205 // including newline character
206 static size_t getLength(size_t DataSize) {
207 // :LLAAAATT[DD...DD]CC'
208 return DataSize * 2 + 11;
209 }
210
211 // Gets length of line in a file (getLength + CRLF).
212 static size_t getLineLength(size_t DataSize) {
213 return getLength(DataSize) + 2;
214 }
215
216 // Given type, address and data returns line which can
217 // be written to output file.
218 static IHexLineData getLine(uint8_t Type, uint16_t Addr,
220
221 // Parses the line and returns record if possible.
222 // Line should be trimmed from whitespace characters.
224
225 // Calculates checksum of stringified record representation
226 // S must NOT contain leading ':' and trailing whitespace
227 // characters
228 static uint8_t getChecksum(StringRef S);
229
230 enum Type {
231 // Contains data and a 16-bit starting address for the data.
232 // The byte count specifies number of data bytes in the record.
233 Data = 0,
234 // Must occur exactly once per file in the last line of the file.
235 // The data field is empty (thus byte count is 00) and the address
236 // field is typically 0000.
238 // The data field contains a 16-bit segment base address (thus byte
239 // count is always 02) compatible with 80x86 real mode addressing.
240 // The address field (typically 0000) is ignored. The segment address
241 // from the most recent 02 record is multiplied by 16 and added to each
242 // subsequent data record address to form the physical starting address
243 // for the data. This allows addressing up to one megabyte of address
244 // space.
246 // or 80x86 processors, specifies the initial content of the CS:IP
247 // registers. The address field is 0000, the byte count is always 04,
248 // the first two data bytes are the CS value, the latter two are the
249 // IP value.
251 // Allows for 32 bit addressing (up to 4GiB). The record's address field
252 // is ignored (typically 0000) and its byte count is always 02. The two
253 // data bytes (big endian) specify the upper 16 bits of the 32 bit
254 // absolute address for all subsequent type 00 records
256 // The address field is 0000 (not used) and the byte count is always 04.
257 // The four data bytes represent a 32-bit address value. In the case of
258 // 80386 and higher CPUs, this address is loaded into the EIP register.
260 // We have no other valid types
261 InvalidType = 6
262 };
263};
264
265// Base class for IHexSectionWriter. This class implements writing algorithm,
266// but doesn't actually write records. It is used for output buffer size
267// calculation in IHexWriter::finalize.
269 // 20-bit segment address
270 uint32_t SegmentAddr = 0;
271 // Extended linear address
272 uint32_t BaseAddr = 0;
273
274 // Write segment address corresponding to 'Addr'
275 uint64_t writeSegmentAddr(uint64_t Addr);
276 // Write extended linear (base) address corresponding to 'Addr'
277 uint64_t writeBaseAddr(uint64_t Addr);
278
279protected:
280 // Offset in the output buffer
282
284 virtual void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data);
285
286public:
288 : BinarySectionWriter(Buf) {}
289
290 uint64_t getBufferOffset() const { return Offset; }
291 Error visit(const Section &Sec) final;
292 Error visit(const OwnedDataSection &Sec) final;
293 Error visit(const StringTableSection &Sec) override;
294 Error visit(const DynamicRelocationSection &Sec) final;
296};
297
298// Real IHEX section writer
300public:
302
303 void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data) override;
304 Error visit(const StringTableSection &Sec) override;
305};
306
307class Writer {
308protected:
310 std::unique_ptr<WritableMemoryBuffer> Buf;
312
313public:
314 virtual ~Writer();
315 virtual Error finalize() = 0;
316 virtual Error write() = 0;
317
319};
320
321template <class ELFT> class ELFWriter : public Writer {
322private:
323 using Elf_Addr = typename ELFT::Addr;
324 using Elf_Shdr = typename ELFT::Shdr;
325 using Elf_Phdr = typename ELFT::Phdr;
326 using Elf_Ehdr = typename ELFT::Ehdr;
327
328 void initEhdrSegment();
329
330 void writeEhdr();
331 void writePhdr(const Segment &Seg);
332 void writeShdr(const SectionBase &Sec);
333
334 void writePhdrs();
335 void writeShdrs();
336 Error writeSectionData();
337 void writeSegmentData();
338
339 void assignOffsets();
340
341 std::unique_ptr<ELFSectionWriter<ELFT>> SecWriter;
342
343 size_t totalSize() const;
344
345public:
346 virtual ~ELFWriter() {}
348
349 // For --only-keep-debug, select an alternative section/segment layout
350 // algorithm.
352
353 Error finalize() override;
354 Error write() override;
355 ELFWriter(Object &Obj, raw_ostream &Out, bool WSH, bool OnlyKeepDebug);
356};
357
358class BinaryWriter : public Writer {
359private:
360 std::unique_ptr<BinarySectionWriter> SecWriter;
361
362 uint64_t TotalSize = 0;
363
364public:
366 Error finalize() override;
367 Error write() override;
369};
370
371class IHexWriter : public Writer {
372 struct SectionCompare {
373 bool operator()(const SectionBase *Lhs, const SectionBase *Rhs) const;
374 };
375
376 std::set<const SectionBase *, SectionCompare> Sections;
377 size_t TotalSize = 0;
378
379 Error checkSection(const SectionBase &Sec);
380 uint64_t writeEntryPointRecord(uint8_t *Buf);
381 uint64_t writeEndOfFileRecord(uint8_t *Buf);
382
383public:
385 Error finalize() override;
386 Error write() override;
388};
389
391public:
392 std::string Name;
396
400 uint64_t OriginalOffset = std::numeric_limits<uint64_t>::max();
401
413 bool HasSymbol = false;
414
415 SectionBase() = default;
416 SectionBase(const SectionBase &) = default;
417
418 virtual ~SectionBase() = default;
419
420 virtual Error initialize(SectionTableRef SecTable);
421 virtual void finalize();
422 // Remove references to these sections. The list of sections must be sorted.
423 virtual Error
424 removeSectionReferences(bool AllowBrokenLinks,
425 function_ref<bool(const SectionBase *)> ToRemove);
426 virtual Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
427 virtual Error accept(SectionVisitor &Visitor) const = 0;
428 virtual Error accept(MutableSectionVisitor &Visitor) = 0;
429 virtual void markSymbols();
430 virtual void
432 virtual bool hasContents() const { return false; }
433 // Notify the section that it is subject to removal.
434 virtual void onRemove();
435};
436
437class Segment {
438private:
439 struct SectionCompare {
440 bool operator()(const SectionBase *Lhs, const SectionBase *Rhs) const {
441 // Some sections might have the same address if one of them is empty. To
442 // fix this we can use the lexicographic ordering on ->Addr and the
443 // original index.
444 if (Lhs->OriginalOffset == Rhs->OriginalOffset)
445 return Lhs->OriginalIndex < Rhs->OriginalIndex;
446 return Lhs->OriginalOffset < Rhs->OriginalOffset;
447 }
448 };
449
450public:
459
464 std::set<const SectionBase *, SectionCompare> Sections;
465
467 Segment() = default;
468
469 const SectionBase *firstSection() const {
470 if (!Sections.empty())
471 return *Sections.begin();
472 return nullptr;
473 }
474
475 void removeSection(const SectionBase *Sec) { Sections.erase(Sec); }
476 void addSection(const SectionBase *Sec) { Sections.insert(Sec); }
477
479};
480
481class Section : public SectionBase {
483
484 ArrayRef<uint8_t> Contents;
485 SectionBase *LinkSection = nullptr;
486
487public:
488 explicit Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
489
490 Error accept(SectionVisitor &Visitor) const override;
491 Error accept(MutableSectionVisitor &Visitor) override;
493 bool AllowBrokenLinks,
494 function_ref<bool(const SectionBase *)> ToRemove) override;
495 Error initialize(SectionTableRef SecTable) override;
496 void finalize() override;
497 bool hasContents() const override {
498 return Type != ELF::SHT_NOBITS && Type != ELF::SHT_NULL;
499 }
500};
501
504
505 std::vector<uint8_t> Data;
506
507public:
509 : Data(std::begin(Data), std::end(Data)) {
510 Name = SecName.str();
512 Size = Data.size();
513 OriginalOffset = std::numeric_limits<uint64_t>::max();
514 }
515
516 OwnedDataSection(const Twine &SecName, uint64_t SecAddr, uint64_t SecFlags,
517 uint64_t SecOff) {
518 Name = SecName.str();
520 Addr = SecAddr;
521 Flags = OriginalFlags = SecFlags;
522 OriginalOffset = SecOff;
523 }
524
526 : SectionBase(S), Data(std::begin(Data), std::end(Data)) {
527 Size = Data.size();
528 }
529
530 void appendHexData(StringRef HexData);
531 Error accept(SectionVisitor &Sec) const override;
532 Error accept(MutableSectionVisitor &Visitor) override;
533 bool hasContents() const override { return true; }
534};
535
538
539 uint32_t ChType = 0;
540 DebugCompressionType CompressionType;
541 uint64_t DecompressedSize;
542 uint64_t DecompressedAlign;
543 SmallVector<uint8_t, 128> CompressedData;
544
545public:
547 DebugCompressionType CompressionType, bool Is64Bits);
548 CompressedSection(ArrayRef<uint8_t> CompressedData, uint32_t ChType,
549 uint64_t DecompressedSize, uint64_t DecompressedAlign);
550
551 uint64_t getDecompressedSize() const { return DecompressedSize; }
552 uint64_t getDecompressedAlign() const { return DecompressedAlign; }
553 uint64_t getChType() const { return ChType; }
554
555 Error accept(SectionVisitor &Visitor) const override;
556 Error accept(MutableSectionVisitor &Visitor) override;
557
558 static bool classof(const SectionBase *S) {
560 }
561};
562
565
566public:
569 : SectionBase(Sec), ChType(Sec.getChType()) {
572 Flags = OriginalFlags = (Flags & ~ELF::SHF_COMPRESSED);
573 }
574
575 Error accept(SectionVisitor &Visitor) const override;
576 Error accept(MutableSectionVisitor &Visitor) override;
577};
578
579// There are two types of string tables that can exist, dynamic and not dynamic.
580// In the dynamic case the string table is allocated. Changing a dynamic string
581// table would mean altering virtual addresses and thus the memory image. So
582// dynamic string tables should not have an interface to modify them or
583// reconstruct them. This type lets us reconstruct a string table. To avoid
584// this class being used for dynamic string tables (which has happened) the
585// classof method checks that the particular instance is not allocated. This
586// then agrees with the makeSection method used to construct most sections.
589
590 StringTableBuilder StrTabBuilder;
591
592public:
595 }
596
599 void prepareForLayout();
600 Error accept(SectionVisitor &Visitor) const override;
601 Error accept(MutableSectionVisitor &Visitor) override;
602
603 static bool classof(const SectionBase *S) {
605 return false;
606 return S->OriginalType == ELF::SHT_STRTAB;
607 }
608};
609
610// Symbols have a st_shndx field that normally stores an index but occasionally
611// stores a different special value. This enum keeps track of what the st_shndx
612// field means. Most of the values are just copies of the special SHN_* values.
613// SYMBOL_SIMPLE_INDEX means that the st_shndx is just an index of a section.
633};
634
635struct Symbol {
636 uint8_t Binding;
640 std::string Name;
643 uint8_t Type;
645 uint8_t Visibility;
646 bool Referenced = false;
647
648 uint16_t getShndx() const;
649 bool isCommon() const;
650};
651
654
655private:
656 std::vector<uint32_t> Indexes;
657 SymbolTableSection *Symbols = nullptr;
658
659public:
662 assert(Size > 0);
663 Indexes.push_back(Index);
664 }
665
666 void reserve(size_t NumSymbols) {
667 Indexes.reserve(NumSymbols);
668 Size = NumSymbols * 4;
669 }
670 void setSymTab(SymbolTableSection *SymTab) { Symbols = SymTab; }
671 Error initialize(SectionTableRef SecTable) override;
672 void finalize() override;
673 Error accept(SectionVisitor &Visitor) const override;
674 Error accept(MutableSectionVisitor &Visitor) override;
675
677 Name = ".symtab_shndx";
678 Align = 4;
679 EntrySize = 4;
681 }
682};
683
686
687 void setStrTab(StringTableSection *StrTab) { SymbolNames = StrTab; }
688 void assignIndices();
689
690protected:
691 std::vector<std::unique_ptr<Symbol>> Symbols;
694
695 using SymPtr = std::unique_ptr<Symbol>;
696
697public:
699
700 void addSymbol(Twine Name, uint8_t Bind, uint8_t Type, SectionBase *DefinedIn,
701 uint64_t Value, uint8_t Visibility, uint16_t Shndx,
702 uint64_t SymbolSize);
703 void prepareForLayout();
704 // An 'empty' symbol table still contains a null symbol.
705 bool empty() const { return Symbols.size() == 1; }
707 SectionIndexTable = ShndxTable;
708 }
710 void fillShndxTable();
711 const SectionBase *getStrTab() const { return SymbolNames; }
714 void updateSymbols(function_ref<void(Symbol &)> Callable);
715
717 bool AllowBrokenLinks,
718 function_ref<bool(const SectionBase *)> ToRemove) override;
719 Error initialize(SectionTableRef SecTable) override;
720 void finalize() override;
721 Error accept(SectionVisitor &Visitor) const override;
722 Error accept(MutableSectionVisitor &Visitor) override;
723 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
725 const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
726
727 static bool classof(const SectionBase *S) {
728 return S->OriginalType == ELF::SHT_SYMTAB;
729 }
730};
731
733 Symbol *RelocSymbol = nullptr;
737};
738
739// All relocation sections denote relocations to apply to another section.
740// However, some relocation sections use a dynamic symbol table and others use
741// a regular symbol table. Because the types of the two symbol tables differ in
742// our system (because they should behave differently) we can't uniformly
743// represent all relocations with the same base class if we expose an interface
744// that mentions the symbol table type. So we split the two base types into two
745// different classes, one which handles the section the relocation is applied to
746// and another which handles the symbol table type. The symbol table type is
747// taken as a type parameter to the class (see RelocSectionWithSymtabBase).
749protected:
751
752public:
753 const SectionBase *getSection() const { return SecToApplyRel; }
755
756 StringRef getNamePrefix() const;
757
758 static bool classof(const SectionBase *S) {
760 }
761};
762
763// Takes the symbol table type to use as a parameter so that we can deduplicate
764// that code between the two symbol table types.
765template <class SymTabType>
767 void setSymTab(SymTabType *SymTab) { Symbols = SymTab; }
768
769protected:
771
772 SymTabType *Symbols = nullptr;
773
774public:
775 Error initialize(SectionTableRef SecTable) override;
776 void finalize() override;
777};
778
780 : public RelocSectionWithSymtabBase<SymbolTableSection> {
782
783 std::vector<Relocation> Relocations;
784 const Object &Obj;
785
786public:
787 RelocationSection(const Object &O) : Obj(O) {}
788 void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
789 Error accept(SectionVisitor &Visitor) const override;
790 Error accept(MutableSectionVisitor &Visitor) override;
792 bool AllowBrokenLinks,
793 function_ref<bool(const SectionBase *)> ToRemove) override;
794 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
795 void markSymbols() override;
797 const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
798 const Object &getObject() const { return Obj; }
799
800 static bool classof(const SectionBase *S) {
802 return false;
804 }
805};
806
807// TODO: The way stripping and groups interact is complicated
808// and still needs to be worked on.
809
810class GroupSection : public SectionBase {
812 const SymbolTableSection *SymTab = nullptr;
813 Symbol *Sym = nullptr;
814 ELF::Elf32_Word FlagWord;
816
817public:
818 // TODO: Contents is present in several classes of the hierarchy.
819 // This needs to be refactored to avoid duplication.
821
823
824 void setSymTab(const SymbolTableSection *SymTabSec) { SymTab = SymTabSec; }
825 void setSymbol(Symbol *S) { Sym = S; }
826 void setFlagWord(ELF::Elf32_Word W) { FlagWord = W; }
827 void addMember(SectionBase *Sec) { GroupMembers.push_back(Sec); }
828
829 Error accept(SectionVisitor &) const override;
830 Error accept(MutableSectionVisitor &Visitor) override;
831 void finalize() override;
833 bool AllowBrokenLinks,
834 function_ref<bool(const SectionBase *)> ToRemove) override;
835 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
836 void markSymbols() override;
838 const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
839 void onRemove() override;
840
841 static bool classof(const SectionBase *S) {
842 return S->OriginalType == ELF::SHT_GROUP;
843 }
844};
845
847public:
849
850 static bool classof(const SectionBase *S) {
851 return S->OriginalType == ELF::SHT_DYNSYM;
852 }
853};
854
855class DynamicSection : public Section {
856public:
858
859 static bool classof(const SectionBase *S) {
860 return S->OriginalType == ELF::SHT_DYNAMIC;
861 }
862};
863
865 : public RelocSectionWithSymtabBase<DynamicSymbolTableSection> {
867
868private:
869 ArrayRef<uint8_t> Contents;
870
871public:
873
874 Error accept(SectionVisitor &) const override;
875 Error accept(MutableSectionVisitor &Visitor) override;
877 bool AllowBrokenLinks,
878 function_ref<bool(const SectionBase *)> ToRemove) override;
879
880 static bool classof(const SectionBase *S) {
881 if (!(S->OriginalFlags & ELF::SHF_ALLOC))
882 return false;
884 }
885};
886
889
890private:
891 StringRef FileName;
892 uint32_t CRC32;
893
894 void init(StringRef File);
895
896public:
897 // If we add this section from an external source we can use this ctor.
898 explicit GnuDebugLinkSection(StringRef File, uint32_t PrecomputedCRC);
899 Error accept(SectionVisitor &Visitor) const override;
900 Error accept(MutableSectionVisitor &Visitor) override;
901};
902
903class Reader {
904public:
905 virtual ~Reader();
906 virtual Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const = 0;
907};
908
909using object::Binary;
910using object::ELFFile;
913
915protected:
916 std::unique_ptr<Object> Obj;
917
918 void initFileHeader();
919 void initHeaderSegment();
923
924public:
925 BasicELFBuilder() : Obj(std::make_unique<Object>()) {}
926};
927
929 MemoryBuffer *MemBuf;
930 uint8_t NewSymbolVisibility;
931 void addData(SymbolTableSection *SymTab);
932
933public:
934 BinaryELFBuilder(MemoryBuffer *MB, uint8_t NewSymbolVisibility)
935 : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {}
936
938};
939
941 const std::vector<IHexRecord> &Records;
942
943 void addDataSections();
944
945public:
946 IHexELFBuilder(const std::vector<IHexRecord> &Records) : Records(Records) {}
947
949};
950
951template <class ELFT> class ELFBuilder {
952private:
953 using Elf_Addr = typename ELFT::Addr;
954 using Elf_Shdr = typename ELFT::Shdr;
955 using Elf_Word = typename ELFT::Word;
956
957 const ELFFile<ELFT> &ElfFile;
958 Object &Obj;
959 size_t EhdrOffset = 0;
960 std::optional<StringRef> ExtractPartition;
961
962 void setParentSegment(Segment &Child);
963 Error readProgramHeaders(const ELFFile<ELFT> &HeadersFile);
964 Error initGroupSection(GroupSection *GroupSec);
965 Error initSymbolTable(SymbolTableSection *SymTab);
966 Error readSectionHeaders();
967 Error readSections(bool EnsureSymtab);
968 Error findEhdrOffset();
969 Expected<SectionBase &> makeSection(const Elf_Shdr &Shdr);
970
971public:
972 ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj,
973 std::optional<StringRef> ExtractPartition);
974
975 Error build(bool EnsureSymtab);
976};
977
978class BinaryReader : public Reader {
979 MemoryBuffer *MemBuf;
980 uint8_t NewSymbolVisibility;
981
982public:
983 BinaryReader(MemoryBuffer *MB, const uint8_t NewSymbolVisibility)
984 : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {}
985 Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override;
986};
987
988class IHexReader : public Reader {
989 MemoryBuffer *MemBuf;
990
992 Error parseError(size_t LineNo, Error E) const {
993 return LineNo == -1U
994 ? createFileError(MemBuf->getBufferIdentifier(), std::move(E))
995 : createFileError(MemBuf->getBufferIdentifier(), LineNo,
996 std::move(E));
997 }
998 template <typename... Ts>
999 Error parseError(size_t LineNo, char const *Fmt, const Ts &...Vals) const {
1001 return parseError(LineNo, std::move(E));
1002 }
1003
1004public:
1005 IHexReader(MemoryBuffer *MB) : MemBuf(MB) {}
1006
1007 Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override;
1008};
1009
1010class ELFReader : public Reader {
1011 Binary *Bin;
1012 std::optional<StringRef> ExtractPartition;
1013
1014public:
1015 Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override;
1016 explicit ELFReader(Binary *B, std::optional<StringRef> ExtractPartition)
1017 : Bin(B), ExtractPartition(ExtractPartition) {}
1018};
1019
1020class Object {
1021private:
1022 using SecPtr = std::unique_ptr<SectionBase>;
1023 using SegPtr = std::unique_ptr<Segment>;
1024
1025 std::vector<SecPtr> Sections;
1026 std::vector<SegPtr> Segments;
1027 std::vector<SecPtr> RemovedSections;
1029
1030 static bool sectionIsAlloc(const SectionBase &Sec) {
1031 return Sec.Flags & ELF::SHF_ALLOC;
1032 };
1033
1034public:
1035 template <class T>
1037 typename std::vector<std::unique_ptr<T>>::const_iterator>>;
1038
1039 // It is often the case that the ELF header and the program header table are
1040 // not present in any segment. This could be a problem during file layout,
1041 // because other segments may get assigned an offset where either of the
1042 // two should reside, which will effectively corrupt the resulting binary.
1043 // Other than that we use these segments to track program header offsets
1044 // when they may not follow the ELF header.
1047
1049 uint8_t OSABI;
1050 uint8_t ABIVersion;
1057
1058 bool HadShdrs = true;
1059 bool MustBeRelocatable = false;
1063
1064 bool IsMips64EL = false;
1065
1066 SectionTableRef sections() const { return SectionTableRef(Sections); }
1069 decltype(&sectionIsAlloc)>>
1071 return make_filter_range(make_pointee_range(Sections), sectionIsAlloc);
1072 }
1073
1074 const auto &getUpdatedSections() const { return UpdatedSections; }
1076
1078 auto SecIt =
1079 find_if(Sections, [&](const SecPtr &Sec) { return Sec->Name == Name; });
1080 return SecIt == Sections.end() ? nullptr : SecIt->get();
1081 }
1082 SectionTableRef removedSections() { return SectionTableRef(RemovedSections); }
1083
1085
1086 Error removeSections(bool AllowBrokenLinks,
1087 std::function<bool(const SectionBase &)> ToRemove);
1090 template <class T, class... Ts> T &addSection(Ts &&...Args) {
1091 auto Sec = std::make_unique<T>(std::forward<Ts>(Args)...);
1092 auto Ptr = Sec.get();
1093 MustBeRelocatable |= isa<RelocationSection>(*Ptr);
1094 Sections.emplace_back(std::move(Sec));
1095 Ptr->Index = Sections.size();
1096 return *Ptr;
1097 }
1100 Segments.emplace_back(std::make_unique<Segment>(Data));
1101 return *Segments.back();
1102 }
1103 bool isRelocatable() const {
1104 return (Type != ELF::ET_DYN && Type != ELF::ET_EXEC) || MustBeRelocatable;
1105 }
1106};
1107
1108} // end namespace elf
1109} // end namespace objcopy
1110} // end namespace llvm
1111
1112#endif // LLVM_LIB_OBJCOPY_ELF_ELFOBJECT_H
ReachingDefAnalysis InstSet & ToRemove
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Elf_Shdr Shdr
uint64_t Addr
std::string Name
#define MAKE_SEC_WRITER_FRIEND
Definition: ELFObject.h:171
#define T
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
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
const T * data() const
Definition: ArrayRef.h:160
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
Tagged union holding either a T or a Error.
Definition: Error.h:470
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:51
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition: MemoryBuffer.h:76
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:222
Utility for building string tables with deduplicated suffixes.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
This class is an extension of MemoryBuffer, which allows copy-on-write access to the underlying conte...
Definition: MemoryBuffer.h:181
Specialization of filter_iterator_base for forward iteration only.
Definition: STLExtras.h:562
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
StringTableSection * addStrTab()
Definition: ELFObject.cpp:1237
SymbolTableSection * addSymTab(StringTableSection *StrTab)
Definition: ELFObject.cpp:1245
std::unique_ptr< Object > Obj
Definition: ELFObject.h:916
BinaryELFBuilder(MemoryBuffer *MB, uint8_t NewSymbolVisibility)
Definition: ELFObject.h:934
Expected< std::unique_ptr< Object > > build()
Definition: ELFObject.cpp:1291
BinaryReader(MemoryBuffer *MB, const uint8_t NewSymbolVisibility)
Definition: ELFObject.h:983
Expected< std::unique_ptr< Object > > create(bool EnsureSymtab) const override
Definition: ELFObject.cpp:1898
Error visit(const SymbolTableSection &Sec) override
Definition: ELFObject.cpp:148
BinarySectionWriter(WritableMemoryBuffer &Buf)
Definition: ELFObject.h:190
BinaryWriter(Object &Obj, raw_ostream &Out)
Definition: ELFObject.h:368
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:557
static bool classof(const SectionBase *S)
Definition: ELFObject.h:558
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:479
DecompressedSection(const CompressedSection &Sec)
Definition: ELFObject.h:568
Error accept(SectionVisitor &) const override
Definition: ELFObject.cpp:1000
DynamicRelocationSection(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:872
static bool classof(const SectionBase *S)
Definition: ELFObject.h:880
Error removeSectionReferences(bool AllowBrokenLinks, function_ref< bool(const SectionBase *)> ToRemove) override
Definition: ELFObject.cpp:1008
DynamicSection(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:857
static bool classof(const SectionBase *S)
Definition: ELFObject.h:859
static bool classof(const SectionBase *S)
Definition: ELFObject.h:850
DynamicSymbolTableSection(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:848
Error build(bool EnsureSymtab)
Definition: ELFObject.cpp:1864
ELFReader(Binary *B, std::optional< StringRef > ExtractPartition)
Definition: ELFObject.h:1016
Expected< std::unique_ptr< Object > > create(bool EnsureSymtab) const override
Definition: ELFObject.cpp:1937
Error visit(Section &Sec) override
Definition: ELFObject.cpp:83
ELFSectionWriter(WritableMemoryBuffer &Buf)
Definition: ELFObject.h:146
Error visit(const SymbolTableSection &Sec) override
Definition: ELFObject.cpp:832
GroupSection(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:822
void setSymTab(const SymbolTableSection *SymTabSec)
Definition: ELFObject.h:824
void replaceSectionReferences(const DenseMap< SectionBase *, SectionBase * > &FromTo) override
Definition: ELFObject.cpp:1083
Error accept(SectionVisitor &) const override
Definition: ELFObject.cpp:1169
static bool classof(const SectionBase *S)
Definition: ELFObject.h:841
ArrayRef< uint8_t > Contents
Definition: ELFObject.h:820
void addMember(SectionBase *Sec)
Definition: ELFObject.h:827
Error removeSectionReferences(bool AllowBrokenLinks, function_ref< bool(const SectionBase *)> ToRemove) override
Definition: ELFObject.cpp:1053
void setFlagWord(ELF::Elf32_Word W)
Definition: ELFObject.h:826
Error removeSymbols(function_ref< bool(const Symbol &)> ToRemove) override
Definition: ELFObject.cpp:1069
IHexELFBuilder(const std::vector< IHexRecord > &Records)
Definition: ELFObject.h:946
Expected< std::unique_ptr< Object > > build()
Definition: ELFObject.cpp:1351
IHexReader(MemoryBuffer *MB)
Definition: ELFObject.h:1005
Expected< std::unique_ptr< Object > > create(bool EnsureSymtab) const override
Definition: ELFObject.cpp:1929
IHexSectionWriterBase(WritableMemoryBuffer &Buf)
Definition: ELFObject.h:287
void writeSection(const SectionBase *Sec, ArrayRef< uint8_t > Data)
Definition: ELFObject.cpp:335
Error visit(const Section &Sec) final
Definition: ELFObject.cpp:384
virtual void writeData(uint8_t Type, uint16_t Addr, ArrayRef< uint8_t > Data)
Definition: ELFObject.cpp:379
IHexSectionWriter(WritableMemoryBuffer &Buf)
Definition: ELFObject.h:301
void writeData(uint8_t Type, uint16_t Addr, ArrayRef< uint8_t > Data) override
Definition: ELFObject.cpp:409
Error visit(const StringTableSection &Sec) override
Definition: ELFObject.cpp:416
IHexWriter(Object &Obj, raw_ostream &Out)
Definition: ELFObject.h:387
virtual Error visit(OwnedDataSection &Sec)=0
virtual Error visit(SymbolTableSection &Sec)=0
virtual Error visit(DecompressedSection &Sec)=0
virtual Error visit(StringTableSection &Sec)=0
virtual Error visit(GnuDebugLinkSection &Sec)=0
virtual Error visit(SectionIndexSection &Sec)=0
virtual Error visit(DynamicRelocationSection &Sec)=0
virtual Error visit(Section &Sec)=0
virtual Error visit(GroupSection &Sec)=0
virtual Error visit(CompressedSection &Sec)=0
virtual Error visit(RelocationSection &Sec)=0
SectionTableRef sections() const
Definition: ELFObject.h:1066
StringTableSection * SectionNames
Definition: ELFObject.h:1060
SectionTableRef removedSections()
Definition: ELFObject.h:1082
bool isRelocatable() const
Definition: ELFObject.h:1103
iterator_range< filter_iterator< pointee_iterator< std::vector< SecPtr >::const_iterator >, decltype(&sectionIsAlloc)> > allocSections() const
Definition: ELFObject.h:1070
Error updateSection(StringRef Name, ArrayRef< uint8_t > Data)
Definition: ELFObject.cpp:2101
SectionIndexSection * SectionIndexTable
Definition: ELFObject.h:1062
Error removeSymbols(function_ref< bool(const Symbol &)> ToRemove)
Definition: ELFObject.cpp:2208
T & addSection(Ts &&...Args)
Definition: ELFObject.h:1090
Error removeSections(bool AllowBrokenLinks, std::function< bool(const SectionBase &)> ToRemove)
Definition: ELFObject.cpp:2132
Segment & addSegment(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:1099
ConstRange< Segment > segments() const
Definition: ELFObject.h:1084
SymbolTableSection * SymbolTable
Definition: ELFObject.h:1061
const auto & getUpdatedSections() const
Definition: ELFObject.h:1074
SectionBase * findSection(StringRef Name)
Definition: ELFObject.h:1077
Error replaceSections(const DenseMap< SectionBase *, SectionBase * > &FromTo)
Definition: ELFObject.cpp:2184
void appendHexData(StringRef HexData)
Definition: ELFObject.cpp:495
OwnedDataSection(const Twine &SecName, uint64_t SecAddr, uint64_t SecFlags, uint64_t SecOff)
Definition: ELFObject.h:516
Error accept(SectionVisitor &Sec) const override
Definition: ELFObject.cpp:487
OwnedDataSection(StringRef SecName, ArrayRef< uint8_t > Data)
Definition: ELFObject.h:508
OwnedDataSection(SectionBase &S, ArrayRef< uint8_t > Data)
Definition: ELFObject.h:525
bool hasContents() const override
Definition: ELFObject.h:533
virtual Expected< std::unique_ptr< Object > > create(bool EnsureSymtab) const =0
Error initialize(SectionTableRef SecTable) override
Definition: ELFObject.cpp:895
const SectionBase * getSection() const
Definition: ELFObject.h:753
static bool classof(const SectionBase *S)
Definition: ELFObject.h:758
void addRelocation(Relocation Rel)
Definition: ELFObject.h:788
const Object & getObject() const
Definition: ELFObject.h:798
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:963
Error removeSymbols(function_ref< bool(const Symbol &)> ToRemove) override
Definition: ELFObject.cpp:971
void replaceSectionReferences(const DenseMap< SectionBase *, SectionBase * > &FromTo) override
Definition: ELFObject.cpp:988
static bool classof(const SectionBase *S)
Definition: ELFObject.h:800
Error removeSectionReferences(bool AllowBrokenLinks, function_ref< bool(const SectionBase *)> ToRemove) override
Definition: ELFObject.cpp:867
ArrayRef< uint8_t > OriginalData
Definition: ELFObject.h:412
virtual Error initialize(SectionTableRef SecTable)
Definition: ELFObject.cpp:60
virtual Error removeSectionReferences(bool AllowBrokenLinks, function_ref< bool(const SectionBase *)> ToRemove)
Definition: ELFObject.cpp:51
virtual void replaceSectionReferences(const DenseMap< SectionBase *, SectionBase * > &)
Definition: ELFObject.cpp:63
virtual Error accept(MutableSectionVisitor &Visitor)=0
virtual ~SectionBase()=default
virtual bool hasContents() const
Definition: ELFObject.h:432
SectionBase(const SectionBase &)=default
virtual Error removeSymbols(function_ref< bool(const Symbol &)> ToRemove)
Definition: ELFObject.cpp:56
virtual Error accept(SectionVisitor &Visitor) const =0
void setSymTab(SymbolTableSection *SymTab)
Definition: ELFObject.h:670
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:616
void reserve(size_t NumSymbols)
Definition: ELFObject.h:666
Error initialize(SectionTableRef SecTable) override
Definition: ELFObject.cpp:597
pointee_iterator< const std::unique_ptr< SectionBase > * > iterator
Definition: ELFObject.h:54
Expected< T * > getSectionOfType(uint32_t Index, Twine IndexErrMsg, Twine TypeErrMsg)
Definition: ELFObject.cpp:1647
SectionTableRef(ArrayRef< std::unique_ptr< SectionBase > > Secs)
Definition: ELFObject.h:56
SectionTableRef(const SectionTableRef &)=default
Expected< SectionBase * > getSection(uint32_t Index, Twine ErrMsg)
Definition: ELFObject.cpp:1639
virtual Error visit(const CompressedSection &Sec)=0
virtual Error visit(const Section &Sec)=0
virtual Error visit(const DecompressedSection &Sec)=0
virtual Error visit(const GroupSection &Sec)=0
virtual Error visit(const SymbolTableSection &Sec)=0
virtual Error visit(const RelocationSection &Sec)=0
virtual Error visit(const SectionIndexSection &Sec)=0
virtual Error visit(const DynamicRelocationSection &Sec)=0
virtual Error visit(const GnuDebugLinkSection &Sec)=0
virtual Error visit(const StringTableSection &Sec)=0
virtual Error visit(const OwnedDataSection &Sec)=0
Error visit(const GroupSection &Sec) override=0
Error visit(const RelocationSection &Sec) override=0
Error visit(const SectionIndexSection &Sec) override=0
Error visit(const CompressedSection &Sec) override=0
Error visit(const Section &Sec) override
Definition: ELFObject.cpp:170
Error visit(const GnuDebugLinkSection &Sec) override=0
Error visit(const SymbolTableSection &Sec) override=0
WritableMemoryBuffer & Out
Definition: ELFObject.h:109
Error visit(const DecompressedSection &Sec) override=0
SectionWriter(WritableMemoryBuffer &Buf)
Definition: ELFObject.h:126
Error removeSectionReferences(bool AllowBrokenLinks, function_ref< bool(const SectionBase *)> ToRemove) override
Definition: ELFObject.cpp:1028
Error initialize(SectionTableRef SecTable) override
Definition: ELFObject.cpp:1097
Section(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:488
bool hasContents() const override
Definition: ELFObject.h:497
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:424
void addSection(const SectionBase *Sec)
Definition: ELFObject.h:476
Segment(ArrayRef< uint8_t > Data)
Definition: ELFObject.h:466
ArrayRef< uint8_t > Contents
Definition: ELFObject.h:463
void removeSection(const SectionBase *Sec)
Definition: ELFObject.h:475
const SectionBase * firstSection() const
Definition: ELFObject.h:469
ArrayRef< uint8_t > getContents() const
Definition: ELFObject.h:478
std::set< const SectionBase *, SectionCompare > Sections
Definition: ELFObject.h:464
static bool classof(const SectionBase *S)
Definition: ELFObject.h:603
uint32_t findIndex(StringRef Name) const
Definition: ELFObject.cpp:567
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:582
const SectionBase * getStrTab() const
Definition: ELFObject.h:711
Error removeSectionReferences(bool AllowBrokenLinks, function_ref< bool(const SectionBase *)> ToRemove) override
Definition: ELFObject.cpp:712
const SectionIndexSection * getShndxTable() const
Definition: ELFObject.h:709
std::vector< std::unique_ptr< Symbol > > Symbols
Definition: ELFObject.h:691
SectionIndexSection * SectionIndexTable
Definition: ELFObject.h:693
Error accept(SectionVisitor &Visitor) const override
Definition: ELFObject.cpp:848
void addSymbol(Twine Name, uint8_t Bind, uint8_t Type, SectionBase *DefinedIn, uint64_t Value, uint8_t Visibility, uint16_t Shndx, uint64_t SymbolSize)
Definition: ELFObject.cpp:687
void updateSymbols(function_ref< void(Symbol &)> Callable)
Definition: ELFObject.cpp:729
static bool classof(const SectionBase *S)
Definition: ELFObject.h:727
Expected< const Symbol * > getSymbolByIndex(uint32_t Index) const
Definition: ELFObject.cpp:815
Error removeSymbols(function_ref< bool(const Symbol &)> ToRemove) override
Definition: ELFObject.cpp:738
Error initialize(SectionTableRef SecTable) override
Definition: ELFObject.cpp:756
void replaceSectionReferences(const DenseMap< SectionBase *, SectionBase * > &FromTo) override
Definition: ELFObject.cpp:749
std::unique_ptr< Symbol > SymPtr
Definition: ELFObject.h:695
void setShndxTable(SectionIndexSection *ShndxTable)
Definition: ELFObject.h:706
StringTableSection * SymbolNames
Definition: ELFObject.h:692
virtual Error finalize()=0
virtual Error write()=0
std::unique_ptr< WritableMemoryBuffer > Buf
Definition: ELFObject.h:310
Writer(Object &O, raw_ostream &Out)
Definition: ELFObject.h:318
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
@ SHF_ALLOC
Definition: ELF.h:1083
@ SHF_COMPRESSED
Definition: ELF.h:1111
@ SHN_AMDGPU_LDS
Definition: ELF.h:1748
@ SHN_XINDEX
Definition: ELF.h:988
@ SHN_HIOS
Definition: ELF.h:985
@ SHN_ABS
Definition: ELF.h:986
@ SHN_COMMON
Definition: ELF.h:987
@ SHN_LOOS
Definition: ELF.h:984
@ SHN_LOPROC
Definition: ELF.h:982
@ SHN_UNDEF
Definition: ELF.h:980
@ SHN_HIPROC
Definition: ELF.h:983
@ SHT_STRTAB
Definition: ELF.h:997
@ SHT_GROUP
Definition: ELF.h:1009
@ SHT_PROGBITS
Definition: ELF.h:995
@ SHT_REL
Definition: ELF.h:1003
@ SHT_NULL
Definition: ELF.h:994
@ SHT_NOBITS
Definition: ELF.h:1002
@ SHT_SYMTAB
Definition: ELF.h:996
@ SHT_DYNAMIC
Definition: ELF.h:1000
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:1010
@ SHT_RELA
Definition: ELF.h:998
@ SHT_DYNSYM
Definition: ELF.h:1005
@ ET_DYN
Definition: ELF.h:118
@ ET_EXEC
Definition: ELF.h:117
@ SHN_MIPS_TEXT
Definition: ELF.h:571
@ SHN_MIPS_DATA
Definition: ELF.h:572
@ SHN_MIPS_SUNDEFINED
Definition: ELF.h:574
@ SHN_MIPS_SCOMMON
Definition: ELF.h:573
@ SHN_MIPS_ACOMMON
Definition: ELF.h:570
@ SHN_HEXAGON_SCOMMON_2
Definition: ELF.h:653
@ SHN_HEXAGON_SCOMMON_4
Definition: ELF.h:654
@ SHN_HEXAGON_SCOMMON_8
Definition: ELF.h:655
@ SHN_HEXAGON_SCOMMON
Definition: ELF.h:651
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
Definition: Error.h:1327
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1246
iterator_range< pointee_iterator< WrappedIteratorT > > make_pointee_range(RangeT &&Range)
Definition: iterator.h:336
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
Definition: STLExtras.h:637
DebugCompressionType
Definition: Compression.h:27
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1762
Definition: BitVector.h:851
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
static IHexLineData getLine(uint8_t Type, uint16_t Addr, ArrayRef< uint8_t > Data)
Definition: ELFObject.cpp:216
static uint8_t getChecksum(StringRef S)
Definition: ELFObject.cpp:206
static size_t getLength(size_t DataSize)
Definition: ELFObject.h:206
static size_t getLineLength(size_t DataSize)
Definition: ELFObject.h:212
uint16_t getShndx() const
Definition: ELFObject.cpp:660
SectionBase * DefinedIn
Definition: ELFObject.h:637
SymbolShndxType ShndxType
Definition: ELFObject.h:638
An iterator type that allows iterating over the pointees via some other iterator.
Definition: iterator.h:324
Definition: regcomp.c:192