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 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 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 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 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 92 ELFHeader::ELFHeader() 93 { 94 memset(this, 0, sizeof(ELFHeader)); 95 } 96 97 ByteOrder 98 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 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 143 ELFHeader::MagicBytesMatch(const uint8_t *magic) 144 { 145 return memcmp(magic, ElfMagic, strlen(ElfMagic)) == 0; 146 } 147 148 unsigned 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 167 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 209 ELFSectionHeader::ELFSectionHeader() 210 { 211 memset(this, 0, sizeof(ELFSectionHeader)); 212 } 213 214 bool 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 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 * 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 * 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 * 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 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 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 378 ELFProgramHeader::ELFProgramHeader() 379 { 380 memset(this, 0, sizeof(ELFProgramHeader)); 381 } 382 383 bool 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 423 ELFDynamic::ELFDynamic() 424 { 425 memset(this, 0, sizeof(ELFDynamic)); 426 } 427 428 bool 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 438 ELFRel::ELFRel() 439 { 440 memset(this, 0, sizeof(ELFRel)); 441 } 442 443 bool 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 458 ELFRela::ELFRela() 459 { 460 memset(this, 0, sizeof(ELFRela)); 461 } 462 463 bool 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