Add AArch64 SVE to NEWS and GDB manual
[external/binutils.git] / elfcpp / elfcpp_file.h
1 // elfcpp_file.h -- file access for elfcpp   -*- C++ -*-
2
3 // Copyright (C) 2006-2018 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)