Add support for returning the section type.
[external/binutils.git] / elfcpp / elfcpp_file.h
1 // elfcpp_file.h -- file access for elfcpp   -*- C++ -*-
2
3 // This header file defines the class Elf_file which can be used to
4 // read useful data from an ELF file.  The functions here are all
5 // templates which take a file interface object as a parameter.  This
6 // type must have a subtype View.  This type must support two methods:
7 //     View view(off_t file_offset, off_t data_size)
8 // returns a View for the specified part of the file.
9 //     void error(const char* printf_format, ...)
10 // prints an error message and does not return.  The subtype View must
11 // support a method
12 //     const unsigned char* data()
13 // which returns a pointer to a buffer containing the requested data.
14 // This general interface is used to read data from the file.  Objects
15 // of type View will never survive longer than the elfcpp function.
16
17 // Some of these functions must return a reference to part of the
18 // file.  To use these, the file interface must support a subtype
19 // Location:
20 //    Location(off_t file_offset, off_t data_size)
21 // To use this in conjunction with the accessors types Shdr, etc., the
22 // file interface should support an overload of view:
23 //    View view(Location)
24 // This permits writing
25 //    elfcpp::Shdr shdr(file, ef.section_header(n));
26
27 #ifndef ELFPCP_FILE_H
28 #define ELFCPP_FILE_H
29
30 #include <string>
31 #include <cstring>
32
33 namespace elfcpp
34 {
35
36 // This object is used to read an ELF file.
37 //   SIZE: The size of file, 32 or 64.
38 //   BIG_ENDIAN: Whether the file is in big-endian format.
39 //   FILE: A file reading type as described above.
40
41 template<int size, bool big_endian, typename File>
42 class Elf_file
43 {
44  private:
45   typedef Elf_file<size, big_endian, File> This;
46
47  public:
48   static const int ehdr_size = Elf_sizes<size>::ehdr_size;
49   static const int phdr_size = Elf_sizes<size>::phdr_size;
50   static const int shdr_size = Elf_sizes<size>::shdr_size;
51   static const int sym_size = Elf_sizes<size>::sym_size;
52   static const int rel_size = Elf_sizes<size>::rel_size;
53   static const int rela_size = Elf_sizes<size>::rela_size;
54
55   typedef Ehdr<size, big_endian> Ef_ehdr;
56   typedef Phdr<size, big_endian> Ef_phdr;
57   typedef Shdr<size, big_endian> Ef_shdr;
58   typedef Sym<size, big_endian> Ef_sym;
59
60   // Construct an Elf_file given an ELF file header.
61   Elf_file(File* file, const Ef_ehdr& ehdr)
62   { this->construct(file, ehdr); }
63
64   // Construct an ELF file.
65   inline
66   Elf_file(File* file);
67
68   // Return the file offset to the section headers.
69   off_t
70   shoff() const
71   { return this->shoff_; }
72
73   // Return the number of sections.
74   unsigned int
75   shnum()
76   {
77     this->initialize_shnum();
78     return this->shnum_;
79   }
80
81   // Return the section index of the section name string table.
82   unsigned int
83   shstrndx()
84   {
85     this->initialize_shnum();
86     return this->shstrndx_;
87   }
88
89   // Return the location of the header of section SHNDX.
90   typename File::Location
91   section_header(unsigned int shndx)
92   {
93     return typename File::Location(this->section_header_offset(shndx),
94                                    shdr_size);
95   }
96
97   // Return the name of section SHNDX.
98   std::string
99   section_name(unsigned int shndx);
100
101   // Return the location of the contents of section SHNDX.
102   typename File::Location
103   section_contents(unsigned int shndx);
104
105   // Return the flags of section SHNDX.
106   typename Elf_types<size>::Elf_WXword
107   section_flags(unsigned int shndx);
108
109   // Return the type of section SHNDX.
110   Elf_Word
111   section_type(unsigned int shndx);
112
113  private:
114   // Shared constructor code.
115   void
116   construct(File* file, const Ef_ehdr& ehdr);
117
118   // Initialize shnum_ and shstrndx_.
119   void
120   initialize_shnum();
121
122   // Return the file offset of the header of section SHNDX.
123   off_t
124   section_header_offset(unsigned int shndx);
125
126   // The file we are reading.
127   File* file_;
128   // The file offset to the section headers.
129   off_t shoff_;
130   // The number of sections.
131   unsigned int shnum_;
132   // The section index of the section name string table.
133   unsigned int shstrndx_;
134 };
135
136 // Template function definitions.
137
138 // Construct an Elf_file given an ELF file header.
139
140 template<int size, bool big_endian, typename File>
141 void
142 Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr)
143 {
144   this->file_ = file;
145   this->shoff_ = ehdr.get_e_shoff();
146   this->shnum_ = ehdr.get_e_shnum();
147   this->shstrndx_ = ehdr.get_e_shstrndx();
148   if (ehdr.get_e_ehsize() != This::ehdr_size)
149     file->error(_("bad e_ehsize (%d != %d)"),
150                 ehdr.get_e_ehsize(), This::ehdr_size);
151   if (ehdr.get_e_shentsize() != This::shdr_size)
152     file->error(_("bad e_shentsize (%d != %d)"),
153                 ehdr.get_e_shentsize(), This::shdr_size);
154 }
155
156 // Construct an ELF file.
157
158 template<int size, bool big_endian, typename File>
159 inline
160 Elf_file<size, big_endian, File>::Elf_file(File* file)
161 {
162   typename File::View v(file->view(file_header_offset, This::ehdr_size));
163   this->construct(file, Ef_ehdr(v.data()));
164 }
165
166 // Initialize the shnum_ and shstrndx_ fields, handling overflow.
167
168 template<int size, bool big_endian, typename File>
169 void
170 Elf_file<size, big_endian, File>::initialize_shnum()
171 {
172   if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX)
173       && this->shoff_ != 0)
174     {
175       typename File::View v(this->file_->view(this->shoff_, This::shdr_size));
176       Ef_shdr shdr(v.data());
177       if (this->shnum_ == 0)
178         this->shnum_ = shdr.get_sh_size();
179       if (this->shstrndx_ == SHN_XINDEX)
180         this->shstrndx_ = shdr.get_sh_link();
181     }
182 }
183
184 // Return the file offset of the section header of section SHNDX.
185
186 template<int size, bool big_endian, typename File>
187 off_t
188 Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx)
189 {
190   if (shndx >= this->shnum())
191     this->file_->error(_("section_header_offset: bad shndx %u >= %u"),
192                        shndx, this->shnum());
193   return this->shoff_ + This::shdr_size * shndx;
194 }
195
196 // Return the name of section SHNDX.
197
198 template<int size, bool big_endian, typename File>
199 std::string
200 Elf_file<size, big_endian, File>::section_name(unsigned int shndx)
201 {
202   File* const file = this->file_;
203
204   // Get the section name offset.
205   unsigned int sh_name;
206   {
207     typename File::View v(file->view(this->section_header_offset(shndx),
208                                      This::shdr_size));
209     Ef_shdr shdr(v.data());
210     sh_name = shdr.get_sh_name();
211   }
212
213   // Get the file offset for the section name string table data.
214   off_t shstr_off;
215   off_t shstr_size;
216   {
217     const unsigned int shstrndx = this->shstrndx_;
218     typename File::View v(file->view(this->section_header_offset(shstrndx),
219                                      This::shdr_size));
220     Ef_shdr shstr_shdr(v.data());
221     shstr_off = shstr_shdr.get_sh_offset();
222     shstr_size = shstr_shdr.get_sh_size();
223   }
224
225   if (sh_name >= shstr_size)
226     file->error(_("bad section name offset for section %u: %u"),
227                 shndx, sh_name);
228
229   typename File::View v(file->view(shstr_off, shstr_size));
230
231   const unsigned char* datau = v.data();
232   const char* data = reinterpret_cast<const char*>(datau);
233   const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name);
234   if (p == NULL)
235     file->error(_("missing null terminator for name of section %u"),
236                 shndx);
237
238   size_t len = static_cast<const char*>(p) - (data + sh_name);
239
240   return std::string(data + sh_name, len);
241 }
242
243 // Return the contents of section SHNDX.
244
245 template<int size, bool big_endian, typename File>
246 typename File::Location
247 Elf_file<size, big_endian, File>::section_contents(unsigned int shndx)
248 {
249   File* const file = this->file_;
250
251   if (shndx >= this->shnum())
252     file->error(_("section_contents: bad shndx %u >= %u"),
253                 shndx, this->shnum());
254
255   typename File::View v(file->view(this->section_header_offset(shndx),
256                                    This::shdr_size));
257   Ef_shdr shdr(v.data());
258   return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size());
259 }
260
261 // Return the section flags of section SHNDX.
262
263 template<int size, bool big_endian, typename File>
264 typename Elf_types<size>::Elf_WXword
265 Elf_file<size, big_endian, File>::section_flags(unsigned int shndx)
266 {
267   File* const file = this->file_;
268
269   if (shndx >= this->shnum())
270     file->error(_("section_flags: bad shndx %u >= %u"),
271                 shndx, this->shnum());
272
273   typename File::View v(file->view(this->section_header_offset(shndx),
274                                    This::shdr_size));
275
276   Ef_shdr shdr(v.data());
277   return shdr.get_sh_flags();
278 }
279
280 // Return the type of section SHNDX.
281
282 template<int size, bool big_endian, typename File>
283 Elf_Word
284 Elf_file<size, big_endian, File>::section_type(unsigned int shndx)
285 {
286   File* const file = this->file_;
287
288   if (shndx >= this->shnum())
289     file->error(_("section_type: bad shndx %u >= %u"),
290                 shndx, this->shnum());
291
292   typename File::View v(file->view(this->section_header_offset(shndx),
293                                    This::shdr_size));
294
295   Ef_shdr shdr(v.data());
296   return shdr.get_sh_type();
297 }
298
299 } // End namespace elfcpp.
300
301 #endif // !defined(ELFCPP_FILE_H)