elfcpp/elfcpp_file.h

   1 // elfcpp_file.h -- file access for elfcpp   -*- C++ -*-
   2
   3 // Copyright (C) 2006-2022 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of elfcpp.
   7
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU Library General Public License
  10 // as published by the Free Software Foundation; either version 2, or
  11 // (at your option) any later version.
  12
  13 // In addition to the permissions in the GNU Library General Public
  14 // License, the Free Software Foundation gives you unlimited
  15 // permission to link the compiled version of this file into
  16 // combinations with other programs, and to distribute those
  17 // combinations without any restriction coming from the use of this
  18 // file.  (The Library Public License restrictions do apply in other
  19 // respects; for example, they cover modification of the file, and
  20 /// distribution when not linked into a combined executable.)
  21
  22 // This program is distributed in the hope that it will be useful, but
  23 // WITHOUT ANY WARRANTY; without even the implied warranty of
  24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25 // Library General Public License for more details.
  26
  27 // You should have received a copy of the GNU Library General Public
  28 // License along with this program; if not, write to the Free Software
  29 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  30 // 02110-1301, USA.
  31
  32 // This header file defines the class Elf_file which can be used to
  33 // read useful data from an ELF file.  The functions here are all
  34 // templates which take a file interface object as a parameter.  This
  35 // type must have a subtype View.  This type must support two methods:
  36 //     View view(off_t file_offset, off_t data_size)
  37 // returns a View for the specified part of the file.
  38 //     void error(const char* printf_format, ...)
  39 // prints an error message and does not return.  The subtype View must
  40 // support a method
  41 //     const unsigned char* data()
  42 // which returns a pointer to a buffer containing the requested data.
  43 // This general interface is used to read data from the file.  Objects
  44 // of type View will never survive longer than the elfcpp function.
  45
  46 // Some of these functions must return a reference to part of the
  47 // file.  To use these, the file interface must support a subtype
  48 // Location:
  49 //    Location(off_t file_offset, off_t data_size)
  50 // To use this in conjunction with the accessors types Shdr, etc., the
  51 // file interface should support an overload of view:
  52 //    View view(Location)
  53 // This permits writing
  54 //    elfcpp::Shdr shdr(file, ef.section_header(n));
  55
  56 #ifndef ELFCPP_FILE_H
  57 #define ELFCPP_FILE_H
  58
  59 #include <string>
  60 #include <cstdio>
  61 #include <cstring>
  62
  63 #include "elfcpp.h"
  64
  65 namespace elfcpp
  66 {
  67
  68 // A simple helper class to recognize if a file has an ELF header.
  69
  70 class Elf_recognizer
  71 {
  72  public:
  73   // Maximum header size.  The user should try to read this much of
  74   // the file when using this class.
  75
  76   static const int max_header_size = Elf_sizes<64>::ehdr_size;
  77
  78   // Checks if the file contains the ELF magic.  Other header fields
  79   // are not checked.
  80
  81   static bool
  82   is_elf_file(const unsigned char* ehdr_buf, int size);
  83
  84   // Check if EHDR_BUF/BUFSIZE is a valid header of a 32-bit or
  85   // 64-bit, little-endian or big-endian ELF file.  Assumes
  86   // is_elf_file() has been checked to be true.  If the header is not
  87   // valid, *ERROR contains a human-readable error message.  If is is,
  88   // *SIZE is set to either 32 or 64, *BIG_ENDIAN is set to indicate
  89   // whether the file is big-endian.
  90
  91   static bool
  92   is_valid_header(const unsigned char* ehdr_buf, off_t bufsize,
  93                   int* size, bool* big_endian,
  94                   std::string* error);
  95 };
  96
  97 // This object is used to read an ELF file.
  98 //   SIZE: The size of file, 32 or 64.
  99 //   BIG_ENDIAN: Whether the file is in big-endian format.
 100 //   FILE: A file reading type as described above.
 101
 102 template<int size, bool big_endian, typename File>
 103 class Elf_file
 104 {
 105  private:
 106   typedef Elf_file<size, big_endian, File> This;
 107
 108  public:
 109   static const int ehdr_size = Elf_sizes<size>::ehdr_size;
 110   static const int phdr_size = Elf_sizes<size>::phdr_size;
 111   static const int shdr_size = Elf_sizes<size>::shdr_size;
 112   static const int sym_size = Elf_sizes<size>::sym_size;
 113   static const int rel_size = Elf_sizes<size>::rel_size;
 114   static const int rela_size = Elf_sizes<size>::rela_size;
 115
 116   typedef Ehdr<size, big_endian> Ef_ehdr;
 117   typedef Phdr<size, big_endian> Ef_phdr;
 118   typedef Shdr<size, big_endian> Ef_shdr;
 119   typedef Sym<size, big_endian> Ef_sym;
 120
 121   // Construct an Elf_file given an ELF file header.
 122   Elf_file(File* file, const Ef_ehdr& ehdr)
 123   { this->construct(file, ehdr); }
 124
 125   // Construct an ELF file.
 126   inline
 127   Elf_file(File* file);
 128
 129   // Return the file offset to the section headers.
 130   off_t
 131   shoff() const
 132   { return this->shoff_; }
 133
 134   // Find the first section with an sh_type field equal to TYPE and
 135   // return its index.  Returns SHN_UNDEF if there is no such section.
 136   unsigned int
 137   find_section_by_type(unsigned int type);
 138
 139   // Return the number of sections.
 140   unsigned int
 141   shnum()
 142   {
 143     this->initialize_shnum();
 144     return this->shnum_;
 145   }
 146
 147   unsigned int
 148   shnum() const
 149   {
 150     if (this->shnum_ == 0 && this->shoff_ != 0)
 151       this->file_->error(_("ELF file has not been initialized yet"
 152                            " (internal error)"));
 153     return this->shnum_;
 154   }
 155
 156   // Return the section index of the section name string table.
 157   unsigned int
 158   shstrndx()
 159   {
 160     this->initialize_shnum();
 161     return this->shstrndx_;
 162   }
 163
 164   unsigned int
 165   shstrndx() const
 166   {
 167     if (this->shstrndx_ == SHN_XINDEX && this->shoff_ != 0)
 168       {
 169         this->file_->error(_("ELF file has not been initialized yet"
 170                              " (internal error)"));
 171         return 0;
 172       }
 173     return this->shstrndx_;
 174   }
 175
 176   // Return the value to subtract from section indexes >=
 177   // SHN_LORESERVE.  See the comment in initialize_shnum.
 178   int
 179   large_shndx_offset()
 180   {
 181     this->initialize_shnum();
 182     return this->large_shndx_offset_;
 183   }
 184
 185   int
 186   large_shndx_offset() const
 187   {
 188     if (this->shstrndx_ == SHN_XINDEX && this->shoff_ != 0)
 189       this->file_->error(_("ELF file has not been initialized yet"
 190                            " (internal error)"));
 191     return this->large_shndx_offset_;
 192   }
 193
 194   // Return the location of the header of section SHNDX.
 195   typename File::Location
 196   section_header(unsigned int shndx)
 197   {
 198     return typename File::Location(this->section_header_offset(shndx),
 199                                    shdr_size);
 200   }
 201
 202   // Return the name of section SHNDX.
 203   std::string
 204   section_name(unsigned int shndx) const;
 205
 206   // Return the location of the contents of section SHNDX.
 207   typename File::Location
 208   section_contents(unsigned int shndx);
 209
 210   // Return the size of section SHNDX.
 211   typename Elf_types<size>::Elf_WXword
 212   section_size(unsigned int shndx);
 213
 214   // Return the flags of section SHNDX.
 215   typename Elf_types<size>::Elf_WXword
 216   section_flags(unsigned int shndx);
 217
 218   // Return the address of section SHNDX.
 219   typename Elf_types<size>::Elf_Addr
 220   section_addr(unsigned int shndx);
 221
 222   // Return the type of section SHNDX.
 223   Elf_Word
 224   section_type(unsigned int shndx);
 225
 226   // Return the link field of section SHNDX.
 227   Elf_Word
 228   section_link(unsigned int shndx);
 229
 230   // Return the info field of section SHNDX.
 231   Elf_Word
 232   section_info(unsigned int shndx);
 233
 234   // Return the addralign field of section SHNDX.
 235   typename Elf_types<size>::Elf_WXword
 236   section_addralign(unsigned int shndx);
 237
 238  private:
 239   // Shared constructor code.
 240   void
 241   construct(File* file, const Ef_ehdr& ehdr);
 242
 243   // Initialize shnum_ and shstrndx_.
 244   void
 245   initialize_shnum();
 246
 247   // Return the file offset of the header of section SHNDX.
 248   off_t
 249   section_header_offset(unsigned int shndx) const;
 250
 251   // The file we are reading.
 252   File* file_;
 253   // The file offset to the section headers.
 254   off_t shoff_;
 255   // The number of sections.
 256   unsigned int shnum_;
 257   // The section index of the section name string table.
 258   unsigned int shstrndx_;
 259   // Offset to add to sections larger than SHN_LORESERVE.
 260   int large_shndx_offset_;
 261 };
 262
 263 // A small wrapper around SHT_STRTAB data mapped to memory. It checks that the
 264 // index is not out of bounds and the string is NULL-terminated.
 265
 266 class Elf_strtab
 267 {
 268  public:
 269   // Construct an Elf_strtab for a section with contents *P and size SIZE.
 270   Elf_strtab(const unsigned char* p, size_t size);
 271
 272   // Return the file offset to the section headers.
 273   bool
 274   get_c_string(size_t offset, const char** cstring) const
 275   {
 276     if (offset >= this->usable_size_)
 277       return false;
 278     *cstring = this->base_ + offset;
 279     return true;
 280   }
 281
 282  private:
 283   // Contents of the section mapped to memory.
 284   const char* base_;
 285   // One larger that the position of the last NULL character in the section.
 286   // For valid SHT_STRTAB sections, this is the size of the section.
 287   size_t usable_size_;
 288 };
 289
 290 // Inline function definitions.
 291
 292 // Check for presence of the ELF magic number.
 293
 294 inline bool
 295 Elf_recognizer::is_elf_file(const unsigned char* ehdr_buf, int size)
 296 {
 297   if (size < 4)
 298     return false;
 299
 300   static unsigned char elfmagic[4] =
 301     {
 302       elfcpp::ELFMAG0, elfcpp::ELFMAG1,
 303       elfcpp::ELFMAG2, elfcpp::ELFMAG3
 304     };
 305   return memcmp(ehdr_buf, elfmagic, 4) == 0;
 306 }
 307
 308 namespace
 309 {
 310
 311 // Print a number to a string.
 312
 313 inline std::string
 314 internal_printf_int(const char* format, int arg)
 315 {
 316   char buf[256];
 317   snprintf(buf, sizeof(buf), format, arg);
 318   return std::string(buf);
 319 }
 320
 321 }  // End anonymous namespace.
 322
 323 // Check the validity of the ELF header.
 324
 325 inline bool
 326 Elf_recognizer::is_valid_header(
 327     const unsigned char* ehdr_buf,
 328     off_t bufsize,
 329     int* size,
 330     bool* big_endian,
 331     std::string* error)
 332 {
 333   if (bufsize < elfcpp::EI_NIDENT)
 334     {
 335       *error = _("ELF file too short");
 336       return false;
 337     }
 338
 339   int v = ehdr_buf[elfcpp::EI_VERSION];
 340   if (v != elfcpp::EV_CURRENT)
 341     {
 342       if (v == elfcpp::EV_NONE)
 343         *error = _("invalid ELF version 0");
 344       else
 345         *error = internal_printf_int(_("unsupported ELF version %d"), v);
 346       return false;
 347     }
 348
 349   int c = ehdr_buf[elfcpp::EI_CLASS];
 350   if (c == elfcpp::ELFCLASSNONE)
 351     {
 352       *error = _("invalid ELF class 0");
 353       return false;
 354     }
 355   else if (c != elfcpp::ELFCLASS32
 356            && c != elfcpp::ELFCLASS64)
 357     {
 358       *error = internal_printf_int(_("unsupported ELF class %d"), c);
 359       return false;
 360     }
 361
 362   int d = ehdr_buf[elfcpp::EI_DATA];
 363   if (d == elfcpp::ELFDATANONE)
 364     {
 365       *error = _("invalid ELF data encoding");
 366       return false;
 367     }
 368   else if (d != elfcpp::ELFDATA2LSB
 369            && d != elfcpp::ELFDATA2MSB)
 370     {
 371       *error = internal_printf_int(_("unsupported ELF data encoding %d"), d);
 372       return false;
 373     }
 374
 375   *big_endian = (d == elfcpp::ELFDATA2MSB);
 376
 377   if (c == elfcpp::ELFCLASS32)
 378     {
 379       if (bufsize < elfcpp::Elf_sizes<32>::ehdr_size)
 380         {
 381           *error = _("ELF file too short");
 382           return false;
 383         }
 384       *size = 32;
 385     }
 386   else
 387     {
 388       if (bufsize < elfcpp::Elf_sizes<64>::ehdr_size)
 389         {
 390           *error = _("ELF file too short");
 391           return false;
 392         }
 393       *size = 64;
 394     }
 395
 396   return true;
 397 }
 398
 399 // Template function definitions.
 400
 401 // Construct an Elf_file given an ELF file header.
 402
 403 template<int size, bool big_endian, typename File>
 404 void
 405 Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr)
 406 {
 407   this->file_ = file;
 408   this->shoff_ = ehdr.get_e_shoff();
 409   this->shnum_ = ehdr.get_e_shnum();
 410   this->shstrndx_ = ehdr.get_e_shstrndx();
 411   this->large_shndx_offset_ = 0;
 412   if (ehdr.get_e_ehsize() != This::ehdr_size)
 413     file->error(_("bad e_ehsize (%d != %d)"),
 414                 ehdr.get_e_ehsize(), This::ehdr_size);
 415   if (ehdr.get_e_shentsize() != This::shdr_size)
 416     file->error(_("bad e_shentsize (%d != %d)"),
 417                 ehdr.get_e_shentsize(), This::shdr_size);
 418 }
 419
 420 // Construct an ELF file.
 421
 422 template<int size, bool big_endian, typename File>
 423 inline
 424 Elf_file<size, big_endian, File>::Elf_file(File* file)
 425 {
 426   typename File::View v(file->view(file_header_offset, This::ehdr_size));
 427   this->construct(file, Ef_ehdr(v.data()));
 428 }
 429
 430 // Initialize the shnum_ and shstrndx_ fields, handling overflow.
 431
 432 template<int size, bool big_endian, typename File>
 433 void
 434 Elf_file<size, big_endian, File>::initialize_shnum()
 435 {
 436   if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX)
 437       && this->shoff_ != 0)
 438     {
 439       typename File::View v(this->file_->view(this->shoff_, This::shdr_size));
 440       Ef_shdr shdr(v.data());
 441
 442       if (this->shnum_ == 0)
 443         this->shnum_ = shdr.get_sh_size();
 444
 445       if (this->shstrndx_ == SHN_XINDEX)
 446         {
 447           this->shstrndx_ = shdr.get_sh_link();
 448
 449           // Versions of the GNU binutils between 2.12 and 2.18 did
 450           // not handle objects with more than SHN_LORESERVE sections
 451           // correctly.  All large section indexes were offset by
 452           // 0x100.  Some information can be found here:
 453           // http://sourceware.org/bugzilla/show_bug.cgi?id=5900 .
 454           // Fortunately these object files are easy to detect, as the
 455           // GNU binutils always put the section header string table
 456           // near the end of the list of sections.  Thus if the
 457           // section header string table index is larger than the
 458           // number of sections, then we know we have to subtract
 459           // 0x100 to get the real section index.
 460           if (this->shstrndx_ >= this->shnum_)
 461             {
 462               if (this->shstrndx_ >= elfcpp::SHN_LORESERVE + 0x100)
 463                 {
 464                   this->large_shndx_offset_ = - 0x100;
 465                   this->shstrndx_ -= 0x100;
 466                 }
 467               if (this->shstrndx_ >= this->shnum_)
 468                 this->file_->error(_("bad shstrndx: %u >= %u"),
 469                                    this->shstrndx_, this->shnum_);
 470             }
 471         }
 472     }
 473 }
 474
 475 // Find section with sh_type equal to TYPE and return its index.
 476 // Returns SHN_UNDEF if not found.
 477
 478 template<int size, bool big_endian, typename File>
 479 unsigned int
 480 Elf_file<size, big_endian, File>::find_section_by_type(unsigned int type)
 481 {
 482   unsigned int shnum = this->shnum();
 483   typename File::View v(this->file_->view(this->shoff_,
 484                                           This::shdr_size * shnum));
 485   for (unsigned int i = 0; i < shnum; i++)
 486     {
 487       Ef_shdr shdr(v.data() + This::shdr_size * i);
 488       if (shdr.get_sh_type() == type)
 489         return i;
 490     }
 491   return SHN_UNDEF;
 492 }
 493
 494 // Return the file offset of the section header of section SHNDX.
 495
 496 template<int size, bool big_endian, typename File>
 497 off_t
 498 Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx) const
 499 {
 500   if (shndx >= this->shnum())
 501     this->file_->error(_("section_header_offset: bad shndx %u >= %u"),
 502                        shndx, this->shnum());
 503   return this->shoff_ + This::shdr_size * shndx;
 504 }
 505
 506 // Return the name of section SHNDX.
 507
 508 template<int size, bool big_endian, typename File>
 509 std::string
 510 Elf_file<size, big_endian, File>::section_name(unsigned int shndx) const
 511 {
 512   File* const file = this->file_;
 513
 514   // Get the section name offset.
 515   unsigned int sh_name;
 516   {
 517     typename File::View v(file->view(this->section_header_offset(shndx),
 518                                      This::shdr_size));
 519     Ef_shdr shdr(v.data());
 520     sh_name = shdr.get_sh_name();
 521   }
 522
 523   // Get the file offset for the section name string table data.
 524   off_t shstr_off;
 525   typename Elf_types<size>::Elf_WXword shstr_size;
 526   {
 527     const unsigned int shstrndx = this->shstrndx_;
 528     typename File::View v(file->view(this->section_header_offset(shstrndx),
 529                                      This::shdr_size));
 530     Ef_shdr shstr_shdr(v.data());
 531     shstr_off = shstr_shdr.get_sh_offset();
 532     shstr_size = shstr_shdr.get_sh_size();
 533   }
 534
 535   if (sh_name >= shstr_size)
 536     file->error(_("bad section name offset for section %u: %u"),
 537                 shndx, sh_name);
 538
 539   typename File::View v(file->view(shstr_off, shstr_size));
 540
 541   const unsigned char* datau = v.data();
 542   const char* data = reinterpret_cast<const char*>(datau);
 543   const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name);
 544   if (p == NULL)
 545     file->error(_("missing null terminator for name of section %u"),
 546                 shndx);
 547
 548   size_t len = static_cast<const char*>(p) - (data + sh_name);
 549
 550   return std::string(data + sh_name, len);
 551 }
 552
 553 // Return the contents of section SHNDX.
 554
 555 template<int size, bool big_endian, typename File>
 556 typename File::Location
 557 Elf_file<size, big_endian, File>::section_contents(unsigned int shndx)
 558 {
 559   File* const file = this->file_;
 560
 561   if (shndx >= this->shnum())
 562     file->error(_("section_contents: bad shndx %u >= %u"),
 563                 shndx, this->shnum());
 564
 565   typename File::View v(file->view(this->section_header_offset(shndx),
 566                                    This::shdr_size));
 567   Ef_shdr shdr(v.data());
 568   return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size());
 569 }
 570
 571 // Get the size of section SHNDX.
 572
 573 template<int size, bool big_endian, typename File>
 574 typename Elf_types<size>::Elf_WXword
 575 Elf_file<size, big_endian, File>::section_size(unsigned int shndx)
 576 {
 577   File* const file = this->file_;
 578
 579   if (shndx >= this->shnum())
 580     file->error(_("section_size: bad shndx %u >= %u"),
 581                 shndx, this->shnum());
 582
 583   typename File::View v(file->view(this->section_header_offset(shndx),
 584                                    This::shdr_size));
 585
 586   Ef_shdr shdr(v.data());
 587   return shdr.get_sh_size();
 588 }
 589
 590 // Return the section flags of section SHNDX.
 591
 592 template<int size, bool big_endian, typename File>
 593 typename Elf_types<size>::Elf_WXword
 594 Elf_file<size, big_endian, File>::section_flags(unsigned int shndx)
 595 {
 596   File* const file = this->file_;
 597
 598   if (shndx >= this->shnum())
 599     file->error(_("section_flags: bad shndx %u >= %u"),
 600                 shndx, this->shnum());
 601
 602   typename File::View v(file->view(this->section_header_offset(shndx),
 603                                    This::shdr_size));
 604
 605   Ef_shdr shdr(v.data());
 606   return shdr.get_sh_flags();
 607 }
 608
 609 // Return the address of section SHNDX.
 610
 611 template<int size, bool big_endian, typename File>
 612 typename Elf_types<size>::Elf_Addr
 613 Elf_file<size, big_endian, File>::section_addr(unsigned int shndx)
 614 {
 615   File* const file = this->file_;
 616
 617   if (shndx >= this->shnum())
 618     file->error(_("section_flags: bad shndx %u >= %u"),
 619                 shndx, this->shnum());
 620
 621   typename File::View v(file->view(this->section_header_offset(shndx),
 622                                    This::shdr_size));
 623
 624   Ef_shdr shdr(v.data());
 625   return shdr.get_sh_addr();
 626 }
 627
 628 // Return the type of section SHNDX.
 629
 630 template<int size, bool big_endian, typename File>
 631 Elf_Word
 632 Elf_file<size, big_endian, File>::section_type(unsigned int shndx)
 633 {
 634   File* const file = this->file_;
 635
 636   if (shndx >= this->shnum())
 637     file->error(_("section_type: bad shndx %u >= %u"),
 638                 shndx, this->shnum());
 639
 640   typename File::View v(file->view(this->section_header_offset(shndx),
 641                                    This::shdr_size));
 642
 643   Ef_shdr shdr(v.data());
 644   return shdr.get_sh_type();
 645 }
 646
 647 // Return the sh_link field of section SHNDX.
 648
 649 template<int size, bool big_endian, typename File>
 650 Elf_Word
 651 Elf_file<size, big_endian, File>::section_link(unsigned int shndx)
 652 {
 653   File* const file = this->file_;
 654
 655   if (shndx >= this->shnum())
 656     file->error(_("section_link: bad shndx %u >= %u"),
 657                 shndx, this->shnum());
 658
 659   typename File::View v(file->view(this->section_header_offset(shndx),
 660                                    This::shdr_size));
 661
 662   Ef_shdr shdr(v.data());
 663   return shdr.get_sh_link();
 664 }
 665
 666 // Return the sh_info field of section SHNDX.
 667
 668 template<int size, bool big_endian, typename File>
 669 Elf_Word
 670 Elf_file<size, big_endian, File>::section_info(unsigned int shndx)
 671 {
 672   File* const file = this->file_;
 673
 674   if (shndx >= this->shnum())
 675     file->error(_("section_info: bad shndx %u >= %u"),
 676                 shndx, this->shnum());
 677
 678   typename File::View v(file->view(this->section_header_offset(shndx),
 679                                    This::shdr_size));
 680
 681   Ef_shdr shdr(v.data());
 682   return shdr.get_sh_info();
 683 }
 684
 685 // Return the sh_addralign field of section SHNDX.
 686
 687 template<int size, bool big_endian, typename File>
 688 typename Elf_types<size>::Elf_WXword
 689 Elf_file<size, big_endian, File>::section_addralign(unsigned int shndx)
 690 {
 691   File* const file = this->file_;
 692
 693   if (shndx >= this->shnum())
 694     file->error(_("section_addralign: bad shndx %u >= %u"),
 695                 shndx, this->shnum());
 696
 697   typename File::View v(file->view(this->section_header_offset(shndx),
 698                                    This::shdr_size));
 699
 700   Ef_shdr shdr(v.data());
 701   return shdr.get_sh_addralign();
 702 }
 703
 704 inline
 705 Elf_strtab::Elf_strtab(const unsigned char* p, size_t size)
 706 {
 707   // Check if the section is NUL-terminated. If it isn't, we ignore
 708   // the last part to make sure we don't return non-NUL-terminated
 709   // strings.
 710   while (size > 0 && p[size - 1] != 0)
 711     size--;
 712   this->base_ = reinterpret_cast<const char*>(p);
 713   this->usable_size_ = size;
 714 }
 715
 716 } // End namespace elfcpp.
 717
 718 #endif // !defined(ELFCPP_FILE_H)