build/unix/elfhack/elfxx.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include <stdexcept>
   6 #include <list>
   7 #include <vector>
   8 #include <cstring>
   9 #include <fstream>
  10 #include <algorithm>
  11 #include <elf.h>
  12 #include <asm/byteorder.h>
  13
  14 // Technically, __*_to_cpu and __cpu_to* function are equivalent,
  15 // so swap can use either of both.
  16 #define def_swap(endian, type, bits)                    \
  17   static inline type##bits##_t swap(type##bits##_t i) { \
  18     return __##endian##bits##_to_cpu(i);                \
  19   }
  20
  21 class little_endian {
  22  public:
  23   def_swap(le, uint, 16);
  24   def_swap(le, uint, 32);
  25   def_swap(le, uint, 64);
  26   def_swap(le, int, 16);
  27   def_swap(le, int, 32);
  28   def_swap(le, int, 64);
  29 };
  30
  31 class big_endian {
  32  public:
  33   def_swap(be, uint, 16);
  34   def_swap(be, uint, 32);
  35   def_swap(be, uint, 64);
  36   def_swap(be, int, 16);
  37   def_swap(be, int, 32);
  38   def_swap(be, int, 64);
  39 };
  40
  41 // forward declaration
  42 class ElfSection;
  43 class ElfSegment;
  44 // TODO: Rename Elf_* types
  45 class Elf_Ehdr;
  46 class Elf_Phdr;
  47 class Elf;
  48 class ElfDynamic_Section;
  49 class ElfStrtab_Section;
  50
  51 template <typename X>
  52 class FixedSizeData {
  53  public:
  54   struct Wrapper {
  55     X value;
  56   };
  57   typedef Wrapper Type32;
  58   typedef Wrapper Type64;
  59
  60   template <class endian, typename R, typename T>
  61   static void swap(T& t, R& r) {
  62     r.value = endian::swap(t.value);
  63   }
  64 };
  65
  66 class Elf_Ehdr_Traits {
  67  public:
  68   typedef Elf32_Ehdr Type32;
  69   typedef Elf64_Ehdr Type64;
  70
  71   template <class endian, typename R, typename T>
  72   static void swap(T& t, R& r);
  73 };
  74
  75 class Elf_Phdr_Traits {
  76  public:
  77   typedef Elf32_Phdr Type32;
  78   typedef Elf64_Phdr Type64;
  79
  80   template <class endian, typename R, typename T>
  81   static void swap(T& t, R& r);
  82 };
  83
  84 class Elf_Shdr_Traits {
  85  public:
  86   typedef Elf32_Shdr Type32;
  87   typedef Elf64_Shdr Type64;
  88
  89   template <class endian, typename R, typename T>
  90   static void swap(T& t, R& r);
  91 };
  92
  93 class Elf_Dyn_Traits {
  94  public:
  95   typedef Elf32_Dyn Type32;
  96   typedef Elf64_Dyn Type64;
  97
  98   template <class endian, typename R, typename T>
  99   static void swap(T& t, R& r);
 100 };
 101
 102 class Elf_Sym_Traits {
 103  public:
 104   typedef Elf32_Sym Type32;
 105   typedef Elf64_Sym Type64;
 106
 107   template <class endian, typename R, typename T>
 108   static void swap(T& t, R& r);
 109 };
 110
 111 class Elf_Rel_Traits {
 112  public:
 113   typedef Elf32_Rel Type32;
 114   typedef Elf64_Rel Type64;
 115
 116   template <class endian, typename R, typename T>
 117   static void swap(T& t, R& r);
 118 };
 119
 120 class Elf_Rela_Traits {
 121  public:
 122   typedef Elf32_Rela Type32;
 123   typedef Elf64_Rela Type64;
 124
 125   template <class endian, typename R, typename T>
 126   static void swap(T& t, R& r);
 127 };
 128
 129 class ElfValue {
 130  public:
 131   virtual unsigned int getValue() { return 0; }
 132   virtual ElfSection* getSection() { return nullptr; }
 133 };
 134
 135 class ElfPlainValue : public ElfValue {
 136   unsigned int value;
 137
 138  public:
 139   ElfPlainValue(unsigned int val) : value(val) {};
 140   unsigned int getValue() { return value; }
 141 };
 142
 143 class ElfLocation : public ElfValue {
 144   ElfSection* section;
 145   unsigned int offset;
 146
 147  public:
 148   enum position { ABSOLUTE, RELATIVE };
 149   ElfLocation() : section(nullptr), offset(0) {};
 150   ElfLocation(ElfSection* section, unsigned int off,
 151               enum position pos = RELATIVE);
 152   ElfLocation(unsigned int location, Elf* elf);
 153   unsigned int getValue();
 154   ElfSection* getSection() { return section; }
 155   const char* getBuffer();
 156 };
 157
 158 class ElfSize : public ElfValue {
 159   ElfSection* section;
 160
 161  public:
 162   ElfSize(ElfSection* s) : section(s) {};
 163   unsigned int getValue();
 164   ElfSection* getSection() { return section; }
 165 };
 166
 167 class ElfEntSize : public ElfValue {
 168   ElfSection* section;
 169
 170  public:
 171   ElfEntSize(ElfSection* s) : section(s) {};
 172   unsigned int getValue();
 173   ElfSection* getSection() { return section; }
 174 };
 175
 176 template <typename T>
 177 class serializable : public T::Type64 {
 178  public:
 179   serializable() {};
 180   serializable(const typename T::Type64& p) : T::Type64(p) {};
 181
 182  private:
 183   template <typename R>
 184   void init(const char* buf, size_t len, unsigned char ei_data) {
 185     R e;
 186     assert(len >= sizeof(e));
 187     memcpy(&e, buf, sizeof(e));
 188     if (ei_data == ELFDATA2LSB) {
 189       T::template swap<little_endian>(e, *this);
 190       return;
 191     } else if (ei_data == ELFDATA2MSB) {
 192       T::template swap<big_endian>(e, *this);
 193       return;
 194     }
 195     throw std::runtime_error("Unsupported ELF data encoding");
 196   }
 197
 198   template <typename R>
 199   void serialize(const char* buf, size_t len, unsigned char ei_data) {
 200     assert(len >= sizeof(R));
 201     if (ei_data == ELFDATA2LSB) {
 202       T::template swap<little_endian>(*this, *(R*)buf);
 203       return;
 204     } else if (ei_data == ELFDATA2MSB) {
 205       T::template swap<big_endian>(*this, *(R*)buf);
 206       return;
 207     }
 208     throw std::runtime_error("Unsupported ELF data encoding");
 209   }
 210
 211  public:
 212   serializable(const char* buf, size_t len, unsigned char ei_class,
 213                unsigned char ei_data) {
 214     if (ei_class == ELFCLASS32) {
 215       init<typename T::Type32>(buf, len, ei_data);
 216       return;
 217     } else if (ei_class == ELFCLASS64) {
 218       init<typename T::Type64>(buf, len, ei_data);
 219       return;
 220     }
 221     throw std::runtime_error("Unsupported ELF class");
 222   }
 223
 224   serializable(std::ifstream& file, unsigned char ei_class,
 225                unsigned char ei_data) {
 226     if (ei_class == ELFCLASS32) {
 227       typename T::Type32 e;
 228       file.read((char*)&e, sizeof(e));
 229       init<typename T::Type32>((char*)&e, sizeof(e), ei_data);
 230       return;
 231     } else if (ei_class == ELFCLASS64) {
 232       typename T::Type64 e;
 233       file.read((char*)&e, sizeof(e));
 234       init<typename T::Type64>((char*)&e, sizeof(e), ei_data);
 235       return;
 236     }
 237     throw std::runtime_error("Unsupported ELF class or data encoding");
 238   }
 239
 240   void serialize(std::ofstream& file, unsigned char ei_class,
 241                  unsigned char ei_data) {
 242     if (ei_class == ELFCLASS32) {
 243       typename T::Type32 e;
 244       serialize<typename T::Type32>((char*)&e, sizeof(e), ei_data);
 245       file.write((char*)&e, sizeof(e));
 246       return;
 247     } else if (ei_class == ELFCLASS64) {
 248       typename T::Type64 e;
 249       serialize<typename T::Type64>((char*)&e, sizeof(e), ei_data);
 250       file.write((char*)&e, sizeof(e));
 251       return;
 252     }
 253     throw std::runtime_error("Unsupported ELF class or data encoding");
 254   }
 255
 256   void serialize(char* buf, size_t len, unsigned char ei_class,
 257                  unsigned char ei_data) {
 258     if (ei_class == ELFCLASS32) {
 259       serialize<typename T::Type32>(buf, len, ei_data);
 260       return;
 261     } else if (ei_class == ELFCLASS64) {
 262       serialize<typename T::Type64>(buf, len, ei_data);
 263       return;
 264     }
 265     throw std::runtime_error("Unsupported ELF class");
 266   }
 267
 268   static inline unsigned int size(unsigned char ei_class) {
 269     if (ei_class == ELFCLASS32)
 270       return sizeof(typename T::Type32);
 271     else if (ei_class == ELFCLASS64)
 272       return sizeof(typename T::Type64);
 273     return 0;
 274   }
 275 };
 276
 277 typedef serializable<Elf_Shdr_Traits> Elf_Shdr;
 278
 279 class Elf {
 280  public:
 281   Elf(std::ifstream& file);
 282   ~Elf();
 283
 284   /* index == -1 is treated as index == ehdr.e_shstrndx */
 285   ElfSection* getSection(int index);
 286
 287   ElfSection* getSectionAt(Elf64_Off offset);
 288
 289   ElfSegment* getSegmentByType(unsigned int type, ElfSegment* last = nullptr);
 290
 291   ElfDynamic_Section* getDynSection();
 292
 293   void normalize();
 294   void write(std::ofstream& file);
 295
 296   unsigned char getClass();
 297   unsigned char getData();
 298   unsigned char getType();
 299   unsigned char getMachine();
 300   unsigned int getSize();
 301
 302   void insertSegmentAfter(ElfSegment* previous, ElfSegment* segment) {
 303     std::vector<ElfSegment*>::iterator prev =
 304         std::find(segments.begin(), segments.end(), previous);
 305     segments.insert(prev + 1, segment);
 306   }
 307
 308   void removeSegment(ElfSegment* segment);
 309
 310  private:
 311   Elf_Ehdr* ehdr;
 312   ElfLocation eh_entry;
 313   ElfStrtab_Section* eh_shstrndx;
 314   ElfSection** sections;
 315   std::vector<ElfSegment*> segments;
 316   ElfSection *shdr_section, *phdr_section;
 317   /* Values used only during initialization */
 318   Elf_Shdr** tmp_shdr;
 319   std::ifstream* tmp_file;
 320 };
 321
 322 class ElfSection {
 323  public:
 324   typedef union {
 325     ElfSection* section;
 326     int index;
 327   } SectionInfo;
 328
 329   ElfSection(Elf_Shdr& s, std::ifstream* file, Elf* parent);
 330
 331   virtual ~ElfSection() { free(data); }
 332
 333   const char* getName() { return name; }
 334   unsigned int getType() { return shdr.sh_type; }
 335   unsigned int getFlags() { return shdr.sh_flags; }
 336   Elf64_Addr getAddr();
 337   Elf64_Off getSize() { return shdr.sh_size; }
 338   unsigned int getAddrAlign() { return shdr.sh_addralign; }
 339   unsigned int getEntSize() { return shdr.sh_entsize; }
 340   const char* getData() { return data; }
 341   ElfSection* getLink() { return link; }
 342   SectionInfo getInfo() { return info; }
 343
 344   void shrink(unsigned int newsize) {
 345     if (newsize < shdr.sh_size) {
 346       shdr.sh_size = newsize;
 347       markDirty();
 348     }
 349   }
 350
 351   void grow(unsigned int newsize) {
 352     if (newsize > shdr.sh_size) {
 353       data = static_cast<char*>(realloc(data, newsize));
 354       memset(data + shdr.sh_size, 0, newsize - shdr.sh_size);
 355       shdr.sh_size = newsize;
 356       markDirty();
 357     }
 358   }
 359
 360   Elf64_Off getOffset();
 361   int getIndex();
 362   Elf_Shdr& getShdr();
 363
 364   ElfSection* getNext() { return next; }
 365   ElfSection* getPrevious() { return previous; }
 366
 367   virtual bool isRelocatable() {
 368     return ((getType() == SHT_SYMTAB) || (getType() == SHT_STRTAB) ||
 369             (getType() == SHT_RELA) || (getType() == SHT_HASH) ||
 370             (getType() == SHT_NOTE) || (getType() == SHT_REL) ||
 371             (getType() == SHT_DYNSYM) || (getType() == SHT_GNU_HASH) ||
 372             (getType() == SHT_GNU_verdef) || (getType() == SHT_GNU_verneed) ||
 373             (getType() == SHT_GNU_versym) || getSegmentByType(PT_INTERP)) &&
 374            (getFlags() & SHF_ALLOC);
 375   }
 376
 377   void insertAfter(ElfSection* section, bool dirty = true) {
 378     if (previous != nullptr) previous->next = next;
 379     if (next != nullptr) next->previous = previous;
 380     previous = section;
 381     if (section != nullptr) {
 382       next = section->next;
 383       section->next = this;
 384     } else
 385       next = nullptr;
 386     if (next != nullptr) next->previous = this;
 387     if (dirty) markDirty();
 388     insertInSegments(section->segments);
 389   }
 390
 391   virtual void insertBefore(ElfSection* section, bool dirty = true) {
 392     if (previous != nullptr) previous->next = next;
 393     if (next != nullptr) next->previous = previous;
 394     next = section;
 395     if (section != nullptr) {
 396       previous = section->previous;
 397       section->previous = this;
 398     } else
 399       previous = nullptr;
 400     if (previous != nullptr) previous->next = this;
 401     if (dirty) markDirty();
 402     insertInSegments(section->segments);
 403   }
 404
 405   void markDirty() {
 406     if (link != nullptr) shdr.sh_link = -1;
 407     if (info.index) shdr.sh_info = -1;
 408     shdr.sh_offset = -1;
 409     if (isRelocatable()) shdr.sh_addr = -1;
 410     if (next) next->markDirty();
 411   }
 412
 413   virtual void serialize(std::ofstream& file, unsigned char ei_class,
 414                          unsigned char ei_data) {
 415     if (getType() == SHT_NOBITS) return;
 416     file.seekp(getOffset());
 417     file.write(data, getSize());
 418   }
 419
 420   ElfSegment* getSegmentByType(unsigned int type);
 421
 422  private:
 423   friend class ElfSegment;
 424
 425   void addToSegment(ElfSegment* segment) { segments.push_back(segment); }
 426
 427   void removeFromSegment(ElfSegment* segment) {
 428     std::vector<ElfSegment*>::iterator i =
 429         std::find(segments.begin(), segments.end(), segment);
 430     segments.erase(i, i + 1);
 431   }
 432
 433   void insertInSegments(std::vector<ElfSegment*>& segs);
 434
 435  protected:
 436   Elf_Shdr shdr;
 437   char* data;
 438   const char* name;
 439
 440  private:
 441   ElfSection* link;
 442   SectionInfo info;
 443   ElfSection *next, *previous;
 444   int index;
 445   std::vector<ElfSegment*> segments;
 446 };
 447
 448 class ElfSegment {
 449  public:
 450   ElfSegment(Elf_Phdr* phdr);
 451
 452   unsigned int getType() { return type; }
 453   unsigned int getFlags() { return flags; }
 454   unsigned int getAlign() { return align; }
 455
 456   ElfSection* getFirstSection() {
 457     return sections.empty() ? nullptr : sections.front();
 458   }
 459   int getVPDiff() { return v_p_diff; }
 460   unsigned int getFileSize();
 461   unsigned int getMemSize();
 462   unsigned int getOffset();
 463   unsigned int getAddr();
 464
 465   void addSection(ElfSection* section);
 466   void removeSection(ElfSection* section);
 467
 468   std::list<ElfSection*>::iterator begin() { return sections.begin(); }
 469   std::list<ElfSection*>::iterator end() { return sections.end(); }
 470
 471   void clear();
 472
 473  private:
 474   unsigned int type;
 475   int v_p_diff;  // Difference between physical and virtual address
 476   unsigned int flags;
 477   unsigned int align;
 478   std::list<ElfSection*> sections;
 479   // The following are only really used for PT_GNU_RELRO until something
 480   // better is found.
 481   unsigned int vaddr;
 482   unsigned int filesz, memsz;
 483 };
 484
 485 class Elf_Ehdr : public serializable<Elf_Ehdr_Traits>, public ElfSection {
 486  public:
 487   Elf_Ehdr(std::ifstream& file, unsigned char ei_class, unsigned char ei_data);
 488   void serialize(std::ofstream& file, unsigned char ei_class,
 489                  unsigned char ei_data) {
 490     serializable<Elf_Ehdr_Traits>::serialize(file, ei_class, ei_data);
 491   }
 492 };
 493
 494 class Elf_Phdr : public serializable<Elf_Phdr_Traits> {
 495  public:
 496   Elf_Phdr() {};
 497   Elf_Phdr(std::ifstream& file, unsigned char ei_class, unsigned char ei_data)
 498       : serializable<Elf_Phdr_Traits>(file, ei_class, ei_data) {};
 499   bool contains(ElfSection* section) {
 500     unsigned int size = section->getSize();
 501     unsigned int addr = section->getAddr();
 502     // This may be biased, but should work in most cases
 503     if ((section->getFlags() & SHF_ALLOC) == 0) return false;
 504     // Special case for PT_DYNAMIC. Eventually, this should
 505     // be better handled than special cases
 506     if ((p_type == PT_DYNAMIC) && (section->getType() != SHT_DYNAMIC))
 507       return false;
 508     // Special case for PT_TLS.
 509     if ((p_type == PT_TLS) && !(section->getFlags() & SHF_TLS)) return false;
 510     return (addr >= p_vaddr) && (addr + size <= p_vaddr + p_memsz);
 511   }
 512 };
 513
 514 typedef serializable<Elf_Dyn_Traits> Elf_Dyn;
 515
 516 struct Elf_DynValue {
 517   unsigned int tag;
 518   ElfValue* value;
 519 };
 520
 521 class ElfDynamic_Section : public ElfSection {
 522  public:
 523   ElfDynamic_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent);
 524   ~ElfDynamic_Section();
 525
 526   void serialize(std::ofstream& file, unsigned char ei_class,
 527                  unsigned char ei_data);
 528
 529   ElfValue* getValueForType(unsigned int tag);
 530   ElfSection* getSectionForType(unsigned int tag);
 531   bool setValueForType(unsigned int tag, ElfValue* val);
 532
 533  private:
 534   std::vector<Elf_DynValue> dyns;
 535 };
 536
 537 typedef serializable<Elf_Sym_Traits> Elf_Sym;
 538
 539 struct Elf_SymValue {
 540   const char* name;
 541   unsigned char info;
 542   unsigned char other;
 543   ElfLocation value;
 544   unsigned int size;
 545   bool defined;
 546 };
 547
 548 #define STT(type) (1 << STT_##type)
 549
 550 class ElfSymtab_Section : public ElfSection {
 551  public:
 552   ElfSymtab_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent);
 553
 554   void serialize(std::ofstream& file, unsigned char ei_class,
 555                  unsigned char ei_data);
 556
 557   Elf_SymValue* lookup(const char* name,
 558                        unsigned int type_filter = STT(OBJECT) | STT(FUNC));
 559
 560   // private: // Until we have a real API
 561   std::vector<Elf_SymValue> syms;
 562 };
 563
 564 class Elf_Rel : public serializable<Elf_Rel_Traits> {
 565  public:
 566   Elf_Rel() : serializable<Elf_Rel_Traits>() {};
 567
 568   Elf_Rel(std::ifstream& file, unsigned char ei_class, unsigned char ei_data)
 569       : serializable<Elf_Rel_Traits>(file, ei_class, ei_data) {};
 570
 571   static const unsigned int sh_type = SHT_REL;
 572   static const unsigned int d_tag = DT_REL;
 573   static const unsigned int d_tag_count = DT_RELCOUNT;
 574 };
 575
 576 class Elf_Rela : public serializable<Elf_Rela_Traits> {
 577  public:
 578   Elf_Rela() : serializable<Elf_Rela_Traits>() {};
 579
 580   Elf_Rela(std::ifstream& file, unsigned char ei_class, unsigned char ei_data)
 581       : serializable<Elf_Rela_Traits>(file, ei_class, ei_data) {};
 582
 583   static const unsigned int sh_type = SHT_RELA;
 584   static const unsigned int d_tag = DT_RELA;
 585   static const unsigned int d_tag_count = DT_RELACOUNT;
 586 };
 587
 588 template <class Rel>
 589 class ElfRel_Section : public ElfSection {
 590  public:
 591   ElfRel_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent)
 592       : ElfSection(s, file, parent) {
 593     auto pos = file->tellg();
 594     file->seekg(shdr.sh_offset);
 595     for (unsigned int i = 0; i < s.sh_size / s.sh_entsize; i++) {
 596       Rel r(*file, parent->getClass(), parent->getData());
 597       rels.push_back(r);
 598     }
 599     file->seekg(pos);
 600   }
 601
 602   void serialize(std::ofstream& file, unsigned char ei_class,
 603                  unsigned char ei_data) {
 604     for (typename std::vector<Rel>::iterator i = rels.begin(); i != rels.end();
 605          ++i)
 606       (*i).serialize(file, ei_class, ei_data);
 607   }
 608   // private: // Until we have a real API
 609   std::vector<Rel> rels;
 610 };
 611
 612 class ElfStrtab_Section : public ElfSection {
 613  public:
 614   ElfStrtab_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent)
 615       : ElfSection(s, file, parent) {
 616     table.push_back(table_storage(data, shdr.sh_size));
 617   }
 618
 619   ~ElfStrtab_Section() {
 620     for (std::vector<table_storage>::iterator t = table.begin() + 1;
 621          t != table.end(); ++t)
 622       delete[] t->buf;
 623   }
 624
 625   const char* getStr(unsigned int index);
 626
 627   const char* getStr(const char* string);
 628
 629   unsigned int getStrIndex(const char* string);
 630
 631   void serialize(std::ofstream& file, unsigned char ei_class,
 632                  unsigned char ei_data);
 633
 634  private:
 635   struct table_storage {
 636     unsigned int size, used;
 637     char* buf;
 638
 639     table_storage() : size(4096), used(0), buf(new char[4096]) {}
 640     table_storage(const char* data, unsigned int sz)
 641         : size(sz), used(sz), buf(const_cast<char*>(data)) {}
 642   };
 643   std::vector<table_storage> table;
 644 };
 645
 646 inline unsigned char Elf::getClass() { return ehdr->e_ident[EI_CLASS]; }
 647
 648 inline unsigned char Elf::getData() { return ehdr->e_ident[EI_DATA]; }
 649
 650 inline unsigned char Elf::getType() { return ehdr->e_type; }
 651
 652 inline unsigned char Elf::getMachine() { return ehdr->e_machine; }
 653
 654 inline unsigned int Elf::getSize() {
 655   ElfSection* section;
 656   for (section = shdr_section /* It's usually not far from the end */;
 657        section->getNext() != nullptr; section = section->getNext());
 658   return section->getOffset() + section->getSize();
 659 }
 660
 661 inline ElfSegment* ElfSection::getSegmentByType(unsigned int type) {
 662   for (std::vector<ElfSegment*>::iterator seg = segments.begin();
 663        seg != segments.end(); ++seg)
 664     if ((*seg)->getType() == type) return *seg;
 665   return nullptr;
 666 }
 667
 668 inline void ElfSection::insertInSegments(std::vector<ElfSegment*>& segs) {
 669   for (std::vector<ElfSegment*>::iterator it = segs.begin(); it != segs.end();
 670        ++it) {
 671     (*it)->addSection(this);
 672   }
 673 }
 674
 675 inline ElfLocation::ElfLocation(ElfSection* section, unsigned int off,
 676                                 enum position pos)
 677     : section(section) {
 678   if ((pos == ABSOLUTE) && section)
 679     offset = off - section->getAddr();
 680   else
 681     offset = off;
 682 }
 683
 684 inline ElfLocation::ElfLocation(unsigned int location, Elf* elf) {
 685   section = elf->getSectionAt(location);
 686   offset = location - (section ? section->getAddr() : 0);
 687 }
 688
 689 inline unsigned int ElfLocation::getValue() {
 690   return (section ? section->getAddr() : 0) + offset;
 691 }
 692
 693 inline const char* ElfLocation::getBuffer() {
 694   return section ? section->getData() + offset : nullptr;
 695 }
 696
 697 inline unsigned int ElfSize::getValue() { return section->getSize(); }
 698
 699 inline unsigned int ElfEntSize::getValue() { return section->getEntSize(); }