Commit | Line | Data |
---|---|---|
645f8123 ILT |
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 | ||
a3ad94ed ILT |
105 | // Return the flags of section SHNDX. |
106 | typename Elf_types<size>::Elf_WXword | |
107 | section_flags(unsigned int shndx); | |
108 | ||
645f8123 ILT |
109 | private: |
110 | // Shared constructor code. | |
111 | void | |
112 | construct(File* file, const Ef_ehdr& ehdr); | |
113 | ||
114 | // Initialize shnum_ and shstrndx_. | |
115 | void | |
116 | initialize_shnum(); | |
117 | ||
118 | // Return the file offset of the header of section SHNDX. | |
119 | off_t | |
120 | section_header_offset(unsigned int shndx); | |
121 | ||
122 | // The file we are reading. | |
123 | File* file_; | |
124 | // The file offset to the section headers. | |
125 | off_t shoff_; | |
126 | // The number of sections. | |
127 | unsigned int shnum_; | |
128 | // The section index of the section name string table. | |
129 | unsigned int shstrndx_; | |
130 | }; | |
131 | ||
132 | // Template function definitions. | |
133 | ||
134 | // Construct an Elf_file given an ELF file header. | |
135 | ||
136 | template<int size, bool big_endian, typename File> | |
137 | void | |
138 | Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr) | |
139 | { | |
140 | this->file_ = file; | |
141 | this->shoff_ = ehdr.get_e_shoff(); | |
142 | this->shnum_ = ehdr.get_e_shnum(); | |
143 | this->shstrndx_ = ehdr.get_e_shstrndx(); | |
144 | if (ehdr.get_e_ehsize() != This::ehdr_size) | |
145 | file->error(_("bad e_ehsize (%d != %d)"), | |
146 | ehdr.get_e_ehsize(), This::ehdr_size); | |
147 | if (ehdr.get_e_shentsize() != This::shdr_size) | |
148 | file->error(_("bad e_shentsize (%d != %d)"), | |
149 | ehdr.get_e_shentsize(), This::shdr_size); | |
150 | } | |
151 | ||
152 | // Construct an ELF file. | |
153 | ||
154 | template<int size, bool big_endian, typename File> | |
155 | inline | |
156 | Elf_file<size, big_endian, File>::Elf_file(File* file) | |
157 | { | |
158 | typename File::View v(file->view(file_header_offset, This::ehdr_size)); | |
159 | this->construct(file, Ef_ehdr(v.data())); | |
160 | } | |
161 | ||
162 | // Initialize the shnum_ and shstrndx_ fields, handling overflow. | |
163 | ||
164 | template<int size, bool big_endian, typename File> | |
165 | void | |
166 | Elf_file<size, big_endian, File>::initialize_shnum() | |
167 | { | |
168 | if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX) | |
169 | && this->shoff_ != 0) | |
170 | { | |
171 | typename File::View v(this->file_->view(this->shoff_, This::shdr_size)); | |
172 | Ef_shdr shdr(v.data()); | |
173 | if (this->shnum_ == 0) | |
174 | this->shnum_ = shdr.get_sh_size(); | |
175 | if (this->shstrndx_ == SHN_XINDEX) | |
176 | this->shstrndx_ = shdr.get_sh_link(); | |
177 | } | |
178 | } | |
179 | ||
180 | // Return the file offset of the section header of section SHNDX. | |
181 | ||
182 | template<int size, bool big_endian, typename File> | |
183 | off_t | |
184 | Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx) | |
185 | { | |
186 | if (shndx >= this->shnum()) | |
187 | this->file_->error(_("section_header_offset: bad shndx %u >= %u"), | |
188 | shndx, this->shnum()); | |
189 | return this->shoff_ + This::shdr_size * shndx; | |
190 | } | |
191 | ||
192 | // Return the name of section SHNDX. | |
193 | ||
194 | template<int size, bool big_endian, typename File> | |
195 | std::string | |
196 | Elf_file<size, big_endian, File>::section_name(unsigned int shndx) | |
197 | { | |
198 | File* const file = this->file_; | |
199 | ||
200 | // Get the section name offset. | |
201 | unsigned int sh_name; | |
202 | { | |
203 | typename File::View v(file->view(this->section_header_offset(shndx), | |
204 | This::shdr_size)); | |
205 | Ef_shdr shdr(v.data()); | |
206 | sh_name = shdr.get_sh_name(); | |
207 | } | |
208 | ||
209 | // Get the file offset for the section name string table data. | |
210 | off_t shstr_off; | |
211 | off_t shstr_size; | |
212 | { | |
213 | const unsigned int shstrndx = this->shstrndx_; | |
214 | typename File::View v(file->view(this->section_header_offset(shstrndx), | |
215 | This::shdr_size)); | |
216 | Ef_shdr shstr_shdr(v.data()); | |
217 | shstr_off = shstr_shdr.get_sh_offset(); | |
218 | shstr_size = shstr_shdr.get_sh_size(); | |
219 | } | |
220 | ||
221 | if (sh_name >= shstr_size) | |
222 | file->error(_("bad section name offset for section %u: %u"), | |
223 | shndx, sh_name); | |
224 | ||
225 | typename File::View v(file->view(shstr_off, shstr_size)); | |
226 | ||
227 | const unsigned char* datau = v.data(); | |
228 | const char* data = reinterpret_cast<const char*>(datau); | |
229 | const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name); | |
230 | if (p == NULL) | |
231 | file->error(_("missing null terminator for name of section %u"), | |
232 | shndx); | |
233 | ||
234 | size_t len = static_cast<const char*>(p) - (data + sh_name); | |
235 | ||
236 | return std::string(data + sh_name, len); | |
237 | } | |
238 | ||
239 | // Return the contents of section SHNDX. | |
240 | ||
241 | template<int size, bool big_endian, typename File> | |
242 | typename File::Location | |
243 | Elf_file<size, big_endian, File>::section_contents(unsigned int shndx) | |
244 | { | |
245 | File* const file = this->file_; | |
246 | ||
247 | if (shndx >= this->shnum()) | |
248 | file->error(_("section_contents: bad shndx %u >= %u"), | |
249 | shndx, this->shnum()); | |
250 | ||
251 | typename File::View v(file->view(this->section_header_offset(shndx), | |
252 | This::shdr_size)); | |
253 | Ef_shdr shdr(v.data()); | |
254 | return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size()); | |
255 | } | |
256 | ||
a3ad94ed ILT |
257 | // Return the section flags of section SHNDX. |
258 | ||
259 | template<int size, bool big_endian, typename File> | |
260 | typename Elf_types<size>::Elf_WXword | |
261 | Elf_file<size, big_endian, File>::section_flags(unsigned int shndx) | |
262 | { | |
263 | File* const file = this->file_; | |
264 | ||
265 | if (shndx >= this->shnum()) | |
266 | file->error(_("section_flags: bad shndx %u >= %u"), | |
267 | shndx, this->shnum()); | |
268 | ||
269 | typename File::View v(file->view(this->section_header_offset(shndx), | |
270 | This::shdr_size)); | |
271 | ||
272 | Ef_shdr shdr(v.data()); | |
273 | return shdr.get_sh_flags(); | |
274 | } | |
275 | ||
645f8123 ILT |
276 | } // End namespace elfcpp. |
277 | ||
278 | #endif // !defined(ELFCPP_FILE_H) |