( GetModule(), this, SegmentID(EnumPHdr.index()), ConstString(provider.GetNextSegmentName()), eSectionTypeContainer, InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset, PHdr.p_filesz, Log2Align, /*flags*/ 0); Segment->SetPermissions(GetPermissions(PHdr)); Segment->SetIsThreadSpecific(PHdr.p_type == PT_TLS); m_sections_up->AddSection(Segment); provider.AddSegment(*InfoOr, std::move(Segment)); } ParseSectionHeaders(); if (m_section_headers.empty()) return; for (SectionHeaderCollIter I = std::next(m_section_headers.begin()); I != m_section_headers.end(); ++I) { const ELFSectionHeaderInfo &header = *I; ConstString &name = I->section_name; const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; VMAddressProvider &provider = header.sh_flags & SHF_TLS ? tls_provider : regular_provider; auto InfoOr = provider.GetAddressInfo(header); if (!InfoOr) continue; SectionType sect_type = GetSectionType(header); const uint32_t target_bytes_size = GetTargetByteSize(sect_type, m_arch_spec); elf::elf_xword log2align = (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign); SectionSP section_sp(new Section( InfoOr->Segment, GetModule(), // Module to which this section belongs. this, // ObjectFile to which this section belongs and should // read section data from. SectionIndex(I), // Section ID. name, // Section name. sect_type, // Section type. InfoOr->Range.GetRangeBase(), // VM address. InfoOr->Range.GetByteSize(), // VM size in bytes of this section. header.sh_offset, // Offset of this section in the file. file_size, // Size of the section as found in the file. log2align, // Alignment of the section header.sh_flags, // Flags for this section. target_bytes_size)); // Number of host bytes per target byte section_sp->SetPermissions(GetPermissions(header)); section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS); (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up) .AddSection(section_sp); provider.AddSection(std::move(*InfoOr), std::move(section_sp)); } // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the // unified section list. if (GetType() != eTypeDebugInfo) unified_section_list = *m_sections_up; // If there's a .gnu_debugdata section, we'll try to read the .symtab that's // embedded in there and replace the one in the original object file (if any). // If there's none in the orignal object file, we add it to it. if (auto gdd_obj_file = GetGnuDebugDataObjectFile()) { if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) { if (SectionSP symtab_section_sp = gdd_objfile_section_list->FindSectionByType( eSectionTypeELFSymbolTable, true)) { SectionSP module_section_sp = unified_section_list.FindSectionByType( eSectionTypeELFSymbolTable, true); if (module_section_sp) unified_section_list.ReplaceSection(module_section_sp->GetID(), symtab_section_sp); else unified_section_list.AddSection(symtab_section_sp); } } } } std::shared_ptr ObjectFileELF::GetGnuDebugDataObjectFile() { if (m_gnu_debug_data_object_file != nullptr) return m_gnu_debug_data_object_file; SectionSP section = GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata")); if (!section) return nullptr; if (!lldb_private::lzma::isAvailable()) { GetModule()->ReportWarning( "No LZMA support found for reading .gnu_debugdata section"); return nullptr; } // Uncompress the data DataExtractor data; section->GetSectionData(data); llvm::SmallVector uncompressedData; auto err = lldb_private::lzma::uncompress(data.GetData(), uncompressedData); if (err) { GetModule()->ReportWarning( "An error occurred while decompression the section {0}: {1}", section->GetName().AsCString(), llvm::toString(std::move(err)).c_str()); return nullptr; } // Construct ObjectFileELF object from decompressed buffer DataBufferSP gdd_data_buf( new DataBufferHeap(uncompressedData.data(), uncompressedData.size())); auto fspec = GetFileSpec().CopyByAppendingPathComponent( llvm::StringRef("gnu_debugdata")); m_gnu_debug_data_object_file.reset(new ObjectFileELF( GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize())); // This line is essential; otherwise a breakpoint can be set but not hit. m_gnu_debug_data_object_file->SetType(ObjectFile::eTypeDebugInfo); ArchSpec spec = m_gnu_debug_data_object_file->GetArchitecture(); if (spec && m_gnu_debug_data_object_file->SetModulesArchitecture(spec)) return m_gnu_debug_data_object_file; return nullptr; } // Find the arm/aarch64 mapping symbol character in the given symbol name. // Mapping symbols have the form of "$[.]*". Additionally we // recognize cases when the mapping symbol prefixed by an arbitrary string // because if a symbol prefix added to each symbol in the object file with // objcopy then the mapping symbols are also prefixed. static char FindArmAarch64MappingSymbol(const char *symbol_name) { if (!symbol_name) return '\0'; const char *dollar_pos = ::strchr(symbol_name, '$'); if (!dollar_pos || dollar_pos[1] == '\0') return '\0'; if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') return dollar_pos[1]; return '\0'; } #define STO_MIPS_ISA (3 << 6) #define STO_MICROMIPS (2 << 6) #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS) // private std::pair ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id, SectionList *section_list, const size_t num_symbols, const DataExtractor &symtab_data, const DataExtractor &strtab_data) { ELFSymbol symbol; lldb::offset_t offset = 0; // The changes these symbols would make to the class map. We will also update // m_address_class_map but need to tell the caller what changed because the // caller may be another object file. FileAddressToAddressClassMap address_class_map; static ConstString text_section_name(".text"); static ConstString init_section_name(".init"); static ConstString fini_section_name(".fini"); static ConstString ctors_section_name(".ctors"); static ConstString dtors_section_name(".dtors"); static ConstString data_section_name(".data"); static ConstString rodata_section_name(".rodata"); static ConstString rodata1_section_name(".rodata1"); static ConstString data2_section_name(".data1"); static ConstString bss_section_name(".bss"); static ConstString opd_section_name(".opd"); // For ppc64 // On Android the oatdata and the oatexec symbols in the oat and odex files // covers the full .text section what causes issues with displaying unusable // symbol name to the user and very slow unwinding speed because the // instruction emulation based unwind plans try to emulate all instructions // in these symbols. Don't add these symbols to the symbol list as they have // no use for the debugger and they are causing a lot of trouble. Filtering // can't be restricted to Android because this special object file don't // contain the note section specifying the environment to Android but the // custom extension and file name makes it highly unlikely that this will // collide with anything else. llvm::StringRef file_extension = m_file.GetFileNameExtension(); bool skip_oatdata_oatexec = file_extension == ".oat" || file_extension == ".odex"; ArchSpec arch = GetArchitecture(); ModuleSP module_sp(GetModule()); SectionList *module_section_list = module_sp ? module_sp->GetSectionList() : nullptr; // We might have debug information in a separate object, in which case // we need to map the sections from that object to the sections in the // main object during symbol lookup. If we had to compare the sections // for every single symbol, that would be expensive, so this map is // used to accelerate the process. std::unordered_map section_map; unsigned i; for (i = 0; i < num_symbols; ++i) { if (!symbol.Parse(symtab_data, &offset)) break; const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); if (!symbol_name) symbol_name = ""; // No need to add non-section symbols that have no names if (symbol.getType() != STT_SECTION && (symbol_name == nullptr || symbol_name[0] == '\0')) continue; // Skipping oatdata and oatexec sections if it is requested. See details // above the definition of skip_oatdata_oatexec for the reasons. if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || ::strcmp(symbol_name, "oatexec") == 0)) continue; SectionSP symbol_section_sp; SymbolType symbol_type = eSymbolTypeInvalid; Elf64_Half shndx = symbol.st_shndx; switch (shndx) { case SHN_ABS: symbol_type = eSymbolTypeAbsolute; break; case SHN_UNDEF: symbol_type = eSymbolTypeUndefined; break; default: symbol_section_sp = section_list->FindSectionByID(shndx); break; } // If a symbol is undefined do not process it further even if it has a STT // type if (symbol_type != eSymbolTypeUndefined) { switch (symbol.getType()) { default: case STT_NOTYPE: // The symbol's type is not specified. break; case STT_OBJECT: // The symbol is associated with a data object, such as a variable, an // array, etc. symbol_type = eSymbolTypeData; break; case STT_FUNC: // The symbol is associated with a function or other executable code. symbol_type = eSymbolTypeCode; break; case STT_SECTION: // The symbol is associated with a section. Symbol table entries of // this type exist primarily for relocation and normally have STB_LOCAL // binding. break; case STT_FILE: // Conventionally, the symbol's name gives the name of the source file // associated with the object file. A file symbol has STB_LOCAL // binding, its section index is SHN_ABS, and it precedes the other // STB_LOCAL symbols for the file, if it is present. symbol_type = eSymbolTypeSourceFile; break; case STT_GNU_IFUNC: // The symbol is associated with an indirect function. The actual // function will be resolved if it is referenced. symbol_type = eSymbolTypeResolver; break; } } if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) { if (symbol_section_sp) { ConstString sect_name = symbol_section_sp->GetName(); if (sect_name == text_section_name || sect_name == init_section_name || sect_name == fini_section_name || sect_name == ctors_section_name || sect_name == dtors_section_name) { symbol_type = eSymbolTypeCode; } else if (sect_name == data_section_name || sect_name == data2_section_name || sect_name == rodata_section_name || sect_name == rodata1_section_name || sect_name == bss_section_name) { symbol_type = eSymbolTypeData; } } } int64_t symbol_value_offset = 0; uint32_t additional_flags = 0; if (arch.IsValid()) { if (arch.GetMachine() == llvm::Triple::arm) { if (symbol.getBinding() == STB_LOCAL) { char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); if (symbol_type == eSymbolTypeCode) { switch (mapping_symbol) { case 'a': // $a[.]* - marks an ARM instruction sequence address_class_map[symbol.st_value] = AddressClass::eCode; break; case 'b': case 't': // $b[.]* - marks a THUMB BL instruction sequence // $t[.]* - marks a THUMB instruction sequence address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; break; case 'd': // $d[.]* - marks a data item sequence (e.g. lit pool) address_class_map[symbol.st_value] = AddressClass::eData; break; } } if (mapping_symbol) continue; } } else if (arch.GetMachine() == llvm::Triple::aarch64) { if (symbol.getBinding() == STB_LOCAL) { char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); if (symbol_type == eSymbolTypeCode) { switch (mapping_symbol) { case 'x': // $x[.]* - marks an A64 instruction sequence address_class_map[symbol.st_value] = AddressClass::eCode; break; case 'd': // $d[.]* - marks a data item sequence (e.g. lit pool) address_class_map[symbol.st_value] = AddressClass::eData; break; } } if (mapping_symbol) continue; } } if (arch.GetMachine() == llvm::Triple::arm) { if (symbol_type == eSymbolTypeCode) { if (symbol.st_value & 1) { // Subtracting 1 from the address effectively unsets the low order // bit, which results in the address actually pointing to the // beginning of the symbol. This delta will be used below in // conjunction with symbol.st_value to produce the final // symbol_value that we store in the symtab. symbol_value_offset = -1; address_class_map[symbol.st_value ^ 1] = AddressClass::eCodeAlternateISA; } else { // This address is ARM address_class_map[symbol.st_value] = AddressClass::eCode; } } } /* * MIPS: * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for * MIPS). * This allows processor to switch between microMIPS and MIPS without any * need * for special mode-control register. However, apart from .debug_line, * none of * the ELF/DWARF sections set the ISA bit (for symbol or section). Use * st_other * flag to check whether the symbol is microMIPS and then set the address * class * accordingly. */ if (arch.IsMIPS()) { if (IS_MICROMIPS(symbol.st_other)) address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) { symbol.st_value = symbol.st_value & (~1ull); address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; } else { if (symbol_type == eSymbolTypeCode) address_class_map[symbol.st_value] = AddressClass::eCode; else if (symbol_type == eSymbolTypeData) address_class_map[symbol.st_value] = AddressClass::eData; else address_class_map[symbol.st_value] = AddressClass::eUnknown; } } } // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB // symbols. See above for more details. uint64_t symbol_value = symbol.st_value + symbol_value_offset; if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) symbol_value -= symbol_section_sp->GetFileAddress(); if (symbol_section_sp && module_section_list && module_section_list != section_list) { auto section_it = section_map.find(symbol_section_sp); if (section_it == section_map.end()) { section_it = section_map .emplace(symbol_section_sp, FindMatchingSection(*module_section_list, symbol_section_sp)) .first; } if (section_it->second) symbol_section_sp = section_it->second; } bool is_global = symbol.getBinding() == STB_GLOBAL; uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; llvm::StringRef symbol_ref(symbol_name); // Symbol names may contain @VERSION suffixes. Find those and strip them // temporarily. size_t version_pos = symbol_ref.find('@'); bool has_suffix = version_pos != llvm::StringRef::npos; llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); Mangled mangled(symbol_bare); // Now append the suffix back to mangled and unmangled names. Only do it if // the demangling was successful (string is not empty). if (has_suffix) { llvm::StringRef suffix = symbol_ref.substr(version_pos); llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); if (!mangled_name.empty()) mangled.SetMangledName(ConstString((mangled_name + suffix).str())); ConstString demangled = mangled.GetDemangledName(); llvm::StringRef demangled_name = demangled.GetStringRef(); if (!demangled_name.empty()) mangled.SetDemangledName(ConstString((demangled_name + suffix).str())); } // In ELF all symbol should have a valid size but it is not true for some // function symbols coming from hand written assembly. As none of the // function symbol should have 0 size we try to calculate the size for // these symbols in the symtab with saying that their original size is not // valid. bool symbol_size_valid = symbol.st_size != 0 || symbol.getType() != STT_FUNC; bool is_trampoline = false; if (arch.IsValid() && (arch.GetMachine() == llvm::Triple::aarch64)) { // On AArch64, trampolines are registered as code. // If we detect a trampoline (which starts with __AArch64ADRPThunk_ or // __AArch64AbsLongThunk_) we register the symbol as a trampoline. This // way we will be able to detect the trampoline when we step in a function // and step through the trampoline. if (symbol_type == eSymbolTypeCode) { llvm::StringRef trampoline_name = mangled.GetName().GetStringRef(); if (trampoline_name.starts_with("__AArch64ADRPThunk_") || trampoline_name.starts_with("__AArch64AbsLongThunk_")) { symbol_type = eSymbolTypeTrampoline; is_trampoline = true; } } } Symbol dc_symbol( i + start_id, // ID is the original symbol table index. mangled, symbol_type, // Type of this symbol is_global, // Is this globally visible? false, // Is this symbol debug info? is_trampoline, // Is this symbol a trampoline? false, // Is this symbol artificial? AddressRange(symbol_section_sp, // Section in which this symbol is // defined or null. symbol_value, // Offset in section or symbol value. symbol.st_size), // Size in bytes of this symbol. symbol_size_valid, // Symbol size is valid has_suffix, // Contains linker annotations? flags); // Symbol flags. if (symbol.getBinding() == STB_WEAK) dc_symbol.SetIsWeak(true); symtab->AddSymbol(dc_symbol); } m_address_class_map.merge(address_class_map); return {i, address_class_map}; } std::pair ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) { if (symtab->GetObjectFile() != this) { // If the symbol table section is owned by a different object file, have it // do the parsing. ObjectFileELF *obj_file_elf = static_cast(symtab->GetObjectFile()); auto [num_symbols, address_class_map] = obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab); // The other object file returned the changes it made to its address // class map, make the same changes to ours. m_address_class_map.merge(address_class_map); return {num_symbols, address_class_map}; } // Get section list for this object file. SectionList *section_list = m_sections_up.get(); if (!section_list) return {}; user_id_t symtab_id = symtab->GetID(); const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); assert(symtab_hdr->sh_type == SHT_SYMTAB || symtab_hdr->sh_type == SHT_DYNSYM); // sh_link: section header index of associated string table. user_id_t strtab_id = symtab_hdr->sh_link; Section *strtab = section_list->FindSectionByID(strtab_id).get(); if (symtab && strtab) { assert(symtab->GetObjectFile() == this); assert(strtab->GetObjectFile() == this); DataExtractor symtab_data; DataExtractor strtab_data; if (ReadSectionData(symtab, symtab_data) && ReadSectionData(strtab, strtab_data)) { size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; return ParseSymbols(symbol_table, start_id, section_list, num_symbols, symtab_data, strtab_data); } } return {0, {}}; } size_t ObjectFileELF::ParseDynamicSymbols() { if (m_dynamic_symbols.size()) return m_dynamic_symbols.size(); SectionList *section_list = GetSectionList(); if (!section_list) return 0; // Find the SHT_DYNAMIC section. Section *dynsym = section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true) .get(); if (!dynsym) return 0; assert(dynsym->GetObjectFile() == this); ELFDynamic symbol; DataExtractor dynsym_data; if (ReadSectionData(dynsym, dynsym_data)) { const lldb::offset_t section_size = dynsym_data.GetByteSize(); lldb::offset_t cursor = 0; while (cursor < section_size) { if (!symbol.Parse(dynsym_data, &cursor)) break; m_dynamic_symbols.push_back(symbol); } } return m_dynamic_symbols.size(); } const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) { if (!ParseDynamicSymbols()) return nullptr; DynamicSymbolCollIter I = m_dynamic_symbols.begin(); DynamicSymbolCollIter E = m_dynamic_symbols.end(); for (; I != E; ++I) { ELFDynamic *symbol = &*I; if (symbol->d_tag == tag) return symbol; } return nullptr; } unsigned ObjectFileELF::PLTRelocationType() { // DT_PLTREL // This member specifies the type of relocation entry to which the // procedure linkage table refers. The d_val member holds DT_REL or // DT_RELA, as appropriate. All relocations in a procedure linkage table // must use the same relocation. const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); if (symbol) return symbol->d_val; return 0; } // Returns the size of the normal plt entries and the offset of the first // normal plt entry. The 0th entry in the plt table is usually a resolution // entry which have different size in some architectures then the rest of the // plt entries. static std::pair GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr, const ELFSectionHeader *plt_hdr) { const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are // 16 bytes. So round the entsize up by the alignment if addralign is set. elf_xword plt_entsize = plt_hdr->sh_addralign ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly. // PLT entries relocation code in general requires multiple instruction and // should be greater than 4 bytes in most cases. Try to guess correct size // just in case. if (plt_entsize <= 4) { // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the // size of the plt entries based on the number of entries and the size of // the plt section with the assumption that the size of the 0th entry is at // least as big as the size of the normal entries and it isn't much bigger // then that. if (plt_hdr->sh_addralign) plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / (num_relocations + 1) * plt_hdr->sh_addralign; else plt_entsize = plt_hdr->sh_size / (num_relocations + 1); } elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; return std::make_pair(plt_entsize, plt_offset); } static unsigned ParsePLTRelocations( Symtab *symbol_table, user_id_t start_id, unsigned rel_type, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr, const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data, DataExtractor &symtab_data, DataExtractor &strtab_data) { ELFRelocation rel(rel_type); ELFSymbol symbol; lldb::offset_t offset = 0; uint64_t plt_offset, plt_entsize; std::tie(plt_entsize, plt_offset) = GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); reloc_info_fn reloc_type; reloc_info_fn reloc_symbol; if (hdr->Is32Bit()) { reloc_type = ELFRelocation::RelocType32; reloc_symbol = ELFRelocation::RelocSymbol32; } else { reloc_type = ELFRelocation::RelocType64; reloc_symbol = ELFRelocation::RelocSymbol64; } unsigned slot_type = hdr->GetRelocationJumpSlotType(); unsigned i; for (i = 0; i < num_relocations; ++i) { if (!rel.Parse(rel_data, &offset)) break; if (reloc_type(rel) != slot_type) continue; lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; if (!symbol.Parse(symtab_data, &symbol_offset)) break; const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); uint64_t plt_index = plt_offset + i * plt_entsize; Symbol jump_symbol( i + start_id, // Symbol table index symbol_name, // symbol name. eSymbolTypeTrampoline, // Type of this symbol false, // Is this globally visible? false, // Is this symbol debug info? true, // Is this symbol a trampoline? true, // Is this symbol artificial? plt_section_sp, // Section in which this symbol is defined or null. plt_index, // Offset in section or symbol value. plt_entsize, // Size in bytes of this symbol. true, // Size is valid false, // Contains linker annotations? 0); // Symbol flags. symbol_table->AddSymbol(jump_symbol); } return i; } unsigned ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id, const ELFSectionHeaderInfo *rel_hdr, user_id_t rel_id) { assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); // The link field points to the associated symbol table. user_id_t symtab_id = rel_hdr->sh_link; // If the link field doesn't point to the appropriate symbol name table then // try to find it by name as some compiler don't fill in the link fields. if (!symtab_id) symtab_id = GetSectionIndexByName(".dynsym"); // Get PLT section. We cannot use rel_hdr->sh_info, since current linkers // point that to the .got.plt or .got section instead of .plt. user_id_t plt_id = GetSectionIndexByName(".plt"); if (!symtab_id || !plt_id) return 0; const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); if (!plt_hdr) return 0; const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); if (!sym_hdr) return 0; SectionList *section_list = m_sections_up.get(); if (!section_list) return 0; Section *rel_section = section_list->FindSectionByID(rel_id).get(); if (!rel_section) return 0; SectionSP plt_section_sp(section_list->FindSectionByID(plt_id)); if (!plt_section_sp) return 0; Section *symtab = section_list->FindSectionByID(symtab_id).get(); if (!symtab) return 0; // sh_link points to associated string table. Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link).get(); if (!strtab) return 0; DataExtractor rel_data; if (!ReadSectionData(rel_section, rel_data)) return 0; DataExtractor symtab_data; if (!ReadSectionData(symtab, symtab_data)) return 0; DataExtractor strtab_data; if (!ReadSectionData(strtab, strtab_data)) return 0; unsigned rel_type = PLTRelocationType(); if (!rel_type) return 0; return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header, rel_hdr, plt_hdr, sym_hdr, plt_section_sp, rel_data, symtab_data, strtab_data); } static void ApplyELF64ABS64Relocation(Symtab *symtab, ELFRelocation &rel, DataExtractor &debug_data, Section *rel_section) { Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol64(rel)); if (symbol) { addr_t value = symbol->GetAddressRef().GetFileAddress(); DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); // ObjectFileELF creates a WritableDataBuffer in CreateInstance. WritableDataBuffer *data_buffer = llvm::cast(data_buffer_sp.get()); uint64_t *dst = reinterpret_cast( data_buffer->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel); memcpy(dst, &val_offset, sizeof(uint64_t)); } } static void ApplyELF64ABS32Relocation(Symtab *symtab, ELFRelocation &rel, DataExtractor &debug_data, Section *rel_section, bool is_signed) { Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol64(rel)); if (symbol) { addr_t value = symbol->GetAddressRef().GetFileAddress(); value += ELFRelocation::RelocAddend32(rel); if ((!is_signed && (value > UINT32_MAX)) || (is_signed && ((int64_t)value > INT32_MAX || (int64_t)value < INT32_MIN))) { Log *log = GetLog(LLDBLog::Modules); LLDB_LOGF(log, "Failed to apply debug info relocations"); return; } uint32_t truncated_addr = (value & 0xFFFFFFFF); DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); // ObjectFileELF creates a WritableDataBuffer in CreateInstance. WritableDataBuffer *data_buffer = llvm::cast(data_buffer_sp.get()); uint32_t *dst = reinterpret_cast( data_buffer->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); memcpy(dst, &truncated_addr, sizeof(uint32_t)); } } static void ApplyELF32ABS32RelRelocation(Symtab *symtab, ELFRelocation &rel, DataExtractor &debug_data, Section *rel_section) { Log *log = GetLog(LLDBLog::Modules); Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol32(rel)); if (symbol) { addr_t value = symbol->GetAddressRef().GetFileAddress(); if (value == LLDB_INVALID_ADDRESS) { const char *name = symbol->GetName().GetCString(); LLDB_LOGF(log, "Debug info symbol invalid: %s", name); return; } assert(llvm::isUInt<32>(value) && "Valid addresses are 32-bit"); DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); // ObjectFileELF creates a WritableDataBuffer in CreateInstance. WritableDataBuffer *data_buffer = llvm::cast(data_buffer_sp.get()); uint8_t *dst = data_buffer->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel); // Implicit addend is stored inline as a signed value. int32_t addend; memcpy(&addend, dst, sizeof(int32_t)); // The sum must be positive. This extra check prevents UB from overflow in // the actual range check below. if (addend < 0 && static_cast(-addend) > value) { LLDB_LOGF(log, "Debug info relocation overflow: 0x%" PRIx64, static_cast(value) + addend); return; } if (!llvm::isUInt<32>(value + addend)) { LLDB_LOGF(log, "Debug info relocation out of range: 0x%" PRIx64, value); return; } uint32_t addr = value + addend; memcpy(dst, &addr, sizeof(uint32_t)); } } unsigned ObjectFileELF::ApplyRelocations( Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, DataExtractor &rel_data, DataExtractor &symtab_data, DataExtractor &debug_data, Section *rel_section) { ELFRelocation rel(rel_hdr->sh_type); lldb::addr_t offset = 0; const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); reloc_info_fn reloc_type; reloc_info_fn reloc_symbol; if (hdr->Is32Bit()) { reloc_type = ELFRelocation::RelocType32; reloc_symbol = ELFRelocation::RelocSymbol32; } else { reloc_type = ELFRelocation::RelocType64; reloc_symbol = ELFRelocation::RelocSymbol64; } for (unsigned i = 0; i < num_relocations; ++i) { if (!rel.Parse(rel_data, &offset)) { GetModule()->ReportError(".rel{0}[{1:d}] failed to parse relocation", rel_section->GetName().AsCString(), i); break; } Symbol *symbol = nullptr; if (hdr->Is32Bit()) { switch (hdr->e_machine) { case llvm::ELF::EM_ARM: switch (reloc_type(rel)) { case R_ARM_ABS32: ApplyELF32ABS32RelRelocation(symtab, rel, debug_data, rel_section); break; case R_ARM_REL32: GetModule()->ReportError("unsupported AArch32 relocation:" " .rel{0}[{1}], type {2}", rel_section->GetName().AsCString(), i, reloc_type(rel)); break; default: assert(false && "unexpected relocation type"); } break; case llvm::ELF::EM_386: switch (reloc_type(rel)) { case R_386_32: symbol = symtab->FindSymbolByID(reloc_symbol(rel)); if (symbol) { addr_t f_offset = rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel); DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); // ObjectFileELF creates a WritableDataBuffer in CreateInstance. WritableDataBuffer *data_buffer = llvm::cast(data_buffer_sp.get()); uint32_t *dst = reinterpret_cast( data_buffer->GetBytes() + f_offset); addr_t value = symbol->GetAddressRef().GetFileAddress(); if (rel.IsRela()) { value += ELFRelocation::RelocAddend32(rel); } else { value += *dst; } *dst = value; } else { GetModule()->ReportError(".rel{0}[{1}] unknown symbol id: {2:d}", rel_section->GetName().AsCString(), i, reloc_symbol(rel)); } break; case R_386_NONE: case R_386_PC32: GetModule()->ReportError("unsupported i386 relocation:" " .rel{0}[{1}], type {2}", rel_section->GetName().AsCString(), i, reloc_type(rel)); break; default: assert(false && "unexpected relocation type"); break; } break; default: GetModule()->ReportError("unsupported 32-bit ELF machine arch: {0}", hdr->e_machine); break; } } else { switch (hdr->e_machine) { case llvm::ELF::EM_AARCH64: switch (reloc_type(rel)) { case R_AARCH64_ABS64: ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section); break; case R_AARCH64_ABS32: ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true); break; default: assert(false && "unexpected relocation type"); } break; case llvm::ELF::EM_LOONGARCH: switch (reloc_type(rel)) { case R_LARCH_64: ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section); break; case R_LARCH_32: ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true); break; default: assert(false && "unexpected relocation type"); } break; case llvm::ELF::EM_X86_64: switch (reloc_type(rel)) { case R_X86_64_64: ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section); break; case R_X86_64_32: ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, false); break; case R_X86_64_32S: ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true); break; case R_X86_64_PC32: default: assert(false && "unexpected relocation type"); } break; default: GetModule()->ReportError("unsupported 64-bit ELF machine arch: {0}", hdr->e_machine); break; } } } return 0; } unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id, lldb_private::Symtab *thetab) { assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); // Parse in the section list if needed. SectionList *section_list = GetSectionList(); if (!section_list) return 0; user_id_t symtab_id = rel_hdr->sh_link; user_id_t debug_id = rel_hdr->sh_info; const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); if (!symtab_hdr) return 0; const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); if (!debug_hdr) return 0; Section *rel = section_list->FindSectionByID(rel_id).get(); if (!rel) return 0; Section *symtab = section_list->FindSectionByID(symtab_id).get(); if (!symtab) return 0; Section *debug = section_list->FindSectionByID(debug_id).get(); if (!debug) return 0; DataExtractor rel_data; DataExtractor symtab_data; DataExtractor debug_data; if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) && GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) && GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) { ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr, rel_data, symtab_data, debug_data, debug); } return 0; } void ObjectFileELF::ParseSymtab(Symtab &lldb_symtab) { ModuleSP module_sp(GetModule()); if (!module_sp) return; Progress progress("Parsing symbol table", m_file.GetFilename().AsCString("")); ElapsedTime elapsed(module_sp->GetSymtabParseTime()); // We always want to use the main object file so we (hopefully) only have one // cached copy of our symtab, dynamic sections, etc. ObjectFile *module_obj_file = module_sp->GetObjectFile(); if (module_obj_file && module_obj_file != this) return module_obj_file->ParseSymtab(lldb_symtab); SectionList *section_list = module_sp->GetSectionList(); if (!section_list) return; uint64_t symbol_id = 0; // Sharable objects and dynamic executables usually have 2 distinct symbol // tables, one named ".symtab", and the other ".dynsym". The dynsym is a // smaller version of the symtab that only contains global symbols. The // information found in the dynsym is therefore also found in the symtab, // while the reverse is not necessarily true. Section *symtab = section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get(); if (symtab) { auto [num_symbols, address_class_map] = ParseSymbolTable(&lldb_symtab, symbol_id, symtab); m_address_class_map.merge(address_class_map); symbol_id += num_symbols; } // The symtab section is non-allocable and can be stripped, while the // .dynsym section which should always be always be there. To support the // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo // section, nomatter if .symtab was already parsed or not. This is because // minidebuginfo normally removes the .symtab symbols which have their // matching .dynsym counterparts. if (!symtab || GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"))) { Section *dynsym = section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true) .get(); if (dynsym) { auto [num_symbols, address_class_map] = ParseSymbolTable(&lldb_symtab, symbol_id, dynsym); symbol_id += num_symbols; m_address_class_map.merge(address_class_map); } } // DT_JMPREL // If present, this entry's d_ptr member holds the address of // relocation // entries associated solely with the procedure linkage table. // Separating // these relocation entries lets the dynamic linker ignore them during // process initialization, if lazy binding is enabled. If this entry is // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must // also be present. const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); if (symbol) { // Synthesize trampoline symbols to help navigate the PLT. addr_t addr = symbol->d_ptr; Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); if (reloc_section) { user_id_t reloc_id = reloc_section->GetID(); const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); if (reloc_header) ParseTrampolineSymbols(&lldb_symtab, symbol_id, reloc_header, reloc_id); } } if (DWARFCallFrameInfo *eh_frame = GetModule()->GetUnwindTable().GetEHFrameInfo()) { ParseUnwindSymbols(&lldb_symtab, eh_frame); } // In the event that there's no symbol entry for the entry point we'll // artificially create one. We delegate to the symtab object the figuring // out of the proper size, this will usually make it span til the next // symbol it finds in the section. This means that if there are missing // symbols the entry point might span beyond its function definition. // We're fine with this as it doesn't make it worse than not having a // symbol entry at all. if (CalculateType() == eTypeExecutable) { ArchSpec arch = GetArchitecture(); auto entry_point_addr = GetEntryPointAddress(); bool is_valid_entry_point = entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset(); addr_t entry_point_file_addr = entry_point_addr.GetFileAddress(); if (is_valid_entry_point && !lldb_symtab.FindSymbolContainingFileAddress( entry_point_file_addr)) { uint64_t symbol_id = lldb_symtab.GetNumSymbols(); // Don't set the name for any synthetic symbols, the Symbol // object will generate one if needed when the name is accessed // via accessors. SectionSP section_sp = entry_point_addr.GetSection(); Symbol symbol( /*symID=*/symbol_id, /*name=*/llvm::StringRef(), // Name will be auto generated. /*type=*/eSymbolTypeCode, /*external=*/true, /*is_debug=*/false, /*is_trampoline=*/false, /*is_artificial=*/true, /*section_sp=*/section_sp, /*offset=*/0, /*size=*/0, // FDE can span multiple symbols so don't use its size. /*size_is_valid=*/false, /*contains_linker_annotations=*/false, /*flags=*/0); // When the entry point is arm thumb we need to explicitly set its // class address to reflect that. This is important because expression // evaluation relies on correctly setting a breakpoint at this // address. if (arch.GetMachine() == llvm::Triple::arm && (entry_point_file_addr & 1)) { symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1); m_address_class_map[entry_point_file_addr ^ 1] = AddressClass::eCodeAlternateISA; } else { m_address_class_map[entry_point_file_addr] = AddressClass::eCode; } lldb_symtab.AddSymbol(symbol); } } } void ObjectFileELF::RelocateSection(lldb_private::Section *section) { static const char *debug_prefix = ".debug"; // Set relocated bit so we stop getting called, regardless of whether we // actually relocate. section->SetIsRelocated(true); // We only relocate in ELF relocatable files if (CalculateType() != eTypeObjectFile) return; const char *section_name = section->GetName().GetCString(); // Can't relocate that which can't be named if (section_name == nullptr) return; // We don't relocate non-debug sections at the moment if (strncmp(section_name, debug_prefix, strlen(debug_prefix))) return; // Relocation section names to look for std::string needle = std::string(".rel") + section_name; std::string needlea = std::string(".rela") + section_name; for (SectionHeaderCollIter I = m_section_headers.begin(); I != m_section_headers.end(); ++I) { if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) { const char *hay_name = I->section_name.GetCString(); if (hay_name == nullptr) continue; if (needle == hay_name || needlea == hay_name) { const ELFSectionHeader &reloc_header = *I; user_id_t reloc_id = SectionIndex(I); RelocateDebugSections(&reloc_header, reloc_id, GetSymtab()); break; } } } } void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table, DWARFCallFrameInfo *eh_frame) { SectionList *section_list = GetSectionList(); if (!section_list) return; // First we save the new symbols into a separate list and add them to the // symbol table after we collected all symbols we want to add. This is // neccessary because adding a new symbol invalidates the internal index of // the symtab what causing the next lookup to be slow because it have to // recalculate the index first. std::vector new_symbols; size_t num_symbols = symbol_table->GetNumSymbols(); uint64_t last_symbol_id = num_symbols ? symbol_table->SymbolAtIndex(num_symbols - 1)->GetID() : 0; eh_frame->ForEachFDEEntries([&](lldb::addr_t file_addr, uint32_t size, dw_offset_t) { Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr); if (symbol) { if (!symbol->GetByteSizeIsValid()) { symbol->SetByteSize(size); symbol->SetSizeIsSynthesized(true); } } else { SectionSP section_sp = section_list->FindSectionContainingFileAddress(file_addr); if (section_sp) { addr_t offset = file_addr - section_sp->GetFileAddress(); uint64_t symbol_id = ++last_symbol_id; // Don't set the name for any synthetic symbols, the Symbol // object will generate one if needed when the name is accessed // via accessors. Symbol eh_symbol( /*symID=*/symbol_id, /*name=*/llvm::StringRef(), // Name will be auto generated. /*type=*/eSymbolTypeCode, /*external=*/true, /*is_debug=*/false, /*is_trampoline=*/false, /*is_artificial=*/true, /*section_sp=*/section_sp, /*offset=*/offset, /*size=*/0, // FDE can span multiple symbols so don't use its size. /*size_is_valid=*/false, /*contains_linker_annotations=*/false, /*flags=*/0); new_symbols.push_back(eh_symbol); } } return true; }); for (const Symbol &s : new_symbols) symbol_table->AddSymbol(s); } bool ObjectFileELF::IsStripped() { // TODO: determine this for ELF return false; } //===----------------------------------------------------------------------===// // Dump // // Dump the specifics of the runtime file container (such as any headers // segments, sections, etc). void ObjectFileELF::Dump(Stream *s) { ModuleSP module_sp(GetModule()); if (!module_sp) { return; } std::lock_guard guard(module_sp->GetMutex()); s->Printf("%p: ", static_cast(this)); s->Indent(); s->PutCString("ObjectFileELF"); ArchSpec header_arch = GetArchitecture(); *s << ", file = '" << m_file << "', arch = " << header_arch.GetArchitectureName() << "\n"; DumpELFHeader(s, m_header); s->EOL(); DumpELFProgramHeaders(s); s->EOL(); DumpELFSectionHeaders(s); s->EOL(); SectionList *section_list = GetSectionList(); if (section_list) section_list->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true, UINT32_MAX); Symtab *symtab = GetSymtab(); if (symtab) symtab->Dump(s, nullptr, eSortOrderNone); s->EOL(); DumpDependentModules(s); s->EOL(); } // DumpELFHeader // // Dump the ELF header to the specified output stream void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) { s->PutCString("ELF Header\n"); s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); s->Printf("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); s->Printf("e_type = 0x%4.4x ", header.e_type); DumpELFHeader_e_type(s, header.e_type); s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); s->Printf("e_version = 0x%8.8x\n", header.e_version); s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); s->Printf("e_flags = 0x%8.8x\n", header.e_flags); s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); s->Printf("e_phnum = 0x%8.8x\n", header.e_phnum); s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); s->Printf("e_shnum = 0x%8.8x\n", header.e_shnum); s->Printf("e_shstrndx = 0x%8.8x\n", header.e_shstrndx); } // DumpELFHeader_e_type // // Dump an token value for the ELF header member e_type void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) { switch (e_type) { case ET_NONE: *s << "ET_NONE"; break; case ET_REL: *s << "ET_REL"; break; case ET_EXEC: *s << "ET_EXEC"; break; case ET_DYN: *s << "ET_DYN"; break; case ET_CORE: *s << "ET_CORE"; break; default: break; } } // DumpELFHeader_e_ident_EI_DATA // // Dump an token value for the ELF header member e_ident[EI_DATA] void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) { switch (ei_data) { case ELFDATANONE: *s << "ELFDATANONE"; break; case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; default: break; } } // DumpELFProgramHeader // // Dump a single ELF program header to the specified output stream void ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) { DumpELFProgramHeader_p_type(s, ph.p_type); s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); DumpELFProgramHeader_p_flags(s, ph.p_flags); s->Printf(") %8.8" PRIx64, ph.p_align); } // DumpELFProgramHeader_p_type // // Dump an token value for the ELF program header member p_type which describes // the type of the program header void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) { const int kStrWidth = 15; switch (p_type) { CASE_AND_STREAM(s, PT_NULL, kStrWidth); CASE_AND_STREAM(s, PT_LOAD, kStrWidth); CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth); CASE_AND_STREAM(s, PT_INTERP, kStrWidth); CASE_AND_STREAM(s, PT_NOTE, kStrWidth); CASE_AND_STREAM(s, PT_SHLIB, kStrWidth); CASE_AND_STREAM(s, PT_PHDR, kStrWidth); CASE_AND_STREAM(s, PT_TLS, kStrWidth); CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); default: s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); break; } } // DumpELFProgramHeader_p_flags // // Dump an token value for the ELF program header member p_flags void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) { *s << ((p_flags & PF_X) ? "PF_X" : " ") << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') << ((p_flags & PF_W) ? "PF_W" : " ") << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') << ((p_flags & PF_R) ? "PF_R" : " "); } // DumpELFProgramHeaders // // Dump all of the ELF program header to the specified output stream void ObjectFileELF::DumpELFProgramHeaders(Stream *s) { if (!ParseProgramHeaders()) return; s->PutCString("Program Headers\n"); s->PutCString("IDX p_type p_offset p_vaddr p_paddr " "p_filesz p_memsz p_flags p_align\n"); s->PutCString("==== --------------- -------- -------- -------- " "-------- -------- ------------------------- --------\n"); for (const auto &H : llvm::enumerate(m_program_headers)) { s->Format("[{0,2}] ", H.index()); ObjectFileELF::DumpELFProgramHeader(s, H.value()); s->EOL(); } } // DumpELFSectionHeader // // Dump a single ELF section header to the specified output stream void ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) { s->Printf("%8.8x ", sh.sh_name); DumpELFSectionHeader_sh_type(s, sh.sh_type); s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); DumpELFSectionHeader_sh_flags(s, sh.sh_flags); s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); } // DumpELFSectionHeader_sh_type // // Dump an token value for the ELF section header member sh_type which // describes the type of the section void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) { const int kStrWidth = 12; switch (sh_type) { CASE_AND_STREAM(s, SHT_NULL, kStrWidth); CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth); CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth); CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth); CASE_AND_STREAM(s, SHT_RELA, kStrWidth); CASE_AND_STREAM(s, SHT_HASH, kStrWidth); CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth); CASE_AND_STREAM(s, SHT_NOTE, kStrWidth); CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth); CASE_AND_STREAM(s, SHT_REL, kStrWidth); CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth); CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth); CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth); CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth); CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth); CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth); default: s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); break; } } // DumpELFSectionHeader_sh_flags // // Dump an token value for the ELF section header member sh_flags void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) { *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); } // DumpELFSectionHeaders // // Dump all of the ELF section header to the specified output stream void ObjectFileELF::DumpELFSectionHeaders(Stream *s) { if (!ParseSectionHeaders()) return; s->PutCString("Section Headers\n"); s->PutCString("IDX name type flags " "addr offset size link info addralgn " "entsize Name\n"); s->PutCString("==== -------- ------------ -------------------------------- " "-------- -------- -------- -------- -------- -------- " "-------- ====================\n"); uint32_t idx = 0; for (SectionHeaderCollConstIter I = m_section_headers.begin(); I != m_section_headers.end(); ++I, ++idx) { s->Printf("[%2u] ", idx); ObjectFileELF::DumpELFSectionHeader(s, *I); const char *section_name = I->section_name.AsCString(""); if (section_name) *s << ' ' << section_name << "\n"; } } void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) { size_t num_modules = ParseDependentModules(); if (num_modules > 0) { s->PutCString("Dependent Modules:\n"); for (unsigned i = 0; i < num_modules; ++i) { const FileSpec &spec = m_filespec_up->GetFileSpecAtIndex(i); s->Printf(" %s\n", spec.GetFilename().GetCString()); } } } ArchSpec ObjectFileELF::GetArchitecture() { if (!ParseHeader()) return ArchSpec(); if (m_section_headers.empty()) { // Allow elf notes to be parsed which may affect the detected architecture. ParseSectionHeaders(); } if (CalculateType() == eTypeCoreFile && !m_arch_spec.TripleOSWasSpecified()) { // Core files don't have section headers yet they have PT_NOTE program // headers that might shed more light on the architecture for (const elf::ELFProgramHeader &H : ProgramHeaders()) { if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0) continue; DataExtractor data; if (data.SetData(m_data, H.p_offset, H.p_filesz) == H.p_filesz) { UUID uuid; RefineModuleDetailsFromNote(data, m_arch_spec, uuid); } } } return m_arch_spec; } ObjectFile::Type ObjectFileELF::CalculateType() { switch (m_header.e_type) { case llvm::ELF::ET_NONE: // 0 - No file type return eTypeUnknown; case llvm::ELF::ET_REL: // 1 - Relocatable file return eTypeObjectFile; case llvm::ELF::ET_EXEC: // 2 - Executable file return eTypeExecutable; case llvm::ELF::ET_DYN: // 3 - Shared object file return eTypeSharedLibrary; case ET_CORE: // 4 - Core file return eTypeCoreFile; default: break; } return eTypeUnknown; } ObjectFile::Strata ObjectFileELF::CalculateStrata() { switch (m_header.e_type) { case llvm::ELF::ET_NONE: // 0 - No file type return eStrataUnknown; case llvm::ELF::ET_REL: // 1 - Relocatable file return eStrataUnknown; case llvm::ELF::ET_EXEC: // 2 - Executable file { SectionList *section_list = GetSectionList(); if (section_list) { static ConstString loader_section_name(".interp"); SectionSP loader_section = section_list->FindSectionByName(loader_section_name); if (loader_section) { char buffer[256]; size_t read_size = ReadSectionData(loader_section.get(), 0, buffer, sizeof(buffer)); // We compare the content of .interp section // It will contains \0 when counting read_size, so the size needs to // decrease by one llvm::StringRef loader_name(buffer, read_size - 1); llvm::StringRef freebsd_kernel_loader_name("/red/herring"); if (loader_name == freebsd_kernel_loader_name) return eStrataKernel; } } return eStrataUser; } case llvm::ELF::ET_DYN: // 3 - Shared object file // TODO: is there any way to detect that an shared library is a kernel // related executable by inspecting the program headers, section headers, // symbols, or any other flag bits??? return eStrataUnknown; case ET_CORE: // 4 - Core file // TODO: is there any way to detect that an core file is a kernel // related executable by inspecting the program headers, section headers, // symbols, or any other flag bits??? return eStrataUnknown; default: break; } return eStrataUnknown; } size_t ObjectFileELF::ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len) { // If some other objectfile owns this data, pass this to them. if (section->GetObjectFile() != this) return section->GetObjectFile()->ReadSectionData(section, section_offset, dst, dst_len); if (!section->Test(SHF_COMPRESSED)) return ObjectFile::ReadSectionData(section, section_offset, dst, dst_len); // For compressed sections we need to read to full data to be able to // decompress. DataExtractor data; ReadSectionData(section, data); return data.CopyData(section_offset, dst_len, dst); } size_t ObjectFileELF::ReadSectionData(Section *section, DataExtractor §ion_data) { // If some other objectfile owns this data, pass this to them. if (section->GetObjectFile() != this) return section->GetObjectFile()->ReadSectionData(section, section_data); size_t result = ObjectFile::ReadSectionData(section, section_data); if (result == 0 || !(section->Get() & llvm::ELF::SHF_COMPRESSED)) return result; auto Decompressor = llvm::object::Decompressor::create( section->GetName().GetStringRef(), {reinterpret_cast(section_data.GetDataStart()), size_t(section_data.GetByteSize())}, GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8); if (!Decompressor) { GetModule()->ReportWarning( "Unable to initialize decompressor for section '{0}': {1}", section->GetName().GetCString(), llvm::toString(Decompressor.takeError()).c_str()); section_data.Clear(); return 0; } auto buffer_sp = std::make_shared(Decompressor->getDecompressedSize(), 0); if (auto error = Decompressor->decompress( {buffer_sp->GetBytes(), size_t(buffer_sp->GetByteSize())})) { GetModule()->ReportWarning("Decompression of section '{0}' failed: {1}", section->GetName().GetCString(), llvm::toString(std::move(error)).c_str()); section_data.Clear(); return 0; } section_data.SetData(buffer_sp); return buffer_sp->GetByteSize(); } llvm::ArrayRef ObjectFileELF::ProgramHeaders() { ParseProgramHeaders(); return m_program_headers; } DataExtractor ObjectFileELF::GetSegmentData(const ELFProgramHeader &H) { return DataExtractor(m_data, H.p_offset, H.p_filesz); } bool ObjectFileELF::AnySegmentHasPhysicalAddress() { for (const ELFProgramHeader &H : ProgramHeaders()) { if (H.p_paddr != 0) return true; } return false; } std::vector ObjectFileELF::GetLoadableData(Target &target) { // Create a list of loadable data from loadable segments, using physical // addresses if they aren't all null std::vector loadables; bool should_use_paddr = AnySegmentHasPhysicalAddress(); for (const ELFProgramHeader &H : ProgramHeaders()) { LoadableData loadable; if (H.p_type != llvm::ELF::PT_LOAD) continue; loadable.Dest = should_use_paddr ? H.p_paddr : H.p_vaddr; if (loadable.Dest == LLDB_INVALID_ADDRESS) continue; if (H.p_filesz == 0) continue; auto segment_data = GetSegmentData(H); loadable.Contents = llvm::ArrayRef(segment_data.GetDataStart(), segment_data.GetByteSize()); loadables.push_back(loadable); } return loadables; } lldb::WritableDataBufferSP ObjectFileELF::MapFileDataWritable(const FileSpec &file, uint64_t Size, uint64_t Offset) { return FileSystem::Instance().CreateWritableDataBuffer(file.GetPath(), Size, Offset); }