Commit | Line | Data |
---|---|---|
645f8123 ILT |
1 | // elfcpp_file.h -- file access for elfcpp -*- C++ -*- |
2 | ||
6cb15b7f ILT |
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 | ||
645f8123 ILT |
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 | ||
a3ad94ed ILT |
134 | // Return the flags of section SHNDX. |
135 | typename Elf_types<size>::Elf_WXword | |
136 | section_flags(unsigned int shndx); | |
137 | ||
e698bc31 ILT |
138 | // Return the type of section SHNDX. |
139 | Elf_Word | |
140 | section_type(unsigned int shndx); | |
141 | ||
f7e2ee48 ILT |
142 | // Return the link field of section SHNDX. |
143 | Elf_Word | |
144 | section_link(unsigned int shndx); | |
145 | ||
f2f3f783 ILT |
146 | // Return the info field of section SHNDX. |
147 | Elf_Word | |
148 | section_info(unsigned int shndx); | |
149 | ||
150 | ||
645f8123 ILT |
151 | private: |
152 | // Shared constructor code. | |
153 | void | |
154 | construct(File* file, const Ef_ehdr& ehdr); | |
155 | ||
156 | // Initialize shnum_ and shstrndx_. | |
157 | void | |
158 | initialize_shnum(); | |
159 | ||
160 | // Return the file offset of the header of section SHNDX. | |
161 | off_t | |
162 | section_header_offset(unsigned int shndx); | |
163 | ||
164 | // The file we are reading. | |
165 | File* file_; | |
166 | // The file offset to the section headers. | |
167 | off_t shoff_; | |
168 | // The number of sections. | |
169 | unsigned int shnum_; | |
170 | // The section index of the section name string table. | |
171 | unsigned int shstrndx_; | |
172 | }; | |
173 | ||
174 | // Template function definitions. | |
175 | ||
176 | // Construct an Elf_file given an ELF file header. | |
177 | ||
178 | template<int size, bool big_endian, typename File> | |
179 | void | |
180 | Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr) | |
181 | { | |
182 | this->file_ = file; | |
183 | this->shoff_ = ehdr.get_e_shoff(); | |
184 | this->shnum_ = ehdr.get_e_shnum(); | |
185 | this->shstrndx_ = ehdr.get_e_shstrndx(); | |
186 | if (ehdr.get_e_ehsize() != This::ehdr_size) | |
187 | file->error(_("bad e_ehsize (%d != %d)"), | |
188 | ehdr.get_e_ehsize(), This::ehdr_size); | |
189 | if (ehdr.get_e_shentsize() != This::shdr_size) | |
190 | file->error(_("bad e_shentsize (%d != %d)"), | |
191 | ehdr.get_e_shentsize(), This::shdr_size); | |
192 | } | |
193 | ||
194 | // Construct an ELF file. | |
195 | ||
196 | template<int size, bool big_endian, typename File> | |
197 | inline | |
198 | Elf_file<size, big_endian, File>::Elf_file(File* file) | |
199 | { | |
200 | typename File::View v(file->view(file_header_offset, This::ehdr_size)); | |
201 | this->construct(file, Ef_ehdr(v.data())); | |
202 | } | |
203 | ||
204 | // Initialize the shnum_ and shstrndx_ fields, handling overflow. | |
205 | ||
206 | template<int size, bool big_endian, typename File> | |
207 | void | |
208 | Elf_file<size, big_endian, File>::initialize_shnum() | |
209 | { | |
210 | if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX) | |
211 | && this->shoff_ != 0) | |
212 | { | |
213 | typename File::View v(this->file_->view(this->shoff_, This::shdr_size)); | |
214 | Ef_shdr shdr(v.data()); | |
215 | if (this->shnum_ == 0) | |
216 | this->shnum_ = shdr.get_sh_size(); | |
217 | if (this->shstrndx_ == SHN_XINDEX) | |
218 | this->shstrndx_ = shdr.get_sh_link(); | |
219 | } | |
220 | } | |
221 | ||
222 | // Return the file offset of the section header of section SHNDX. | |
223 | ||
224 | template<int size, bool big_endian, typename File> | |
225 | off_t | |
226 | Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx) | |
227 | { | |
228 | if (shndx >= this->shnum()) | |
229 | this->file_->error(_("section_header_offset: bad shndx %u >= %u"), | |
230 | shndx, this->shnum()); | |
231 | return this->shoff_ + This::shdr_size * shndx; | |
232 | } | |
233 | ||
234 | // Return the name of section SHNDX. | |
235 | ||
236 | template<int size, bool big_endian, typename File> | |
237 | std::string | |
238 | Elf_file<size, big_endian, File>::section_name(unsigned int shndx) | |
239 | { | |
240 | File* const file = this->file_; | |
241 | ||
242 | // Get the section name offset. | |
243 | unsigned int sh_name; | |
244 | { | |
245 | typename File::View v(file->view(this->section_header_offset(shndx), | |
246 | This::shdr_size)); | |
247 | Ef_shdr shdr(v.data()); | |
248 | sh_name = shdr.get_sh_name(); | |
249 | } | |
250 | ||
251 | // Get the file offset for the section name string table data. | |
252 | off_t shstr_off; | |
253 | off_t shstr_size; | |
254 | { | |
255 | const unsigned int shstrndx = this->shstrndx_; | |
256 | typename File::View v(file->view(this->section_header_offset(shstrndx), | |
257 | This::shdr_size)); | |
258 | Ef_shdr shstr_shdr(v.data()); | |
259 | shstr_off = shstr_shdr.get_sh_offset(); | |
260 | shstr_size = shstr_shdr.get_sh_size(); | |
261 | } | |
262 | ||
263 | if (sh_name >= shstr_size) | |
264 | file->error(_("bad section name offset for section %u: %u"), | |
265 | shndx, sh_name); | |
266 | ||
267 | typename File::View v(file->view(shstr_off, shstr_size)); | |
268 | ||
269 | const unsigned char* datau = v.data(); | |
270 | const char* data = reinterpret_cast<const char*>(datau); | |
271 | const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name); | |
272 | if (p == NULL) | |
273 | file->error(_("missing null terminator for name of section %u"), | |
274 | shndx); | |
275 | ||
276 | size_t len = static_cast<const char*>(p) - (data + sh_name); | |
277 | ||
278 | return std::string(data + sh_name, len); | |
279 | } | |
280 | ||
281 | // Return the contents of section SHNDX. | |
282 | ||
283 | template<int size, bool big_endian, typename File> | |
284 | typename File::Location | |
285 | Elf_file<size, big_endian, File>::section_contents(unsigned int shndx) | |
286 | { | |
287 | File* const file = this->file_; | |
288 | ||
289 | if (shndx >= this->shnum()) | |
290 | file->error(_("section_contents: bad shndx %u >= %u"), | |
291 | shndx, this->shnum()); | |
292 | ||
293 | typename File::View v(file->view(this->section_header_offset(shndx), | |
294 | This::shdr_size)); | |
295 | Ef_shdr shdr(v.data()); | |
296 | return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size()); | |
297 | } | |
298 | ||
a3ad94ed ILT |
299 | // Return the section flags of section SHNDX. |
300 | ||
301 | template<int size, bool big_endian, typename File> | |
302 | typename Elf_types<size>::Elf_WXword | |
303 | Elf_file<size, big_endian, File>::section_flags(unsigned int shndx) | |
304 | { | |
305 | File* const file = this->file_; | |
306 | ||
307 | if (shndx >= this->shnum()) | |
308 | file->error(_("section_flags: bad shndx %u >= %u"), | |
309 | shndx, this->shnum()); | |
310 | ||
311 | typename File::View v(file->view(this->section_header_offset(shndx), | |
312 | This::shdr_size)); | |
313 | ||
314 | Ef_shdr shdr(v.data()); | |
315 | return shdr.get_sh_flags(); | |
316 | } | |
317 | ||
e698bc31 ILT |
318 | // Return the type of section SHNDX. |
319 | ||
320 | template<int size, bool big_endian, typename File> | |
321 | Elf_Word | |
322 | Elf_file<size, big_endian, File>::section_type(unsigned int shndx) | |
323 | { | |
324 | File* const file = this->file_; | |
325 | ||
326 | if (shndx >= this->shnum()) | |
327 | file->error(_("section_type: bad shndx %u >= %u"), | |
328 | shndx, this->shnum()); | |
329 | ||
330 | typename File::View v(file->view(this->section_header_offset(shndx), | |
331 | This::shdr_size)); | |
332 | ||
333 | Ef_shdr shdr(v.data()); | |
334 | return shdr.get_sh_type(); | |
335 | } | |
336 | ||
f7e2ee48 ILT |
337 | // Return the sh_link field of section SHNDX. |
338 | ||
339 | template<int size, bool big_endian, typename File> | |
340 | Elf_Word | |
341 | Elf_file<size, big_endian, File>::section_link(unsigned int shndx) | |
342 | { | |
343 | File* const file = this->file_; | |
344 | ||
345 | if (shndx >= this->shnum()) | |
346 | file->error(_("section_link: bad shndx %u >= %u"), | |
347 | shndx, this->shnum()); | |
348 | ||
349 | typename File::View v(file->view(this->section_header_offset(shndx), | |
350 | This::shdr_size)); | |
351 | ||
352 | Ef_shdr shdr(v.data()); | |
353 | return shdr.get_sh_link(); | |
354 | } | |
355 | ||
f2f3f783 ILT |
356 | // Return the sh_info field of section SHNDX. |
357 | ||
358 | template<int size, bool big_endian, typename File> | |
359 | Elf_Word | |
360 | Elf_file<size, big_endian, File>::section_info(unsigned int shndx) | |
361 | { | |
362 | File* const file = this->file_; | |
363 | ||
364 | if (shndx >= this->shnum()) | |
365 | file->error(_("section_info: bad shndx %u >= %u"), | |
366 | shndx, this->shnum()); | |
367 | ||
368 | typename File::View v(file->view(this->section_header_offset(shndx), | |
369 | This::shdr_size)); | |
370 | ||
371 | Ef_shdr shdr(v.data()); | |
372 | return shdr.get_sh_info(); | |
373 | } | |
374 | ||
645f8123 ILT |
375 | } // End namespace elfcpp. |
376 | ||
377 | #endif // !defined(ELFCPP_FILE_H) |