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_386: 177 case EM_486: 178 slot = R_386_JUMP_SLOT; 179 break; 180 case EM_X86_64: 181 slot = R_X86_64_JUMP_SLOT; 182 break; 183 case EM_ARM: 184 slot = R_ARM_JUMP_SLOT; 185 break; 186 case EM_MBLAZE: 187 slot = R_MICROBLAZE_JUMP_SLOT; 188 } 189 190 return slot; 191 } 192 193 //------------------------------------------------------------------------------ 194 // ELFSectionHeader 195 196 ELFSectionHeader::ELFSectionHeader() 197 { 198 memset(this, 0, sizeof(ELFSectionHeader)); 199 } 200 201 bool 202 ELFSectionHeader::Parse(const lldb_private::DataExtractor &data, 203 lldb::offset_t *offset) 204 { 205 const unsigned byte_size = data.GetAddressByteSize(); 206 207 // Read sh_name and sh_type. 208 if (data.GetU32(offset, &sh_name, 2) == NULL) 209 return false; 210 211 // Read sh_flags. 212 if (GetMaxU64(data, offset, &sh_flags, byte_size) == false) 213 return false; 214 215 // Read sh_addr, sh_off and sh_size. 216 if (GetMaxU64(data, offset, &sh_addr, byte_size, 3) == false) 217 return false; 218 219 // Read sh_link and sh_info. 220 if (data.GetU32(offset, &sh_link, 2) == NULL) 221 return false; 222 223 // Read sh_addralign and sh_entsize. 224 if (GetMaxU64(data, offset, &sh_addralign, byte_size, 2) == false) 225 return false; 226 227 return true; 228 } 229 230 //------------------------------------------------------------------------------ 231 // ELFSymbol 232 233 ELFSymbol::ELFSymbol() 234 { 235 memset(this, 0, sizeof(ELFSymbol)); 236 } 237 238 #define ENUM_TO_CSTR(e) case e: return #e 239 240 const char * 241 ELFSymbol::bindingToCString(unsigned char binding) 242 { 243 switch (binding) 244 { 245 ENUM_TO_CSTR(STB_LOCAL); 246 ENUM_TO_CSTR(STB_GLOBAL); 247 ENUM_TO_CSTR(STB_WEAK); 248 ENUM_TO_CSTR(STB_LOOS); 249 ENUM_TO_CSTR(STB_HIOS); 250 ENUM_TO_CSTR(STB_LOPROC); 251 ENUM_TO_CSTR(STB_HIPROC); 252 } 253 return ""; 254 } 255 256 const char * 257 ELFSymbol::typeToCString(unsigned char type) 258 { 259 switch (type) 260 { 261 ENUM_TO_CSTR(STT_NOTYPE); 262 ENUM_TO_CSTR(STT_OBJECT); 263 ENUM_TO_CSTR(STT_FUNC); 264 ENUM_TO_CSTR(STT_SECTION); 265 ENUM_TO_CSTR(STT_FILE); 266 ENUM_TO_CSTR(STT_COMMON); 267 ENUM_TO_CSTR(STT_TLS); 268 ENUM_TO_CSTR(STT_LOOS); 269 ENUM_TO_CSTR(STT_HIOS); 270 ENUM_TO_CSTR(STT_GNU_IFUNC); 271 ENUM_TO_CSTR(STT_LOPROC); 272 ENUM_TO_CSTR(STT_HIPROC); 273 } 274 return ""; 275 } 276 277 const char * 278 ELFSymbol::sectionIndexToCString (elf_half shndx, 279 const lldb_private::SectionList *section_list) 280 { 281 switch (shndx) 282 { 283 ENUM_TO_CSTR(SHN_UNDEF); 284 ENUM_TO_CSTR(SHN_LOPROC); 285 ENUM_TO_CSTR(SHN_HIPROC); 286 ENUM_TO_CSTR(SHN_LOOS); 287 ENUM_TO_CSTR(SHN_HIOS); 288 ENUM_TO_CSTR(SHN_ABS); 289 ENUM_TO_CSTR(SHN_COMMON); 290 ENUM_TO_CSTR(SHN_XINDEX); 291 default: 292 { 293 const lldb_private::Section *section = section_list->GetSectionAtIndex(shndx).get(); 294 if (section) 295 return section->GetName().AsCString(""); 296 } 297 break; 298 } 299 return ""; 300 } 301 302 void 303 ELFSymbol::Dump (lldb_private::Stream *s, 304 uint32_t idx, 305 const lldb_private::DataExtractor *strtab_data, 306 const lldb_private::SectionList *section_list) 307 { 308 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", 309 idx, 310 st_value, 311 st_size, 312 st_name, 313 st_info, 314 bindingToCString (getBinding()), 315 typeToCString (getType()), 316 st_other, 317 st_shndx, 318 sectionIndexToCString (st_shndx, section_list), 319 strtab_data ? strtab_data->PeekCStr(st_name) : ""); 320 } 321 322 bool 323 ELFSymbol::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 324 { 325 const unsigned byte_size = data.GetAddressByteSize(); 326 const bool parsing_32 = byte_size == 4; 327 328 // Read st_name. 329 if (data.GetU32(offset, &st_name, 1) == NULL) 330 return false; 331 332 if (parsing_32) 333 { 334 // Read st_value and st_size. 335 if (GetMaxU64(data, offset, &st_value, byte_size, 2) == false) 336 return false; 337 338 // Read st_info and st_other. 339 if (data.GetU8(offset, &st_info, 2) == NULL) 340 return false; 341 342 // Read st_shndx. 343 if (data.GetU16(offset, &st_shndx, 1) == NULL) 344 return false; 345 } 346 else 347 { 348 // Read st_info and st_other. 349 if (data.GetU8(offset, &st_info, 2) == NULL) 350 return false; 351 352 // Read st_shndx. 353 if (data.GetU16(offset, &st_shndx, 1) == NULL) 354 return false; 355 356 // Read st_value and st_size. 357 if (data.GetU64(offset, &st_value, 2) == NULL) 358 return false; 359 } 360 return true; 361 } 362 363 //------------------------------------------------------------------------------ 364 // ELFProgramHeader 365 366 ELFProgramHeader::ELFProgramHeader() 367 { 368 memset(this, 0, sizeof(ELFProgramHeader)); 369 } 370 371 bool 372 ELFProgramHeader::Parse(const lldb_private::DataExtractor &data, 373 lldb::offset_t *offset) 374 { 375 const uint32_t byte_size = data.GetAddressByteSize(); 376 const bool parsing_32 = byte_size == 4; 377 378 // Read p_type; 379 if (data.GetU32(offset, &p_type, 1) == NULL) 380 return false; 381 382 if (parsing_32) { 383 // Read p_offset, p_vaddr, p_paddr, p_filesz and p_memsz. 384 if (GetMaxU64(data, offset, &p_offset, byte_size, 5) == false) 385 return false; 386 387 // Read p_flags. 388 if (data.GetU32(offset, &p_flags, 1) == NULL) 389 return false; 390 391 // Read p_align. 392 if (GetMaxU64(data, offset, &p_align, byte_size) == false) 393 return false; 394 } 395 else { 396 // Read p_flags. 397 if (data.GetU32(offset, &p_flags, 1) == NULL) 398 return false; 399 400 // Read p_offset, p_vaddr, p_paddr, p_filesz, p_memsz and p_align. 401 if (GetMaxU64(data, offset, &p_offset, byte_size, 6) == false) 402 return false; 403 } 404 405 return true; 406 } 407 408 //------------------------------------------------------------------------------ 409 // ELFDynamic 410 411 ELFDynamic::ELFDynamic() 412 { 413 memset(this, 0, sizeof(ELFDynamic)); 414 } 415 416 bool 417 ELFDynamic::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 418 { 419 const unsigned byte_size = data.GetAddressByteSize(); 420 return GetMaxS64(data, offset, &d_tag, byte_size, 2); 421 } 422 423 //------------------------------------------------------------------------------ 424 // ELFRel 425 426 ELFRel::ELFRel() 427 { 428 memset(this, 0, sizeof(ELFRel)); 429 } 430 431 bool 432 ELFRel::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 433 { 434 const unsigned byte_size = data.GetAddressByteSize(); 435 436 // Read r_offset and r_info. 437 if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false) 438 return false; 439 440 return true; 441 } 442 443 //------------------------------------------------------------------------------ 444 // ELFRela 445 446 ELFRela::ELFRela() 447 { 448 memset(this, 0, sizeof(ELFRela)); 449 } 450 451 bool 452 ELFRela::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) 453 { 454 const unsigned byte_size = data.GetAddressByteSize(); 455 456 // Read r_offset and r_info. 457 if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false) 458 return false; 459 460 // Read r_addend; 461 if (GetMaxS64(data, offset, &r_addend, byte_size) == false) 462 return false; 463 464 return true; 465 } 466 467 468