xref: /freebsd/contrib/llvm-project/llvm/lib/ObjCopy/ELF/ELFObject.h (revision 9f23cbd6cae82fd77edfad7173432fa8dccd0a95)
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"
15 #include "llvm/BinaryFormat/ELF.h"
16 #include "llvm/MC/StringTableBuilder.h"
17 #include "llvm/ObjCopy/CommonConfig.h"
18 #include "llvm/Object/ELFObjectFile.h"
19 #include "llvm/Support/Errc.h"
20 #include "llvm/Support/FileOutputBuffer.h"
21 #include "llvm/Support/MemoryBuffer.h"
22 #include <cstddef>
23 #include <cstdint>
24 #include <functional>
25 #include <memory>
26 #include <set>
27 #include <vector>
28 
29 namespace llvm {
30 enum class DebugCompressionType;
31 namespace objcopy {
32 namespace elf {
33 
34 class SectionBase;
35 class Section;
36 class OwnedDataSection;
37 class StringTableSection;
38 class SymbolTableSection;
39 class RelocationSection;
40 class DynamicRelocationSection;
41 class GnuDebugLinkSection;
42 class GroupSection;
43 class SectionIndexSection;
44 class CompressedSection;
45 class DecompressedSection;
46 class Segment;
47 class Object;
48 struct Symbol;
49 
50 class SectionTableRef {
51   ArrayRef<std::unique_ptr<SectionBase>> Sections;
52 
53 public:
54   using iterator = pointee_iterator<const std::unique_ptr<SectionBase> *>;
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 
64   Expected<SectionBase *> getSection(uint32_t Index, Twine ErrMsg);
65 
66   template <class T>
67   Expected<T *> getSectionOfType(uint32_t Index, Twine IndexErrMsg,
68                                  Twine TypeErrMsg);
69 };
70 
71 enum ElfType { ELFT_ELF32LE, ELFT_ELF64LE, ELFT_ELF32BE, ELFT_ELF64BE };
72 
73 class SectionVisitor {
74 public:
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 
90 class MutableSectionVisitor {
91 public:
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;
99   virtual Error visit(DynamicRelocationSection &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 
107 class SectionWriter : public SectionVisitor {
108 protected:
109   WritableMemoryBuffer &Out;
110 
111 public:
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 
129 template <class ELFT> class ELFSectionWriter : public SectionWriter {
130 private:
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 
136 public:
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 
146   explicit ELFSectionWriter(WritableMemoryBuffer &Buf) : SectionWriter(Buf) {}
147 };
148 
149 template <class ELFT> class ELFSectionSizer : public MutableSectionVisitor {
150 private:
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 
157 public:
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 
178 class BinarySectionWriter : public SectionWriter {
179 public:
180   virtual ~BinarySectionWriter() {}
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 
190   explicit BinarySectionWriter(WritableMemoryBuffer &Buf)
191       : SectionWriter(Buf) {}
192 };
193 
194 using IHexLineData = SmallVector<char, 64>;
195 
196 struct IHexRecord {
197   // Memory address of the record.
198   uint16_t Addr;
199   // Record type (see below).
200   uint16_t Type;
201   // Record data in hexadecimal form.
202   StringRef HexData;
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,
219                               ArrayRef<uint8_t> Data);
220 
221   // Parses the line and returns record if possible.
222   // Line should be trimmed from whitespace characters.
223   static Expected<IHexRecord> parse(StringRef Line);
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.
237     EndOfFile = 1,
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.
245     SegmentAddr = 2,
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.
250     StartAddr80x86 = 3,
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
255     ExtendedAddr = 4,
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.
259     StartAddr = 5,
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.
268 class IHexSectionWriterBase : public BinarySectionWriter {
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 
279 protected:
280   // Offset in the output buffer
281   uint64_t Offset = 0;
282 
283   void writeSection(const SectionBase *Sec, ArrayRef<uint8_t> Data);
284   virtual void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data);
285 
286 public:
287   explicit IHexSectionWriterBase(WritableMemoryBuffer &Buf)
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;
295   using BinarySectionWriter::visit;
296 };
297 
298 // Real IHEX section writer
299 class IHexSectionWriter : public IHexSectionWriterBase {
300 public:
301   IHexSectionWriter(WritableMemoryBuffer &Buf) : IHexSectionWriterBase(Buf) {}
302 
303   void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data) override;
304   Error visit(const StringTableSection &Sec) override;
305 };
306 
307 class Writer {
308 protected:
309   Object &Obj;
310   std::unique_ptr<WritableMemoryBuffer> Buf;
311   raw_ostream &Out;
312 
313 public:
314   virtual ~Writer();
315   virtual Error finalize() = 0;
316   virtual Error write() = 0;
317 
318   Writer(Object &O, raw_ostream &Out) : Obj(O), Out(Out) {}
319 };
320 
321 template <class ELFT> class ELFWriter : public Writer {
322 private:
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 
345 public:
346   virtual ~ELFWriter() {}
347   bool WriteSectionHeaders;
348 
349   // For --only-keep-debug, select an alternative section/segment layout
350   // algorithm.
351   bool OnlyKeepDebug;
352 
353   Error finalize() override;
354   Error write() override;
355   ELFWriter(Object &Obj, raw_ostream &Out, bool WSH, bool OnlyKeepDebug);
356 };
357 
358 class BinaryWriter : public Writer {
359 private:
360   std::unique_ptr<BinarySectionWriter> SecWriter;
361 
362   uint64_t TotalSize = 0;
363 
364 public:
365   ~BinaryWriter() {}
366   Error finalize() override;
367   Error write() override;
368   BinaryWriter(Object &Obj, raw_ostream &Out) : Writer(Obj, Out) {}
369 };
370 
371 class 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 
383 public:
384   ~IHexWriter() {}
385   Error finalize() override;
386   Error write() override;
387   IHexWriter(Object &Obj, raw_ostream &Out) : Writer(Obj, Out) {}
388 };
389 
390 class SectionBase {
391 public:
392   std::string Name;
393   Segment *ParentSegment = nullptr;
394   uint64_t HeaderOffset = 0;
395   uint32_t Index = 0;
396 
397   uint32_t OriginalIndex = 0;
398   uint64_t OriginalFlags = 0;
399   uint64_t OriginalType = ELF::SHT_NULL;
400   uint64_t OriginalOffset = std::numeric_limits<uint64_t>::max();
401 
402   uint64_t Addr = 0;
403   uint64_t Align = 1;
404   uint32_t EntrySize = 0;
405   uint64_t Flags = 0;
406   uint64_t Info = 0;
407   uint64_t Link = ELF::SHN_UNDEF;
408   uint64_t NameIndex = 0;
409   uint64_t Offset = 0;
410   uint64_t Size = 0;
411   uint64_t Type = ELF::SHT_NULL;
412   ArrayRef<uint8_t> OriginalData;
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
431   replaceSectionReferences(const DenseMap<SectionBase *, SectionBase *> &);
432   virtual bool hasContents() const { return false; }
433   // Notify the section that it is subject to removal.
434   virtual void onRemove();
435 };
436 
437 class Segment {
438 private:
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 
450 public:
451   uint32_t Type = 0;
452   uint32_t Flags = 0;
453   uint64_t Offset = 0;
454   uint64_t VAddr = 0;
455   uint64_t PAddr = 0;
456   uint64_t FileSize = 0;
457   uint64_t MemSize = 0;
458   uint64_t Align = 0;
459 
460   uint32_t Index = 0;
461   uint64_t OriginalOffset = 0;
462   Segment *ParentSegment = nullptr;
463   ArrayRef<uint8_t> Contents;
464   std::set<const SectionBase *, SectionCompare> Sections;
465 
466   explicit Segment(ArrayRef<uint8_t> Data) : Contents(Data) {}
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 
478   ArrayRef<uint8_t> getContents() const { return Contents; }
479 };
480 
481 class Section : public SectionBase {
482   MAKE_SEC_WRITER_FRIEND
483 
484   ArrayRef<uint8_t> Contents;
485   SectionBase *LinkSection = nullptr;
486 
487 public:
488   explicit Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
489 
490   Error accept(SectionVisitor &Visitor) const override;
491   Error accept(MutableSectionVisitor &Visitor) override;
492   Error removeSectionReferences(
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 
502 class OwnedDataSection : public SectionBase {
503   MAKE_SEC_WRITER_FRIEND
504 
505   std::vector<uint8_t> Data;
506 
507 public:
508   OwnedDataSection(StringRef SecName, ArrayRef<uint8_t> Data)
509       : Data(std::begin(Data), std::end(Data)) {
510     Name = SecName.str();
511     Type = OriginalType = ELF::SHT_PROGBITS;
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();
519     Type = OriginalType = ELF::SHT_PROGBITS;
520     Addr = SecAddr;
521     Flags = OriginalFlags = SecFlags;
522     OriginalOffset = SecOff;
523   }
524 
525   OwnedDataSection(SectionBase &S, ArrayRef<uint8_t> Data)
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 
536 class CompressedSection : public SectionBase {
537   MAKE_SEC_WRITER_FRIEND
538 
539   uint32_t ChType = 0;
540   DebugCompressionType CompressionType;
541   uint64_t DecompressedSize;
542   uint64_t DecompressedAlign;
543   SmallVector<uint8_t, 128> CompressedData;
544 
545 public:
546   CompressedSection(const SectionBase &Sec,
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) {
559     return S->OriginalFlags & ELF::SHF_COMPRESSED;
560   }
561 };
562 
563 class DecompressedSection : public SectionBase {
564   MAKE_SEC_WRITER_FRIEND
565 
566 public:
567   uint32_t ChType;
568   explicit DecompressedSection(const CompressedSection &Sec)
569       : SectionBase(Sec), ChType(Sec.getChType()) {
570     Size = Sec.getDecompressedSize();
571     Align = Sec.getDecompressedAlign();
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.
587 class StringTableSection : public SectionBase {
588   MAKE_SEC_WRITER_FRIEND
589 
590   StringTableBuilder StrTabBuilder;
591 
592 public:
593   StringTableSection() : StrTabBuilder(StringTableBuilder::ELF) {
594     Type = OriginalType = ELF::SHT_STRTAB;
595   }
596 
597   void addString(StringRef Name);
598   uint32_t findIndex(StringRef Name) const;
599   void prepareForLayout();
600   Error accept(SectionVisitor &Visitor) const override;
601   Error accept(MutableSectionVisitor &Visitor) override;
602 
603   static bool classof(const SectionBase *S) {
604     if (S->OriginalFlags & ELF::SHF_ALLOC)
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.
614 enum SymbolShndxType {
615   SYMBOL_SIMPLE_INDEX = 0,
616   SYMBOL_ABS = ELF::SHN_ABS,
617   SYMBOL_COMMON = ELF::SHN_COMMON,
618   SYMBOL_LOPROC = ELF::SHN_LOPROC,
619   SYMBOL_AMDGPU_LDS = ELF::SHN_AMDGPU_LDS,
620   SYMBOL_HEXAGON_SCOMMON = ELF::SHN_HEXAGON_SCOMMON,
621   SYMBOL_HEXAGON_SCOMMON_2 = ELF::SHN_HEXAGON_SCOMMON_2,
622   SYMBOL_HEXAGON_SCOMMON_4 = ELF::SHN_HEXAGON_SCOMMON_4,
623   SYMBOL_HEXAGON_SCOMMON_8 = ELF::SHN_HEXAGON_SCOMMON_8,
624   SYMBOL_MIPS_ACOMMON = ELF::SHN_MIPS_ACOMMON,
625   SYMBOL_MIPS_TEXT = ELF::SHN_MIPS_TEXT,
626   SYMBOL_MIPS_DATA = ELF::SHN_MIPS_DATA,
627   SYMBOL_MIPS_SCOMMON = ELF::SHN_MIPS_SCOMMON,
628   SYMBOL_MIPS_SUNDEFINED = ELF::SHN_MIPS_SUNDEFINED,
629   SYMBOL_HIPROC = ELF::SHN_HIPROC,
630   SYMBOL_LOOS = ELF::SHN_LOOS,
631   SYMBOL_HIOS = ELF::SHN_HIOS,
632   SYMBOL_XINDEX = ELF::SHN_XINDEX,
633 };
634 
635 struct Symbol {
636   uint8_t Binding;
637   SectionBase *DefinedIn = nullptr;
638   SymbolShndxType ShndxType;
639   uint32_t Index;
640   std::string Name;
641   uint32_t NameIndex;
642   uint64_t Size;
643   uint8_t Type;
644   uint64_t Value;
645   uint8_t Visibility;
646   bool Referenced = false;
647 
648   uint16_t getShndx() const;
649   bool isCommon() const;
650 };
651 
652 class SectionIndexSection : public SectionBase {
653   MAKE_SEC_WRITER_FRIEND
654 
655 private:
656   std::vector<uint32_t> Indexes;
657   SymbolTableSection *Symbols = nullptr;
658 
659 public:
660   virtual ~SectionIndexSection() {}
661   void addIndex(uint32_t Index) {
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 
676   SectionIndexSection() {
677     Name = ".symtab_shndx";
678     Align = 4;
679     EntrySize = 4;
680     Type = OriginalType = ELF::SHT_SYMTAB_SHNDX;
681   }
682 };
683 
684 class SymbolTableSection : public SectionBase {
685   MAKE_SEC_WRITER_FRIEND
686 
687   void setStrTab(StringTableSection *StrTab) { SymbolNames = StrTab; }
688   void assignIndices();
689 
690 protected:
691   std::vector<std::unique_ptr<Symbol>> Symbols;
692   StringTableSection *SymbolNames = nullptr;
693   SectionIndexSection *SectionIndexTable = nullptr;
694 
695   using SymPtr = std::unique_ptr<Symbol>;
696 
697 public:
698   SymbolTableSection() { Type = OriginalType = ELF::SHT_SYMTAB; }
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; }
706   void setShndxTable(SectionIndexSection *ShndxTable) {
707     SectionIndexTable = ShndxTable;
708   }
709   const SectionIndexSection *getShndxTable() const { return SectionIndexTable; }
710   void fillShndxTable();
711   const SectionBase *getStrTab() const { return SymbolNames; }
712   Expected<const Symbol *> getSymbolByIndex(uint32_t Index) const;
713   Expected<Symbol *> getSymbolByIndex(uint32_t Index);
714   void updateSymbols(function_ref<void(Symbol &)> Callable);
715 
716   Error removeSectionReferences(
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;
724   void replaceSectionReferences(
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 
732 struct Relocation {
733   Symbol *RelocSymbol = nullptr;
734   uint64_t Offset;
735   uint64_t Addend;
736   uint32_t Type;
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).
748 class RelocationSectionBase : public SectionBase {
749 protected:
750   SectionBase *SecToApplyRel = nullptr;
751 
752 public:
753   const SectionBase *getSection() const { return SecToApplyRel; }
754   void setSection(SectionBase *Sec) { SecToApplyRel = Sec; }
755 
756   StringRef getNamePrefix() const;
757 
758   static bool classof(const SectionBase *S) {
759     return S->OriginalType == ELF::SHT_REL || S->OriginalType == ELF::SHT_RELA;
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.
765 template <class SymTabType>
766 class RelocSectionWithSymtabBase : public RelocationSectionBase {
767   void setSymTab(SymTabType *SymTab) { Symbols = SymTab; }
768 
769 protected:
770   RelocSectionWithSymtabBase() = default;
771 
772   SymTabType *Symbols = nullptr;
773 
774 public:
775   Error initialize(SectionTableRef SecTable) override;
776   void finalize() override;
777 };
778 
779 class RelocationSection
780     : public RelocSectionWithSymtabBase<SymbolTableSection> {
781   MAKE_SEC_WRITER_FRIEND
782 
783   std::vector<Relocation> Relocations;
784   const Object &Obj;
785 
786 public:
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;
791   Error removeSectionReferences(
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;
796   void replaceSectionReferences(
797       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
798   const Object &getObject() const { return Obj; }
799 
800   static bool classof(const SectionBase *S) {
801     if (S->OriginalFlags & ELF::SHF_ALLOC)
802       return false;
803     return S->OriginalType == ELF::SHT_REL || S->OriginalType == ELF::SHT_RELA;
804   }
805 };
806 
807 // TODO: The way stripping and groups interact is complicated
808 // and still needs to be worked on.
809 
810 class GroupSection : public SectionBase {
811   MAKE_SEC_WRITER_FRIEND
812   const SymbolTableSection *SymTab = nullptr;
813   Symbol *Sym = nullptr;
814   ELF::Elf32_Word FlagWord;
815   SmallVector<SectionBase *, 3> GroupMembers;
816 
817 public:
818   // TODO: Contents is present in several classes of the hierarchy.
819   // This needs to be refactored to avoid duplication.
820   ArrayRef<uint8_t> Contents;
821 
822   explicit GroupSection(ArrayRef<uint8_t> Data) : Contents(Data) {}
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;
832   Error removeSectionReferences(
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;
837   void replaceSectionReferences(
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 
846 class DynamicSymbolTableSection : public Section {
847 public:
848   explicit DynamicSymbolTableSection(ArrayRef<uint8_t> Data) : Section(Data) {}
849 
850   static bool classof(const SectionBase *S) {
851     return S->OriginalType == ELF::SHT_DYNSYM;
852   }
853 };
854 
855 class DynamicSection : public Section {
856 public:
857   explicit DynamicSection(ArrayRef<uint8_t> Data) : Section(Data) {}
858 
859   static bool classof(const SectionBase *S) {
860     return S->OriginalType == ELF::SHT_DYNAMIC;
861   }
862 };
863 
864 class DynamicRelocationSection
865     : public RelocSectionWithSymtabBase<DynamicSymbolTableSection> {
866   MAKE_SEC_WRITER_FRIEND
867 
868 private:
869   ArrayRef<uint8_t> Contents;
870 
871 public:
872   explicit DynamicRelocationSection(ArrayRef<uint8_t> Data) : Contents(Data) {}
873 
874   Error accept(SectionVisitor &) const override;
875   Error accept(MutableSectionVisitor &Visitor) override;
876   Error removeSectionReferences(
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;
883     return S->OriginalType == ELF::SHT_REL || S->OriginalType == ELF::SHT_RELA;
884   }
885 };
886 
887 class GnuDebugLinkSection : public SectionBase {
888   MAKE_SEC_WRITER_FRIEND
889 
890 private:
891   StringRef FileName;
892   uint32_t CRC32;
893 
894   void init(StringRef File);
895 
896 public:
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 
903 class Reader {
904 public:
905   virtual ~Reader();
906   virtual Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const = 0;
907 };
908 
909 using object::Binary;
910 using object::ELFFile;
911 using object::ELFObjectFile;
912 using object::OwningBinary;
913 
914 class BasicELFBuilder {
915 protected:
916   std::unique_ptr<Object> Obj;
917 
918   void initFileHeader();
919   void initHeaderSegment();
920   StringTableSection *addStrTab();
921   SymbolTableSection *addSymTab(StringTableSection *StrTab);
922   Error initSections();
923 
924 public:
925   BasicELFBuilder() : Obj(std::make_unique<Object>()) {}
926 };
927 
928 class BinaryELFBuilder : public BasicELFBuilder {
929   MemoryBuffer *MemBuf;
930   uint8_t NewSymbolVisibility;
931   void addData(SymbolTableSection *SymTab);
932 
933 public:
934   BinaryELFBuilder(MemoryBuffer *MB, uint8_t NewSymbolVisibility)
935       : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {}
936 
937   Expected<std::unique_ptr<Object>> build();
938 };
939 
940 class IHexELFBuilder : public BasicELFBuilder {
941   const std::vector<IHexRecord> &Records;
942 
943   void addDataSections();
944 
945 public:
946   IHexELFBuilder(const std::vector<IHexRecord> &Records) : Records(Records) {}
947 
948   Expected<std::unique_ptr<Object>> build();
949 };
950 
951 template <class ELFT> class ELFBuilder {
952 private:
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 
971 public:
972   ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj,
973              std::optional<StringRef> ExtractPartition);
974 
975   Error build(bool EnsureSymtab);
976 };
977 
978 class BinaryReader : public Reader {
979   MemoryBuffer *MemBuf;
980   uint8_t NewSymbolVisibility;
981 
982 public:
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 
988 class IHexReader : public Reader {
989   MemoryBuffer *MemBuf;
990 
991   Expected<std::vector<IHexRecord>> parse() const;
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 {
1000     Error E = createStringError(errc::invalid_argument, Fmt, Vals...);
1001     return parseError(LineNo, std::move(E));
1002   }
1003 
1004 public:
1005   IHexReader(MemoryBuffer *MB) : MemBuf(MB) {}
1006 
1007   Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override;
1008 };
1009 
1010 class ELFReader : public Reader {
1011   Binary *Bin;
1012   std::optional<StringRef> ExtractPartition;
1013 
1014 public:
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 
1020 class Object {
1021 private:
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;
1028   DenseMap<SectionBase *, std::vector<uint8_t>> UpdatedSections;
1029 
1030   static bool sectionIsAlloc(const SectionBase &Sec) {
1031     return Sec.Flags & ELF::SHF_ALLOC;
1032   };
1033 
1034 public:
1035   template <class T>
1036   using ConstRange = iterator_range<pointee_iterator<
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.
1045   Segment ElfHdrSegment;
1046   Segment ProgramHdrSegment;
1047 
1048   bool Is64Bits;
1049   uint8_t OSABI;
1050   uint8_t ABIVersion;
1051   uint64_t Entry;
1052   uint64_t SHOff;
1053   uint32_t Type;
1054   uint32_t Machine;
1055   uint32_t Version;
1056   uint32_t Flags;
1057 
1058   bool HadShdrs = true;
1059   bool MustBeRelocatable = false;
1060   StringTableSection *SectionNames = nullptr;
1061   SymbolTableSection *SymbolTable = nullptr;
1062   SectionIndexSection *SectionIndexTable = nullptr;
1063 
1064   bool IsMips64EL = false;
1065 
1066   SectionTableRef sections() const { return SectionTableRef(Sections); }
1067   iterator_range<
1068       filter_iterator<pointee_iterator<std::vector<SecPtr>::const_iterator>,
1069                       decltype(&sectionIsAlloc)>>
1070   allocSections() const {
1071     return make_filter_range(make_pointee_range(Sections), sectionIsAlloc);
1072   }
1073 
1074   const auto &getUpdatedSections() const { return UpdatedSections; }
1075   Error updateSection(StringRef Name, ArrayRef<uint8_t> Data);
1076 
1077   SectionBase *findSection(StringRef Name) {
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 
1084   ConstRange<Segment> segments() const { return make_pointee_range(Segments); }
1085 
1086   Error removeSections(bool AllowBrokenLinks,
1087                        std::function<bool(const SectionBase &)> ToRemove);
1088   Error replaceSections(const DenseMap<SectionBase *, SectionBase *> &FromTo);
1089   Error removeSymbols(function_ref<bool(const Symbol &)> 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   }
1098   Error addNewSymbolTable();
1099   Segment &addSegment(ArrayRef<uint8_t> Data) {
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
1113