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