Reworked from Andrew Chatham: report error locations.
[external/binutils.git] / elfcpp / elfcpp_file.h
1 // elfcpp_file.h -- file access for elfcpp   -*- C++ -*-
2
3 // Copyright 2006, 2007, 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 ELFPCP_FILE_H
57 #define ELFCPP_FILE_H
58
59 #include <string>
60 #include <cstring>
61
62 namespace elfcpp
63 {
64
65 // This object is used to read an ELF file.
66 //   SIZE: The size of file, 32 or 64.
67 //   BIG_ENDIAN: Whether the file is in big-endian format.
68 //   FILE: A file reading type as described above.
69
70 template<int size, bool big_endian, typename File>
71 class Elf_file
72 {
73  private:
74   typedef Elf_file<size, big_endian, File> This;
75
76  public:
77   static const int ehdr_size = Elf_sizes<size>::ehdr_size;
78   static const int phdr_size = Elf_sizes<size>::phdr_size;
79   static const int shdr_size = Elf_sizes<size>::shdr_size;
80   static const int sym_size = Elf_sizes<size>::sym_size;
81   static const int rel_size = Elf_sizes<size>::rel_size;
82   static const int rela_size = Elf_sizes<size>::rela_size;
83
84   typedef Ehdr<size, big_endian> Ef_ehdr;
85   typedef Phdr<size, big_endian> Ef_phdr;
86   typedef Shdr<size, big_endian> Ef_shdr;
87   typedef Sym<size, big_endian> Ef_sym;
88
89   // Construct an Elf_file given an ELF file header.
90   Elf_file(File* file, const Ef_ehdr& ehdr)
91   { this->construct(file, ehdr); }
92
93   // Construct an ELF file.
94   inline
95   Elf_file(File* file);
96
97   // Return the file offset to the section headers.
98   off_t
99   shoff() const
100   { return this->shoff_; }
101
102   // Return the number of sections.
103   unsigned int
104   shnum()
105   {
106     this->initialize_shnum();
107     return this->shnum_;
108   }
109
110   // Return the section index of the section name string table.
111   unsigned int
112   shstrndx()
113   {
114     this->initialize_shnum();
115     return this->shstrndx_;
116   }
117
118   // Return the location of the header of section SHNDX.
119   typename File::Location
120   section_header(unsigned int shndx)
121   {
122     return typename File::Location(this->section_header_offset(shndx),
123                                    shdr_size);
124   }
125
126   // Return the name of section SHNDX.
127   std::string
128   section_name(unsigned int shndx);
129
130   // Return the location of the contents of section SHNDX.
131   typename File::Location
132   section_contents(unsigned int shndx);
133
134   // Return the flags of section SHNDX.
135   typename Elf_types<size>::Elf_WXword
136   section_flags(unsigned int shndx);
137
138   // Return the type of section SHNDX.
139   Elf_Word
140   section_type(unsigned int shndx);
141
142   // Return the link field of section SHNDX.
143   Elf_Word
144   section_link(unsigned int shndx);
145
146  private:
147   // Shared constructor code.
148   void
149   construct(File* file, const Ef_ehdr& ehdr);
150
151   // Initialize shnum_ and shstrndx_.
152   void
153   initialize_shnum();
154
155   // Return the file offset of the header of section SHNDX.
156   off_t
157   section_header_offset(unsigned int shndx);
158
159   // The file we are reading.
160   File* file_;
161   // The file offset to the section headers.
162   off_t shoff_;
163   // The number of sections.
164   unsigned int shnum_;
165   // The section index of the section name string table.
166   unsigned int shstrndx_;
167 };
168
169 // Template function definitions.
170
171 // Construct an Elf_file given an ELF file header.
172
173 template<int size, bool big_endian, typename File>
174 void
175 Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr)
176 {
177   this->file_ = file;
178   this->shoff_ = ehdr.get_e_shoff();
179   this->shnum_ = ehdr.get_e_shnum();
180   this->shstrndx_ = ehdr.get_e_shstrndx();
181   if (ehdr.get_e_ehsize() != This::ehdr_size)
182     file->error(_("bad e_ehsize (%d != %d)"),
183                 ehdr.get_e_ehsize(), This::ehdr_size);
184   if (ehdr.get_e_shentsize() != This::shdr_size)
185     file->error(_("bad e_shentsize (%d != %d)"),
186                 ehdr.get_e_shentsize(), This::shdr_size);
187 }
188
189 // Construct an ELF file.
190
191 template<int size, bool big_endian, typename File>
192 inline
193 Elf_file<size, big_endian, File>::Elf_file(File* file)
194 {
195   typename File::View v(file->view(file_header_offset, This::ehdr_size));
196   this->construct(file, Ef_ehdr(v.data()));
197 }
198
199 // Initialize the shnum_ and shstrndx_ fields, handling overflow.
200
201 template<int size, bool big_endian, typename File>
202 void
203 Elf_file<size, big_endian, File>::initialize_shnum()
204 {
205   if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX)
206       && this->shoff_ != 0)
207     {
208       typename File::View v(this->file_->view(this->shoff_, This::shdr_size));
209       Ef_shdr shdr(v.data());
210       if (this->shnum_ == 0)
211         this->shnum_ = shdr.get_sh_size();
212       if (this->shstrndx_ == SHN_XINDEX)
213         this->shstrndx_ = shdr.get_sh_link();
214     }
215 }
216
217 // Return the file offset of the section header of section SHNDX.
218
219 template<int size, bool big_endian, typename File>
220 off_t
221 Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx)
222 {
223   if (shndx >= this->shnum())
224     this->file_->error(_("section_header_offset: bad shndx %u >= %u"),
225                        shndx, this->shnum());
226   return this->shoff_ + This::shdr_size * shndx;
227 }
228
229 // Return the name of section SHNDX.
230
231 template<int size, bool big_endian, typename File>
232 std::string
233 Elf_file<size, big_endian, File>::section_name(unsigned int shndx)
234 {
235   File* const file = this->file_;
236
237   // Get the section name offset.
238   unsigned int sh_name;
239   {
240     typename File::View v(file->view(this->section_header_offset(shndx),
241                                      This::shdr_size));
242     Ef_shdr shdr(v.data());
243     sh_name = shdr.get_sh_name();
244   }
245
246   // Get the file offset for the section name string table data.
247   off_t shstr_off;
248   off_t shstr_size;
249   {
250     const unsigned int shstrndx = this->shstrndx_;
251     typename File::View v(file->view(this->section_header_offset(shstrndx),
252                                      This::shdr_size));
253     Ef_shdr shstr_shdr(v.data());
254     shstr_off = shstr_shdr.get_sh_offset();
255     shstr_size = shstr_shdr.get_sh_size();
256   }
257
258   if (sh_name >= shstr_size)
259     file->error(_("bad section name offset for section %u: %u"),
260                 shndx, sh_name);
261
262   typename File::View v(file->view(shstr_off, shstr_size));
263
264   const unsigned char* datau = v.data();
265   const char* data = reinterpret_cast<const char*>(datau);
266   const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name);
267   if (p == NULL)
268     file->error(_("missing null terminator for name of section %u"),
269                 shndx);
270
271   size_t len = static_cast<const char*>(p) - (data + sh_name);
272
273   return std::string(data + sh_name, len);
274 }
275
276 // Return the contents of section SHNDX.
277
278 template<int size, bool big_endian, typename File>
279 typename File::Location
280 Elf_file<size, big_endian, File>::section_contents(unsigned int shndx)
281 {
282   File* const file = this->file_;
283
284   if (shndx >= this->shnum())
285     file->error(_("section_contents: bad shndx %u >= %u"),
286                 shndx, this->shnum());
287
288   typename File::View v(file->view(this->section_header_offset(shndx),
289                                    This::shdr_size));
290   Ef_shdr shdr(v.data());
291   return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size());
292 }
293
294 // Return the section flags of section SHNDX.
295
296 template<int size, bool big_endian, typename File>
297 typename Elf_types<size>::Elf_WXword
298 Elf_file<size, big_endian, File>::section_flags(unsigned int shndx)
299 {
300   File* const file = this->file_;
301
302   if (shndx >= this->shnum())
303     file->error(_("section_flags: bad shndx %u >= %u"),
304                 shndx, this->shnum());
305
306   typename File::View v(file->view(this->section_header_offset(shndx),
307                                    This::shdr_size));
308
309   Ef_shdr shdr(v.data());
310   return shdr.get_sh_flags();
311 }
312
313 // Return the type of section SHNDX.
314
315 template<int size, bool big_endian, typename File>
316 Elf_Word
317 Elf_file<size, big_endian, File>::section_type(unsigned int shndx)
318 {
319   File* const file = this->file_;
320
321   if (shndx >= this->shnum())
322     file->error(_("section_type: bad shndx %u >= %u"),
323                 shndx, this->shnum());
324
325   typename File::View v(file->view(this->section_header_offset(shndx),
326                                    This::shdr_size));
327
328   Ef_shdr shdr(v.data());
329   return shdr.get_sh_type();
330 }
331
332 // Return the sh_link field of section SHNDX.
333
334 template<int size, bool big_endian, typename File>
335 Elf_Word
336 Elf_file<size, big_endian, File>::section_link(unsigned int shndx)
337 {
338   File* const file = this->file_;
339
340   if (shndx >= this->shnum())
341     file->error(_("section_link: bad shndx %u >= %u"),
342                 shndx, this->shnum());
343
344   typename File::View v(file->view(this->section_header_offset(shndx),
345                                    This::shdr_size));
346
347   Ef_shdr shdr(v.data());
348   return shdr.get_sh_link();
349 }
350
351 } // End namespace elfcpp.
352
353 #endif // !defined(ELFCPP_FILE_H)