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 DebugCompressionType CompressionType; 540 uint64_t DecompressedSize; 541 uint64_t DecompressedAlign; 542 SmallVector<uint8_t, 128> CompressedData; 543 544 public: 545 CompressedSection(const SectionBase &Sec, 546 DebugCompressionType CompressionType); 547 CompressedSection(ArrayRef<uint8_t> CompressedData, uint64_t DecompressedSize, 548 uint64_t DecompressedAlign); 549 550 uint64_t getDecompressedSize() const { return DecompressedSize; } 551 uint64_t getDecompressedAlign() const { return DecompressedAlign; } 552 553 Error accept(SectionVisitor &Visitor) const override; 554 Error accept(MutableSectionVisitor &Visitor) override; 555 556 static bool classof(const SectionBase *S) { 557 return S->OriginalFlags & ELF::SHF_COMPRESSED; 558 } 559 }; 560 561 class DecompressedSection : public SectionBase { 562 MAKE_SEC_WRITER_FRIEND 563 564 public: 565 explicit DecompressedSection(const CompressedSection &Sec) 566 : SectionBase(Sec) { 567 Size = Sec.getDecompressedSize(); 568 Align = Sec.getDecompressedAlign(); 569 Flags = OriginalFlags = (Flags & ~ELF::SHF_COMPRESSED); 570 } 571 572 Error accept(SectionVisitor &Visitor) const override; 573 Error accept(MutableSectionVisitor &Visitor) override; 574 }; 575 576 // There are two types of string tables that can exist, dynamic and not dynamic. 577 // In the dynamic case the string table is allocated. Changing a dynamic string 578 // table would mean altering virtual addresses and thus the memory image. So 579 // dynamic string tables should not have an interface to modify them or 580 // reconstruct them. This type lets us reconstruct a string table. To avoid 581 // this class being used for dynamic string tables (which has happened) the 582 // classof method checks that the particular instance is not allocated. This 583 // then agrees with the makeSection method used to construct most sections. 584 class StringTableSection : public SectionBase { 585 MAKE_SEC_WRITER_FRIEND 586 587 StringTableBuilder StrTabBuilder; 588 589 public: 590 StringTableSection() : StrTabBuilder(StringTableBuilder::ELF) { 591 Type = OriginalType = ELF::SHT_STRTAB; 592 } 593 594 void addString(StringRef Name); 595 uint32_t findIndex(StringRef Name) const; 596 void prepareForLayout(); 597 Error accept(SectionVisitor &Visitor) const override; 598 Error accept(MutableSectionVisitor &Visitor) override; 599 600 static bool classof(const SectionBase *S) { 601 if (S->OriginalFlags & ELF::SHF_ALLOC) 602 return false; 603 return S->OriginalType == ELF::SHT_STRTAB; 604 } 605 }; 606 607 // Symbols have a st_shndx field that normally stores an index but occasionally 608 // stores a different special value. This enum keeps track of what the st_shndx 609 // field means. Most of the values are just copies of the special SHN_* values. 610 // SYMBOL_SIMPLE_INDEX means that the st_shndx is just an index of a section. 611 enum SymbolShndxType { 612 SYMBOL_SIMPLE_INDEX = 0, 613 SYMBOL_ABS = ELF::SHN_ABS, 614 SYMBOL_COMMON = ELF::SHN_COMMON, 615 SYMBOL_LOPROC = ELF::SHN_LOPROC, 616 SYMBOL_AMDGPU_LDS = ELF::SHN_AMDGPU_LDS, 617 SYMBOL_HEXAGON_SCOMMON = ELF::SHN_HEXAGON_SCOMMON, 618 SYMBOL_HEXAGON_SCOMMON_2 = ELF::SHN_HEXAGON_SCOMMON_2, 619 SYMBOL_HEXAGON_SCOMMON_4 = ELF::SHN_HEXAGON_SCOMMON_4, 620 SYMBOL_HEXAGON_SCOMMON_8 = ELF::SHN_HEXAGON_SCOMMON_8, 621 SYMBOL_MIPS_ACOMMON = ELF::SHN_MIPS_ACOMMON, 622 SYMBOL_MIPS_TEXT = ELF::SHN_MIPS_TEXT, 623 SYMBOL_MIPS_DATA = ELF::SHN_MIPS_DATA, 624 SYMBOL_MIPS_SCOMMON = ELF::SHN_MIPS_SCOMMON, 625 SYMBOL_MIPS_SUNDEFINED = ELF::SHN_MIPS_SUNDEFINED, 626 SYMBOL_HIPROC = ELF::SHN_HIPROC, 627 SYMBOL_LOOS = ELF::SHN_LOOS, 628 SYMBOL_HIOS = ELF::SHN_HIOS, 629 SYMBOL_XINDEX = ELF::SHN_XINDEX, 630 }; 631 632 struct Symbol { 633 uint8_t Binding; 634 SectionBase *DefinedIn = nullptr; 635 SymbolShndxType ShndxType; 636 uint32_t Index; 637 std::string Name; 638 uint32_t NameIndex; 639 uint64_t Size; 640 uint8_t Type; 641 uint64_t Value; 642 uint8_t Visibility; 643 bool Referenced = false; 644 645 uint16_t getShndx() const; 646 bool isCommon() const; 647 }; 648 649 class SectionIndexSection : public SectionBase { 650 MAKE_SEC_WRITER_FRIEND 651 652 private: 653 std::vector<uint32_t> Indexes; 654 SymbolTableSection *Symbols = nullptr; 655 656 public: 657 virtual ~SectionIndexSection() {} 658 void addIndex(uint32_t Index) { 659 assert(Size > 0); 660 Indexes.push_back(Index); 661 } 662 663 void reserve(size_t NumSymbols) { 664 Indexes.reserve(NumSymbols); 665 Size = NumSymbols * 4; 666 } 667 void setSymTab(SymbolTableSection *SymTab) { Symbols = SymTab; } 668 Error initialize(SectionTableRef SecTable) override; 669 void finalize() override; 670 Error accept(SectionVisitor &Visitor) const override; 671 Error accept(MutableSectionVisitor &Visitor) override; 672 673 SectionIndexSection() { 674 Name = ".symtab_shndx"; 675 Align = 4; 676 EntrySize = 4; 677 Type = OriginalType = ELF::SHT_SYMTAB_SHNDX; 678 } 679 }; 680 681 class SymbolTableSection : public SectionBase { 682 MAKE_SEC_WRITER_FRIEND 683 684 void setStrTab(StringTableSection *StrTab) { SymbolNames = StrTab; } 685 void assignIndices(); 686 687 protected: 688 std::vector<std::unique_ptr<Symbol>> Symbols; 689 StringTableSection *SymbolNames = nullptr; 690 SectionIndexSection *SectionIndexTable = nullptr; 691 692 using SymPtr = std::unique_ptr<Symbol>; 693 694 public: 695 SymbolTableSection() { Type = OriginalType = ELF::SHT_SYMTAB; } 696 697 void addSymbol(Twine Name, uint8_t Bind, uint8_t Type, SectionBase *DefinedIn, 698 uint64_t Value, uint8_t Visibility, uint16_t Shndx, 699 uint64_t SymbolSize); 700 void prepareForLayout(); 701 // An 'empty' symbol table still contains a null symbol. 702 bool empty() const { return Symbols.size() == 1; } 703 void setShndxTable(SectionIndexSection *ShndxTable) { 704 SectionIndexTable = ShndxTable; 705 } 706 const SectionIndexSection *getShndxTable() const { return SectionIndexTable; } 707 void fillShndxTable(); 708 const SectionBase *getStrTab() const { return SymbolNames; } 709 Expected<const Symbol *> getSymbolByIndex(uint32_t Index) const; 710 Expected<Symbol *> getSymbolByIndex(uint32_t Index); 711 void updateSymbols(function_ref<void(Symbol &)> Callable); 712 713 Error removeSectionReferences( 714 bool AllowBrokenLinks, 715 function_ref<bool(const SectionBase *)> ToRemove) override; 716 Error initialize(SectionTableRef SecTable) override; 717 void finalize() override; 718 Error accept(SectionVisitor &Visitor) const override; 719 Error accept(MutableSectionVisitor &Visitor) override; 720 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override; 721 void replaceSectionReferences( 722 const DenseMap<SectionBase *, SectionBase *> &FromTo) override; 723 724 static bool classof(const SectionBase *S) { 725 return S->OriginalType == ELF::SHT_SYMTAB; 726 } 727 }; 728 729 struct Relocation { 730 Symbol *RelocSymbol = nullptr; 731 uint64_t Offset; 732 uint64_t Addend; 733 uint32_t Type; 734 }; 735 736 // All relocation sections denote relocations to apply to another section. 737 // However, some relocation sections use a dynamic symbol table and others use 738 // a regular symbol table. Because the types of the two symbol tables differ in 739 // our system (because they should behave differently) we can't uniformly 740 // represent all relocations with the same base class if we expose an interface 741 // that mentions the symbol table type. So we split the two base types into two 742 // different classes, one which handles the section the relocation is applied to 743 // and another which handles the symbol table type. The symbol table type is 744 // taken as a type parameter to the class (see RelocSectionWithSymtabBase). 745 class RelocationSectionBase : public SectionBase { 746 protected: 747 SectionBase *SecToApplyRel = nullptr; 748 749 public: 750 const SectionBase *getSection() const { return SecToApplyRel; } 751 void setSection(SectionBase *Sec) { SecToApplyRel = Sec; } 752 753 StringRef getNamePrefix() const; 754 755 static bool classof(const SectionBase *S) { 756 return S->OriginalType == ELF::SHT_REL || S->OriginalType == ELF::SHT_RELA; 757 } 758 }; 759 760 // Takes the symbol table type to use as a parameter so that we can deduplicate 761 // that code between the two symbol table types. 762 template <class SymTabType> 763 class RelocSectionWithSymtabBase : public RelocationSectionBase { 764 void setSymTab(SymTabType *SymTab) { Symbols = SymTab; } 765 766 protected: 767 RelocSectionWithSymtabBase() = default; 768 769 SymTabType *Symbols = nullptr; 770 771 public: 772 Error initialize(SectionTableRef SecTable) override; 773 void finalize() override; 774 }; 775 776 class RelocationSection 777 : public RelocSectionWithSymtabBase<SymbolTableSection> { 778 MAKE_SEC_WRITER_FRIEND 779 780 std::vector<Relocation> Relocations; 781 const Object &Obj; 782 783 public: 784 RelocationSection(const Object &O) : Obj(O) {} 785 void addRelocation(Relocation Rel) { Relocations.push_back(Rel); } 786 Error accept(SectionVisitor &Visitor) const override; 787 Error accept(MutableSectionVisitor &Visitor) override; 788 Error removeSectionReferences( 789 bool AllowBrokenLinks, 790 function_ref<bool(const SectionBase *)> ToRemove) override; 791 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override; 792 void markSymbols() override; 793 void replaceSectionReferences( 794 const DenseMap<SectionBase *, SectionBase *> &FromTo) override; 795 const Object &getObject() const { return Obj; } 796 797 static bool classof(const SectionBase *S) { 798 if (S->OriginalFlags & ELF::SHF_ALLOC) 799 return false; 800 return S->OriginalType == ELF::SHT_REL || S->OriginalType == ELF::SHT_RELA; 801 } 802 }; 803 804 // TODO: The way stripping and groups interact is complicated 805 // and still needs to be worked on. 806 807 class GroupSection : public SectionBase { 808 MAKE_SEC_WRITER_FRIEND 809 const SymbolTableSection *SymTab = nullptr; 810 Symbol *Sym = nullptr; 811 ELF::Elf32_Word FlagWord; 812 SmallVector<SectionBase *, 3> GroupMembers; 813 814 public: 815 // TODO: Contents is present in several classes of the hierarchy. 816 // This needs to be refactored to avoid duplication. 817 ArrayRef<uint8_t> Contents; 818 819 explicit GroupSection(ArrayRef<uint8_t> Data) : Contents(Data) {} 820 821 void setSymTab(const SymbolTableSection *SymTabSec) { SymTab = SymTabSec; } 822 void setSymbol(Symbol *S) { Sym = S; } 823 void setFlagWord(ELF::Elf32_Word W) { FlagWord = W; } 824 void addMember(SectionBase *Sec) { GroupMembers.push_back(Sec); } 825 826 Error accept(SectionVisitor &) const override; 827 Error accept(MutableSectionVisitor &Visitor) override; 828 void finalize() override; 829 Error removeSectionReferences( 830 bool AllowBrokenLinks, 831 function_ref<bool(const SectionBase *)> ToRemove) override; 832 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override; 833 void markSymbols() override; 834 void replaceSectionReferences( 835 const DenseMap<SectionBase *, SectionBase *> &FromTo) override; 836 void onRemove() override; 837 838 static bool classof(const SectionBase *S) { 839 return S->OriginalType == ELF::SHT_GROUP; 840 } 841 }; 842 843 class DynamicSymbolTableSection : public Section { 844 public: 845 explicit DynamicSymbolTableSection(ArrayRef<uint8_t> Data) : Section(Data) {} 846 847 static bool classof(const SectionBase *S) { 848 return S->OriginalType == ELF::SHT_DYNSYM; 849 } 850 }; 851 852 class DynamicSection : public Section { 853 public: 854 explicit DynamicSection(ArrayRef<uint8_t> Data) : Section(Data) {} 855 856 static bool classof(const SectionBase *S) { 857 return S->OriginalType == ELF::SHT_DYNAMIC; 858 } 859 }; 860 861 class DynamicRelocationSection 862 : public RelocSectionWithSymtabBase<DynamicSymbolTableSection> { 863 MAKE_SEC_WRITER_FRIEND 864 865 private: 866 ArrayRef<uint8_t> Contents; 867 868 public: 869 explicit DynamicRelocationSection(ArrayRef<uint8_t> Data) : Contents(Data) {} 870 871 Error accept(SectionVisitor &) const override; 872 Error accept(MutableSectionVisitor &Visitor) override; 873 Error removeSectionReferences( 874 bool AllowBrokenLinks, 875 function_ref<bool(const SectionBase *)> ToRemove) override; 876 877 static bool classof(const SectionBase *S) { 878 if (!(S->OriginalFlags & ELF::SHF_ALLOC)) 879 return false; 880 return S->OriginalType == ELF::SHT_REL || S->OriginalType == ELF::SHT_RELA; 881 } 882 }; 883 884 class GnuDebugLinkSection : public SectionBase { 885 MAKE_SEC_WRITER_FRIEND 886 887 private: 888 StringRef FileName; 889 uint32_t CRC32; 890 891 void init(StringRef File); 892 893 public: 894 // If we add this section from an external source we can use this ctor. 895 explicit GnuDebugLinkSection(StringRef File, uint32_t PrecomputedCRC); 896 Error accept(SectionVisitor &Visitor) const override; 897 Error accept(MutableSectionVisitor &Visitor) override; 898 }; 899 900 class Reader { 901 public: 902 virtual ~Reader(); 903 virtual Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const = 0; 904 }; 905 906 using object::Binary; 907 using object::ELFFile; 908 using object::ELFObjectFile; 909 using object::OwningBinary; 910 911 class BasicELFBuilder { 912 protected: 913 std::unique_ptr<Object> Obj; 914 915 void initFileHeader(); 916 void initHeaderSegment(); 917 StringTableSection *addStrTab(); 918 SymbolTableSection *addSymTab(StringTableSection *StrTab); 919 Error initSections(); 920 921 public: 922 BasicELFBuilder() : Obj(std::make_unique<Object>()) {} 923 }; 924 925 class BinaryELFBuilder : public BasicELFBuilder { 926 MemoryBuffer *MemBuf; 927 uint8_t NewSymbolVisibility; 928 void addData(SymbolTableSection *SymTab); 929 930 public: 931 BinaryELFBuilder(MemoryBuffer *MB, uint8_t NewSymbolVisibility) 932 : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {} 933 934 Expected<std::unique_ptr<Object>> build(); 935 }; 936 937 class IHexELFBuilder : public BasicELFBuilder { 938 const std::vector<IHexRecord> &Records; 939 940 void addDataSections(); 941 942 public: 943 IHexELFBuilder(const std::vector<IHexRecord> &Records) : Records(Records) {} 944 945 Expected<std::unique_ptr<Object>> build(); 946 }; 947 948 template <class ELFT> class ELFBuilder { 949 private: 950 using Elf_Addr = typename ELFT::Addr; 951 using Elf_Shdr = typename ELFT::Shdr; 952 using Elf_Word = typename ELFT::Word; 953 954 const ELFFile<ELFT> &ElfFile; 955 Object &Obj; 956 size_t EhdrOffset = 0; 957 Optional<StringRef> ExtractPartition; 958 959 void setParentSegment(Segment &Child); 960 Error readProgramHeaders(const ELFFile<ELFT> &HeadersFile); 961 Error initGroupSection(GroupSection *GroupSec); 962 Error initSymbolTable(SymbolTableSection *SymTab); 963 Error readSectionHeaders(); 964 Error readSections(bool EnsureSymtab); 965 Error findEhdrOffset(); 966 Expected<SectionBase &> makeSection(const Elf_Shdr &Shdr); 967 968 public: 969 ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj, 970 Optional<StringRef> ExtractPartition); 971 972 Error build(bool EnsureSymtab); 973 }; 974 975 class BinaryReader : public Reader { 976 MemoryBuffer *MemBuf; 977 uint8_t NewSymbolVisibility; 978 979 public: 980 BinaryReader(MemoryBuffer *MB, const uint8_t NewSymbolVisibility) 981 : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {} 982 Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override; 983 }; 984 985 class IHexReader : public Reader { 986 MemoryBuffer *MemBuf; 987 988 Expected<std::vector<IHexRecord>> parse() const; 989 Error parseError(size_t LineNo, Error E) const { 990 return LineNo == -1U 991 ? createFileError(MemBuf->getBufferIdentifier(), std::move(E)) 992 : createFileError(MemBuf->getBufferIdentifier(), LineNo, 993 std::move(E)); 994 } 995 template <typename... Ts> 996 Error parseError(size_t LineNo, char const *Fmt, const Ts &...Vals) const { 997 Error E = createStringError(errc::invalid_argument, Fmt, Vals...); 998 return parseError(LineNo, std::move(E)); 999 } 1000 1001 public: 1002 IHexReader(MemoryBuffer *MB) : MemBuf(MB) {} 1003 1004 Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override; 1005 }; 1006 1007 class ELFReader : public Reader { 1008 Binary *Bin; 1009 Optional<StringRef> ExtractPartition; 1010 1011 public: 1012 Expected<std::unique_ptr<Object>> create(bool EnsureSymtab) const override; 1013 explicit ELFReader(Binary *B, Optional<StringRef> ExtractPartition) 1014 : Bin(B), ExtractPartition(ExtractPartition) {} 1015 }; 1016 1017 class Object { 1018 private: 1019 using SecPtr = std::unique_ptr<SectionBase>; 1020 using SegPtr = std::unique_ptr<Segment>; 1021 1022 std::vector<SecPtr> Sections; 1023 std::vector<SegPtr> Segments; 1024 std::vector<SecPtr> RemovedSections; 1025 DenseMap<SectionBase *, std::vector<uint8_t>> UpdatedSections; 1026 1027 static bool sectionIsAlloc(const SectionBase &Sec) { 1028 return Sec.Flags & ELF::SHF_ALLOC; 1029 }; 1030 1031 public: 1032 template <class T> 1033 using ConstRange = iterator_range<pointee_iterator< 1034 typename std::vector<std::unique_ptr<T>>::const_iterator>>; 1035 1036 // It is often the case that the ELF header and the program header table are 1037 // not present in any segment. This could be a problem during file layout, 1038 // because other segments may get assigned an offset where either of the 1039 // two should reside, which will effectively corrupt the resulting binary. 1040 // Other than that we use these segments to track program header offsets 1041 // when they may not follow the ELF header. 1042 Segment ElfHdrSegment; 1043 Segment ProgramHdrSegment; 1044 1045 uint8_t OSABI; 1046 uint8_t ABIVersion; 1047 uint64_t Entry; 1048 uint64_t SHOff; 1049 uint32_t Type; 1050 uint32_t Machine; 1051 uint32_t Version; 1052 uint32_t Flags; 1053 1054 bool HadShdrs = true; 1055 bool MustBeRelocatable = false; 1056 StringTableSection *SectionNames = nullptr; 1057 SymbolTableSection *SymbolTable = nullptr; 1058 SectionIndexSection *SectionIndexTable = nullptr; 1059 1060 bool IsMips64EL = false; 1061 1062 SectionTableRef sections() const { return SectionTableRef(Sections); } 1063 iterator_range< 1064 filter_iterator<pointee_iterator<std::vector<SecPtr>::const_iterator>, 1065 decltype(§ionIsAlloc)>> 1066 allocSections() const { 1067 return make_filter_range(make_pointee_range(Sections), sectionIsAlloc); 1068 } 1069 1070 const auto &getUpdatedSections() const { return UpdatedSections; } 1071 Error updateSection(StringRef Name, ArrayRef<uint8_t> Data); 1072 1073 SectionBase *findSection(StringRef Name) { 1074 auto SecIt = 1075 find_if(Sections, [&](const SecPtr &Sec) { return Sec->Name == Name; }); 1076 return SecIt == Sections.end() ? nullptr : SecIt->get(); 1077 } 1078 SectionTableRef removedSections() { return SectionTableRef(RemovedSections); } 1079 1080 ConstRange<Segment> segments() const { return make_pointee_range(Segments); } 1081 1082 Error removeSections(bool AllowBrokenLinks, 1083 std::function<bool(const SectionBase &)> ToRemove); 1084 Error replaceSections(const DenseMap<SectionBase *, SectionBase *> &FromTo); 1085 Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove); 1086 template <class T, class... Ts> T &addSection(Ts &&...Args) { 1087 auto Sec = std::make_unique<T>(std::forward<Ts>(Args)...); 1088 auto Ptr = Sec.get(); 1089 MustBeRelocatable |= isa<RelocationSection>(*Ptr); 1090 Sections.emplace_back(std::move(Sec)); 1091 Ptr->Index = Sections.size(); 1092 return *Ptr; 1093 } 1094 Error addNewSymbolTable(); 1095 Segment &addSegment(ArrayRef<uint8_t> Data) { 1096 Segments.emplace_back(std::make_unique<Segment>(Data)); 1097 return *Segments.back(); 1098 } 1099 bool isRelocatable() const { 1100 return (Type != ELF::ET_DYN && Type != ELF::ET_EXEC) || MustBeRelocatable; 1101 } 1102 }; 1103 1104 } // end namespace elf 1105 } // end namespace objcopy 1106 } // end namespace llvm 1107 1108 #endif // LLVM_LIB_OBJCOPY_ELF_ELFOBJECT_H 1109