1 //===-- ELFHeader.cpp ----------------------------------------- -*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include <cstring>
11
12 #include "lldb/Core/DataExtractor.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Core/Stream.h"
15
16 #include "ELFHeader.h"
17
18 using namespace elf;
19 using namespace lldb;
20 using namespace llvm::ELF;
21
22 //------------------------------------------------------------------------------
23 // Static utility functions.
24 //
25 // GetMaxU64 and GetMaxS64 wrap the similarly named methods from DataExtractor
26 // with error handling code and provide for parsing a sequence of values.
27 static bool
GetMaxU64(const lldb_private::DataExtractor & data,lldb::offset_t * offset,uint64_t * value,uint32_t byte_size)28 GetMaxU64(const lldb_private::DataExtractor &data,
29 lldb::offset_t *offset,
30 uint64_t *value,
31 uint32_t byte_size)
32 {
33 const lldb::offset_t saved_offset = *offset;
34 *value = data.GetMaxU64(offset, byte_size);
35 return *offset != saved_offset;
36 }
37
38 static bool
GetMaxU64(const lldb_private::DataExtractor & data,lldb::offset_t * offset,uint64_t * value,uint32_t byte_size,uint32_t count)39 GetMaxU64(const lldb_private::DataExtractor &data,
40 lldb::offset_t *offset,
41 uint64_t *value,
42 uint32_t byte_size,
43 uint32_t count)
44 {
45 lldb::offset_t saved_offset = *offset;
46
47 for (uint32_t i = 0; i < count; ++i, ++value)
48 {
49 if (GetMaxU64(data, offset, value, byte_size) == false)
50 {
51 *offset = saved_offset;
52 return false;
53 }
54 }
55 return true;
56 }
57
58 static bool
GetMaxS64(const lldb_private::DataExtractor & data,lldb::offset_t * offset,int64_t * value,uint32_t byte_size)59 GetMaxS64(const lldb_private::DataExtractor &data,
60 lldb::offset_t *offset,
61 int64_t *value,
62 uint32_t byte_size)
63 {
64 const lldb::offset_t saved_offset = *offset;
65 *value = data.GetMaxS64(offset, byte_size);
66 return *offset != saved_offset;
67 }
68
69 static bool
GetMaxS64(const lldb_private::DataExtractor & data,lldb::offset_t * offset,int64_t * value,uint32_t byte_size,uint32_t count)70 GetMaxS64(const lldb_private::DataExtractor &data,
71 lldb::offset_t *offset,
72 int64_t *value,
73 uint32_t byte_size,
74 uint32_t count)
75 {
76 lldb::offset_t saved_offset = *offset;
77
78 for (uint32_t i = 0; i < count; ++i, ++value)
79 {
80 if (GetMaxS64(data, offset, value, byte_size) == false)
81 {
82 *offset = saved_offset;
83 return false;
84 }
85 }
86 return true;
87 }
88
89 //------------------------------------------------------------------------------
90 // ELFHeader
91
ELFHeader()92 ELFHeader::ELFHeader()
93 {
94 memset(this, 0, sizeof(ELFHeader));
95 }
96
97 ByteOrder
GetByteOrder() const98 ELFHeader::GetByteOrder() const
99 {
100 if (e_ident[EI_DATA] == ELFDATA2MSB)
101 return eByteOrderBig;
102 if (e_ident[EI_DATA] == ELFDATA2LSB)
103 return eByteOrderLittle;
104 return eByteOrderInvalid;
105 }
106
107 bool
Parse(lldb_private::DataExtractor & data,lldb::offset_t * offset)108 ELFHeader::Parse(lldb_private::DataExtractor &data, lldb::offset_t *offset)
109 {
110 // Read e_ident. This provides byte order and address size info.
111 if (data.GetU8(offset, &e_ident, EI_NIDENT) == NULL)
112 return false;
113
114 const unsigned byte_size = Is32Bit() ? 4 : 8;
115 data.SetByteOrder(GetByteOrder());
116 data.SetAddressByteSize(byte_size);
117
118 // Read e_type and e_machine.
119 if (data.GetU16(offset, &e_type, 2) == NULL)
120 return false;
121
122 // Read e_version.
123 if (data.GetU32(offset, &e_version, 1) == NULL)
124 return false;
125
126 // Read e_entry, e_phoff and e_shoff.
127 if (GetMaxU64(data, offset, &e_entry, byte_size, 3) == false)
128 return false;
129
130 // Read e_flags.
131 if (data.GetU32(offset, &e_flags, 1) == NULL)
132 return false;
133
134 // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and
135 // e_shstrndx.
136 if (data.GetU16(offset, &e_ehsize, 6) == NULL)
137 return false;
138
139 return true;
140 }
141
142 bool
MagicBytesMatch(const uint8_t * magic)143 ELFHeader::MagicBytesMatch(const uint8_t *magic)
144 {
145 return memcmp(magic, ElfMagic, strlen(ElfMagic)) == 0;
146 }
147
148 unsigned
AddressSizeInBytes(const uint8_t * magic)149 ELFHeader::AddressSizeInBytes(const uint8_t *magic)
150 {
151 unsigned address_size = 0;
152
153 switch (magic[EI_CLASS])
154 {
155 case ELFCLASS32:
156 address_size = 4;
157 break;
158
159 case ELFCLASS64:
160 address_size = 8;
161 break;
162 }
163 return address_size;
164 }
165
166 unsigned
GetRelocationJumpSlotType() const167 ELFHeader::GetRelocationJumpSlotType() const
168 {
169 unsigned slot = 0;
170
171 switch (e_machine)
172 {
173 default:
174 assert(false && "architecture not supported");
175 break;
176 case EM_PPC:
177 slot = R_PPC_JMP_SLOT;
178 break;
179 case EM_PPC64:
180 slot = R_PPC64_JMP_SLOT;
181 break;
182 case EM_386:
183 case EM_IAMCU: // FIXME: is this correct?
184 slot = R_386_JUMP_SLOT;
185 break;
186 case EM_X86_64:
187 slot = R_X86_64_JUMP_SLOT;
188 break;
189 case EM_ARM:
190 slot = R_ARM_JUMP_SLOT;
191 break;
192 case EM_HEXAGON:
193 slot = R_HEX_JMP_SLOT;
194 break;
195 case EM_AARCH64:
196 slot = R_AARCH64_JUMP_SLOT;
197 break;
198 case EM_MIPS:
199 slot = R_MIPS_JUMP_SLOT;
200 break;
201 }
202
203 return slot;
204 }
205
206 //------------------------------------------------------------------------------
207 // ELFSectionHeader
208
ELFSectionHeader()209 ELFSectionHeader::ELFSectionHeader()
210 {
211 memset(this, 0, sizeof(ELFSectionHeader));
212 }
213
214 bool
Parse(const lldb_private::DataExtractor & data,lldb::offset_t * offset)215 ELFSectionHeader::Parse(const lldb_private::DataExtractor &data,
216 lldb::offset_t *offset)
217 {
218 const unsigned byte_size = data.GetAddressByteSize();
219
220 // Read sh_name and sh_type.
221 if (data.GetU32(offset, &sh_name, 2) == NULL)
222 return false;
223
224 // Read sh_flags.
225 if (GetMaxU64(data, offset, &sh_flags, byte_size) == false)
226 return false;
227
228 // Read sh_addr, sh_off and sh_size.
229 if (GetMaxU64(data, offset, &sh_addr, byte_size, 3) == false)
230 return false;
231
232 // Read sh_link and sh_info.
233 if (data.GetU32(offset, &sh_link, 2) == NULL)
234 return false;
235
236 // Read sh_addralign and sh_entsize.
237 if (GetMaxU64(data, offset, &sh_addralign, byte_size, 2) == false)
238 return false;
239
240 return true;
241 }
242
243 //------------------------------------------------------------------------------
244 // ELFSymbol
245
ELFSymbol()246 ELFSymbol::ELFSymbol()
247 {
248 memset(this, 0, sizeof(ELFSymbol));
249 }
250
251 #define ENUM_TO_CSTR(e) case e: return #e
252
253 const char *
bindingToCString(unsigned char binding)254 ELFSymbol::bindingToCString(unsigned char binding)
255 {
256 switch (binding)
257 {
258 ENUM_TO_CSTR(STB_LOCAL);
259 ENUM_TO_CSTR(STB_GLOBAL);
260 ENUM_TO_CSTR(STB_WEAK);
261 ENUM_TO_CSTR(STB_LOOS);
262 ENUM_TO_CSTR(STB_HIOS);
263 ENUM_TO_CSTR(STB_LOPROC);
264 ENUM_TO_CSTR(STB_HIPROC);
265 }
266 return "";
267 }
268
269 const char *
typeToCString(unsigned char type)270 ELFSymbol::typeToCString(unsigned char type)
271 {
272 switch (type)
273 {
274 ENUM_TO_CSTR(STT_NOTYPE);
275 ENUM_TO_CSTR(STT_OBJECT);
276 ENUM_TO_CSTR(STT_FUNC);
277 ENUM_TO_CSTR(STT_SECTION);
278 ENUM_TO_CSTR(STT_FILE);
279 ENUM_TO_CSTR(STT_COMMON);
280 ENUM_TO_CSTR(STT_TLS);
281 ENUM_TO_CSTR(STT_GNU_IFUNC);
282 ENUM_TO_CSTR(STT_HIOS);
283 ENUM_TO_CSTR(STT_LOPROC);
284 ENUM_TO_CSTR(STT_HIPROC);
285 }
286 return "";
287 }
288
289 const char *
sectionIndexToCString(elf_half shndx,const lldb_private::SectionList * section_list)290 ELFSymbol::sectionIndexToCString (elf_half shndx,
291 const lldb_private::SectionList *section_list)
292 {
293 switch (shndx)
294 {
295 ENUM_TO_CSTR(SHN_UNDEF);
296 ENUM_TO_CSTR(SHN_LOPROC);
297 ENUM_TO_CSTR(SHN_HIPROC);
298 ENUM_TO_CSTR(SHN_LOOS);
299 ENUM_TO_CSTR(SHN_HIOS);
300 ENUM_TO_CSTR(SHN_ABS);
301 ENUM_TO_CSTR(SHN_COMMON);
302 ENUM_TO_CSTR(SHN_XINDEX);
303 default:
304 {
305 const lldb_private::Section *section = section_list->GetSectionAtIndex(shndx).get();
306 if (section)
307 return section->GetName().AsCString("");
308 }
309 break;
310 }
311 return "";
312 }
313
314 void
Dump(lldb_private::Stream * s,uint32_t idx,const lldb_private::DataExtractor * strtab_data,const lldb_private::SectionList * section_list)315 ELFSymbol::Dump (lldb_private::Stream *s,
316 uint32_t idx,
317 const lldb_private::DataExtractor *strtab_data,
318 const lldb_private::SectionList *section_list)
319 {
320 s->Printf("[%3u] 0x%16.16" PRIx64 " 0x%16.16" PRIx64 " 0x%8.8x 0x%2.2x (%-10s %-13s) 0x%2.2x 0x%4.4x (%-10s) %s\n",
321 idx,
322 st_value,
323 st_size,
324 st_name,
325 st_info,
326 bindingToCString (getBinding()),
327 typeToCString (getType()),
328 st_other,
329 st_shndx,
330 sectionIndexToCString (st_shndx, section_list),
331 strtab_data ? strtab_data->PeekCStr(st_name) : "");
332 }
333
334 bool
Parse(const lldb_private::DataExtractor & data,lldb::offset_t * offset)335 ELFSymbol::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
336 {
337 const unsigned byte_size = data.GetAddressByteSize();
338 const bool parsing_32 = byte_size == 4;
339
340 // Read st_name.
341 if (data.GetU32(offset, &st_name, 1) == NULL)
342 return false;
343
344 if (parsing_32)
345 {
346 // Read st_value and st_size.
347 if (GetMaxU64(data, offset, &st_value, byte_size, 2) == false)
348 return false;
349
350 // Read st_info and st_other.
351 if (data.GetU8(offset, &st_info, 2) == NULL)
352 return false;
353
354 // Read st_shndx.
355 if (data.GetU16(offset, &st_shndx, 1) == NULL)
356 return false;
357 }
358 else
359 {
360 // Read st_info and st_other.
361 if (data.GetU8(offset, &st_info, 2) == NULL)
362 return false;
363
364 // Read st_shndx.
365 if (data.GetU16(offset, &st_shndx, 1) == NULL)
366 return false;
367
368 // Read st_value and st_size.
369 if (data.GetU64(offset, &st_value, 2) == NULL)
370 return false;
371 }
372 return true;
373 }
374
375 //------------------------------------------------------------------------------
376 // ELFProgramHeader
377
ELFProgramHeader()378 ELFProgramHeader::ELFProgramHeader()
379 {
380 memset(this, 0, sizeof(ELFProgramHeader));
381 }
382
383 bool
Parse(const lldb_private::DataExtractor & data,lldb::offset_t * offset)384 ELFProgramHeader::Parse(const lldb_private::DataExtractor &data,
385 lldb::offset_t *offset)
386 {
387 const uint32_t byte_size = data.GetAddressByteSize();
388 const bool parsing_32 = byte_size == 4;
389
390 // Read p_type;
391 if (data.GetU32(offset, &p_type, 1) == NULL)
392 return false;
393
394 if (parsing_32) {
395 // Read p_offset, p_vaddr, p_paddr, p_filesz and p_memsz.
396 if (GetMaxU64(data, offset, &p_offset, byte_size, 5) == false)
397 return false;
398
399 // Read p_flags.
400 if (data.GetU32(offset, &p_flags, 1) == NULL)
401 return false;
402
403 // Read p_align.
404 if (GetMaxU64(data, offset, &p_align, byte_size) == false)
405 return false;
406 }
407 else {
408 // Read p_flags.
409 if (data.GetU32(offset, &p_flags, 1) == NULL)
410 return false;
411
412 // Read p_offset, p_vaddr, p_paddr, p_filesz, p_memsz and p_align.
413 if (GetMaxU64(data, offset, &p_offset, byte_size, 6) == false)
414 return false;
415 }
416
417 return true;
418 }
419
420 //------------------------------------------------------------------------------
421 // ELFDynamic
422
ELFDynamic()423 ELFDynamic::ELFDynamic()
424 {
425 memset(this, 0, sizeof(ELFDynamic));
426 }
427
428 bool
Parse(const lldb_private::DataExtractor & data,lldb::offset_t * offset)429 ELFDynamic::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
430 {
431 const unsigned byte_size = data.GetAddressByteSize();
432 return GetMaxS64(data, offset, &d_tag, byte_size, 2);
433 }
434
435 //------------------------------------------------------------------------------
436 // ELFRel
437
ELFRel()438 ELFRel::ELFRel()
439 {
440 memset(this, 0, sizeof(ELFRel));
441 }
442
443 bool
Parse(const lldb_private::DataExtractor & data,lldb::offset_t * offset)444 ELFRel::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
445 {
446 const unsigned byte_size = data.GetAddressByteSize();
447
448 // Read r_offset and r_info.
449 if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false)
450 return false;
451
452 return true;
453 }
454
455 //------------------------------------------------------------------------------
456 // ELFRela
457
ELFRela()458 ELFRela::ELFRela()
459 {
460 memset(this, 0, sizeof(ELFRela));
461 }
462
463 bool
Parse(const lldb_private::DataExtractor & data,lldb::offset_t * offset)464 ELFRela::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
465 {
466 const unsigned byte_size = data.GetAddressByteSize();
467
468 // Read r_offset and r_info.
469 if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false)
470 return false;
471
472 // Read r_addend;
473 if (GetMaxS64(data, offset, &r_addend, byte_size) == false)
474 return false;
475
476 return true;
477 }
478
479
480