diff options
Diffstat (limited to 'lldb/source')
18 files changed, 537 insertions, 1 deletions
diff --git a/lldb/source/Expression/ExpressionSourceCode.cpp b/lldb/source/Expression/ExpressionSourceCode.cpp index 695acae969d..c4ab7a95d7a 100644 --- a/lldb/source/Expression/ExpressionSourceCode.cpp +++ b/lldb/source/Expression/ExpressionSourceCode.cpp @@ -12,6 +12,8 @@ #include "lldb/Core/StreamString.h" #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/DebugMacros.h" #include "lldb/Symbol/Block.h" #include "lldb/Symbol/TypeSystem.h" #include "lldb/Target/ExecutionContext.h" @@ -57,6 +59,121 @@ extern "C" } )"; +namespace { + +class AddMacroState +{ + enum State + { + CURRENT_FILE_NOT_YET_PUSHED, + CURRENT_FILE_PUSHED, + CURRENT_FILE_POPPED + }; + +public: + AddMacroState(const FileSpec ¤t_file, const uint32_t current_file_line) + : m_state(CURRENT_FILE_NOT_YET_PUSHED), + m_current_file(current_file), + m_current_file_line(current_file_line) + { } + + void + StartFile(const FileSpec &file) + { + m_file_stack.push_back(file); + if (file == m_current_file) + m_state = CURRENT_FILE_PUSHED; + } + + void + EndFile() + { + if (m_file_stack.size() == 0) + return; + + FileSpec old_top = m_file_stack.back(); + m_file_stack.pop_back(); + if (old_top == m_current_file) + m_state = CURRENT_FILE_POPPED; + } + + // An entry is valid if it occurs before the current line in + // the current file. + bool + IsValidEntry(uint32_t line) + { + switch (m_state) + { + case CURRENT_FILE_NOT_YET_PUSHED: + return true; + case CURRENT_FILE_POPPED: + return false; + case CURRENT_FILE_PUSHED: + // If we are in file included in the current file, + // the entry should be added. + if (m_file_stack.back() != m_current_file) + return true; + + if (line >= m_current_file_line) + return false; + else + return true; + } + } + +private: + std::vector<FileSpec> m_file_stack; + State m_state; + FileSpec m_current_file; + uint32_t m_current_file_line; +}; + +} // anonymous namespace + +static void +AddMacros(const DebugMacros *dm, CompileUnit *comp_unit, AddMacroState &state, StreamString &stream) +{ + if (dm == nullptr) + return; + + for (size_t i = 0; i < dm->GetNumMacroEntries(); i++) + { + const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(i); + uint32_t line; + + switch (entry.GetType()) + { + case DebugMacroEntry::DEFINE: + if (state.IsValidEntry(entry.GetLineNumber())) + stream.Printf("#define %s\n", entry.GetMacroString().AsCString()); + else + return; + break; + case DebugMacroEntry::UNDEF: + if (state.IsValidEntry(entry.GetLineNumber())) + stream.Printf("#undef %s\n", entry.GetMacroString().AsCString()); + else + return; + break; + case DebugMacroEntry::START_FILE: + line = entry.GetLineNumber(); + if (state.IsValidEntry(line)) + state.StartFile(entry.GetFileSpec(comp_unit)); + else + return; + break; + case DebugMacroEntry::END_FILE: + state.EndFile(); + break; + case DebugMacroEntry::INDIRECT: + AddMacros(entry.GetIndirectDebugMacros(), comp_unit, state, stream); + break; + default: + // This is an unknown/invalid entry. Ignore. + break; + } + } +} bool ExpressionSourceCode::GetText (std::string &text, lldb::LanguageType wrapping_language, bool const_object, bool static_method, ExecutionContext &exe_ctx) const { @@ -120,6 +237,23 @@ bool ExpressionSourceCode::GetText (std::string &text, lldb::LanguageType wrappi } } + + StreamString debug_macros_stream; + if (StackFrame *frame = exe_ctx.GetFramePtr()) + { + const SymbolContext &sc = frame->GetSymbolContext( + lldb:: eSymbolContextCompUnit | lldb::eSymbolContextLineEntry); + + if (sc.comp_unit && sc.line_entry.IsValid()) + { + DebugMacros *dm = sc.comp_unit->GetDebugMacros(); + if (dm) + { + AddMacroState state(sc.line_entry.file, sc.line_entry.line); + AddMacros(dm, sc.comp_unit, state, debug_macros_stream); + } + } + } if (m_wrap) { @@ -135,8 +269,9 @@ bool ExpressionSourceCode::GetText (std::string &text, lldb::LanguageType wrappi StreamString wrap_stream; - wrap_stream.Printf("%s\n%s\n%s\n%s\n", + wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n", module_macros.c_str(), + debug_macros_stream.GetData(), g_expression_prefix, target_specific_defines, m_prefix.c_str()); diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp index 5c1fccf664f..44fe6615a36 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp @@ -1777,6 +1777,7 @@ ObjectFileELF::CreateSections(SectionList &unified_section_list) static ConstString g_sect_name_dwarf_debug_line (".debug_line"); static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); + static ConstString g_sect_name_dwarf_debug_macro (".debug_macro"); static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); @@ -1785,6 +1786,7 @@ ObjectFileELF::CreateSections(SectionList &unified_section_list) static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo"); static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo"); static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo"); + static ConstString g_sect_name_dwarf_debug_macro_dwo (".debug_macro.dwo"); static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo"); static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo"); static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo"); @@ -1832,6 +1834,7 @@ ObjectFileELF::CreateSections(SectionList &unified_section_list) else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; + else if (name == g_sect_name_dwarf_debug_macro) sect_type = eSectionTypeDWARFDebugMacro; else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; @@ -1840,6 +1843,7 @@ ObjectFileELF::CreateSections(SectionList &unified_section_list) else if (name == g_sect_name_dwarf_debug_abbrev_dwo) sect_type = eSectionTypeDWARFDebugAbbrev; else if (name == g_sect_name_dwarf_debug_info_dwo) sect_type = eSectionTypeDWARFDebugInfo; else if (name == g_sect_name_dwarf_debug_line_dwo) sect_type = eSectionTypeDWARFDebugLine; + else if (name == g_sect_name_dwarf_debug_macro_dwo) sect_type = eSectionTypeDWARFDebugMacro; else if (name == g_sect_name_dwarf_debug_loc_dwo) sect_type = eSectionTypeDWARFDebugLoc; else if (name == g_sect_name_dwarf_debug_str_dwo) sect_type = eSectionTypeDWARFDebugStr; else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets; diff --git a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp index 0720c5e8cc9..9c1e1778250 100644 --- a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp +++ b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp @@ -1369,6 +1369,7 @@ ObjectFileMachO::GetAddressClass (lldb::addr_t file_addr) case eSectionTypeDWARFDebugLine: case eSectionTypeDWARFDebugLoc: case eSectionTypeDWARFDebugMacInfo: + case eSectionTypeDWARFDebugMacro: case eSectionTypeDWARFDebugPubNames: case eSectionTypeDWARFDebugPubTypes: case eSectionTypeDWARFDebugRanges: diff --git a/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt b/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt index b1c8fb7bda9..b4658115dfe 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt +++ b/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt @@ -12,6 +12,7 @@ add_lldb_library(lldbPluginSymbolFileDWARF DWARFDebugInfo.cpp DWARFDebugInfoEntry.cpp DWARFDebugLine.cpp + DWARFDebugMacro.cpp DWARFDebugMacinfo.cpp DWARFDebugMacinfoEntry.cpp DWARFDebugPubnames.cpp diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp new file mode 100644 index 00000000000..75c812e6e79 --- /dev/null +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp @@ -0,0 +1,128 @@ +//===-- DWARFDebugMacro.cpp -------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "DWARFDebugMacro.h" +#include "SymbolFileDWARF.h" + +#include "lldb/Symbol/DebugMacros.h" + +#include "DWARFDataExtractor.h" + +using namespace lldb_private; + +DWARFDebugMacroHeader +DWARFDebugMacroHeader::ParseHeader(const DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset) +{ + DWARFDebugMacroHeader header; + + // Skip over the version field in header. + header.m_version = debug_macro_data.GetU16(offset); + + uint8_t flags = debug_macro_data.GetU8(offset); + header.m_offset_is_64_bit = flags & OFFSET_SIZE_MASK ? true : false; + + if (flags & DEBUG_LINE_OFFSET_MASK) + { + if (header.m_offset_is_64_bit) + header.m_debug_line_offset = debug_macro_data.GetU64(offset); + else + header.m_debug_line_offset = debug_macro_data.GetU32(offset); + } + + // Skip over the operands table if it is present. + if (flags & OPCODE_OPERANDS_TABLE_MASK) + SkipOperandTable(debug_macro_data, offset); + + return header; +} + +void +DWARFDebugMacroHeader::SkipOperandTable(const DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset) +{ + uint8_t entry_count = debug_macro_data.GetU8(offset); + for (uint8_t i = 0; i < entry_count; i++) + { + // Skip over the opcode number. + debug_macro_data.GetU8(offset); + + uint64_t operand_count = debug_macro_data.GetULEB128(offset); + + for (uint64_t j = 0; j < operand_count; j++) + { + // Skip over the operand form + debug_macro_data.GetU8(offset); + } + } +} + +void +DWARFDebugMacroEntry::ReadMacroEntries(const DWARFDataExtractor &debug_macro_data, + const DWARFDataExtractor &debug_str_data, + const bool offset_is_64_bit, + lldb::offset_t *offset, + SymbolFileDWARF *sym_file_dwarf, + DebugMacrosSP &debug_macros_sp) +{ + llvm::dwarf::MacroEntryType type = static_cast<llvm::dwarf::MacroEntryType>(debug_macro_data.GetU8(offset)); + while (type != 0) + { + lldb::offset_t new_offset = 0, str_offset = 0; + uint32_t line = 0; + const char *macro_str = nullptr; + uint32_t debug_line_file_idx = 0; + + switch (type) + { + case DW_MACRO_define: + case DW_MACRO_undef: + line = debug_macro_data.GetULEB128(offset); + macro_str = debug_macro_data.GetCStr(offset); + if (type == DW_MACRO_define) + debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateDefineEntry(line, macro_str)); + else + debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateUndefEntry(line, macro_str)); + break; + case DW_MACRO_define_indirect: + case DW_MACRO_undef_indirect: + line = debug_macro_data.GetULEB128(offset); + if (offset_is_64_bit) + str_offset = debug_macro_data.GetU64(offset); + else + str_offset = debug_macro_data.GetU32(offset); + macro_str = debug_str_data.GetCStr(&str_offset); + if (type == DW_MACRO_define_indirect) + debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateDefineEntry(line, macro_str)); + else + debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateUndefEntry(line, macro_str)); + break; + case DW_MACRO_start_file: + line = debug_macro_data.GetULEB128(offset); + debug_line_file_idx = debug_macro_data.GetULEB128(offset); + debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateStartFileEntry(line, debug_line_file_idx)); + break; + case DW_MACRO_end_file: + // This operation has no operands. + debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateEndFileEntry()); + break; + case DW_MACRO_transparent_include: + if (offset_is_64_bit) + new_offset = debug_macro_data.GetU64(offset); + else + new_offset = debug_macro_data.GetU32(offset); + debug_macros_sp->AddMacroEntry( + DebugMacroEntry::CreateIndirectEntry(sym_file_dwarf->ParseDebugMacros(&new_offset))); + break; + default: + // TODO: Add support for other standard operations. + // TODO: Provide mechanism to hook handling of non-standard/extension operands. + return; + } + type = static_cast<llvm::dwarf::MacroEntryType>(debug_macro_data.GetU8(offset)); + } +} diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h new file mode 100644 index 00000000000..c60b9749b00 --- /dev/null +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.h @@ -0,0 +1,68 @@ +//===-- DWARFDebugMacro.h ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef SymbolFileDWARF_DWARFDebugMacro_h_ +#define SymbolFileDWARF_DWARFDebugMacro_h_ + +#include <map> + +#include "lldb/lldb-types.h" +#include "lldb/Core/dwarf.h" +#include "lldb/Symbol/DebugMacros.h" + +namespace lldb_private +{ + +class DWARFDataExtractor; + +} // namespace lldb_private + +class SymbolFileDWARF; + +class DWARFDebugMacroHeader +{ +public: + enum HeaderFlagMask + { + OFFSET_SIZE_MASK = 0x1, + DEBUG_LINE_OFFSET_MASK = 0x2, + OPCODE_OPERANDS_TABLE_MASK = 0x4 + }; + + static DWARFDebugMacroHeader + ParseHeader(const lldb_private::DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset); + + bool + OffsetIs64Bit() const + { + return m_offset_is_64_bit; + } + +private: + static void + SkipOperandTable(const lldb_private::DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset); + + uint16_t m_version; + bool m_offset_is_64_bit; + uint64_t m_debug_line_offset; +}; + +class DWARFDebugMacroEntry +{ +public: + static void + ReadMacroEntries(const lldb_private::DWARFDataExtractor &debug_macro_data, + const lldb_private::DWARFDataExtractor &debug_str_data, + const bool offset_is_64_bit, + lldb::offset_t *sect_offset, + SymbolFileDWARF *sym_file_dwarf, + lldb_private::DebugMacrosSP &debug_macros_sp); +}; + +#endif // SymbolFileDWARF_DWARFDebugMacro_h_ diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp index fd254ad9c29..9c161eb3ca5 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -39,6 +39,7 @@ #include "lldb/Symbol/CompilerDeclContext.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/LineTable.h" +#include "lldb/Symbol/DebugMacros.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/TypeSystem.h" @@ -58,6 +59,7 @@ #include "DWARFDebugAranges.h" #include "DWARFDebugInfo.h" #include "DWARFDebugLine.h" +#include "DWARFDebugMacro.h" #include "DWARFDebugPubnames.h" #include "DWARFDebugRanges.h" #include "DWARFDeclContext.h" @@ -436,6 +438,7 @@ SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) : m_data_debug_frame (), m_data_debug_info (), m_data_debug_line (), + m_data_debug_macro (), m_data_debug_loc (), m_data_debug_ranges (), m_data_debug_str (), @@ -709,6 +712,12 @@ SymbolFileDWARF::get_debug_line_data() } const DWARFDataExtractor& +SymbolFileDWARF::get_debug_macro_data() +{ + return GetCachedSectionData (eSectionTypeDWARFDebugMacro, m_data_debug_macro); +} + +const DWARFDataExtractor& SymbolFileDWARF::get_debug_loc_data() { return GetCachedSectionData (eSectionTypeDWARFDebugLoc, m_data_debug_loc); @@ -1204,6 +1213,51 @@ SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc) return false; } +lldb_private::DebugMacrosSP +SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) +{ + auto iter = m_debug_macros_map.find(*offset); + if (iter != m_debug_macros_map.end()) + return iter->second; + + const DWARFDataExtractor &debug_macro_data = get_debug_macro_data(); + if (debug_macro_data.GetByteSize() == 0) + return DebugMacrosSP(); + + lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros()); + m_debug_macros_map[*offset] = debug_macros_sp; + + const DWARFDebugMacroHeader &header = DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset); + DWARFDebugMacroEntry::ReadMacroEntries( + debug_macro_data, get_debug_str_data(), header.OffsetIs64Bit(), offset, this, debug_macros_sp); + + return debug_macros_sp; +} + +bool +SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext& sc) +{ + assert (sc.comp_unit); + + DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); + if (dwarf_cu == nullptr) + return false; + + const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly(); + if (!dwarf_cu_die) + return false; + + lldb::offset_t sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET); + if (sect_offset == DW_INVALID_OFFSET) + sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros, DW_INVALID_OFFSET); + if (sect_offset == DW_INVALID_OFFSET) + return false; + + sc.comp_unit->SetDebugMacros(ParseDebugMacros(§_offset)); + + return true; +} + size_t SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext& sc, Block *parent_block, diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h index 2bdbc37c51f..c2e78a417b7 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -16,6 +16,7 @@ #include <map> #include <mutex> #include <set> +#include <unordered_map> #include <vector> // Other libraries and framework includes @@ -28,6 +29,7 @@ #include "lldb/Core/RangeMap.h" #include "lldb/Core/UniqueCStringMap.h" #include "lldb/Expression/DWARFExpression.h" +#include "lldb/Symbol/DebugMacros.h" #include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolContext.h" @@ -124,6 +126,9 @@ public: ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc) override; bool + ParseCompileUnitDebugMacros (const lldb_private::SymbolContext& sc) override; + + bool ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList& support_files) override; @@ -248,6 +253,7 @@ public: const lldb_private::DWARFDataExtractor& get_debug_frame_data (); const lldb_private::DWARFDataExtractor& get_debug_info_data (); const lldb_private::DWARFDataExtractor& get_debug_line_data (); + const lldb_private::DWARFDataExtractor& get_debug_macro_data (); const lldb_private::DWARFDataExtractor& get_debug_loc_data (); const lldb_private::DWARFDataExtractor& get_debug_ranges_data (); const lldb_private::DWARFDataExtractor& get_debug_str_data (); @@ -302,6 +308,9 @@ public: bool Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu); + lldb_private::DebugMacrosSP + ParseDebugMacros(lldb::offset_t *offset); + static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die); @@ -530,6 +539,7 @@ protected: DWARFDataSegment m_data_debug_frame; DWARFDataSegment m_data_debug_info; DWARFDataSegment m_data_debug_line; + DWARFDataSegment m_data_debug_macro; DWARFDataSegment m_data_debug_loc; DWARFDataSegment m_data_debug_ranges; DWARFDataSegment m_data_debug_str; @@ -549,6 +559,10 @@ protected: std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_ap; std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_ap; std::unique_ptr<GlobalVariableMap> m_global_aranges_ap; + + typedef std::unordered_map<lldb::offset_t, lldb_private::DebugMacrosSP> DebugMacrosMap; + DebugMacrosMap m_debug_macros_map; + ExternalTypeModuleMap m_external_type_modules; NameToDIE m_function_basename_index; // All concrete functions NameToDIE m_function_fullname_index; // All concrete functions diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp index be8e870c3cf..be25dfc99de 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp @@ -707,6 +707,15 @@ SymbolFileDWARFDebugMap::ParseCompileUnitLineTable (const SymbolContext& sc) } bool +SymbolFileDWARFDebugMap::ParseCompileUnitDebugMacros (const SymbolContext& sc) +{ + SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc); + if (oso_dwarf) + return oso_dwarf->ParseCompileUnitDebugMacros (sc); + return false; +} + +bool SymbolFileDWARFDebugMap::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList &support_files) { SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc); diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h index a54701e5150..1eb33c927bd 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h @@ -63,6 +63,7 @@ public: lldb::LanguageType ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc) override; size_t ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc) override; bool ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc) override; + bool ParseCompileUnitDebugMacros (const lldb_private::SymbolContext& sc) override; bool ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files) override; bool ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) override; size_t ParseFunctionBlocks (const lldb_private::SymbolContext& sc) override; diff --git a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp index ea8991c6351..d3dd1ae923e 100644 --- a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp +++ b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp @@ -253,6 +253,12 @@ SymbolFileSymtab::ParseCompileUnitLineTable (const SymbolContext &sc) } bool +SymbolFileSymtab::ParseCompileUnitDebugMacros (const SymbolContext &sc) +{ + return false; +} + +bool SymbolFileSymtab::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList &support_files) { return false; diff --git a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h index 5223fa061c3..4648da49cb9 100644 --- a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h +++ b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h @@ -69,6 +69,9 @@ public: ParseCompileUnitLineTable(const lldb_private::SymbolContext& sc) override; bool + ParseCompileUnitDebugMacros(const lldb_private::SymbolContext& sc) override; + + bool ParseCompileUnitSupportFiles(const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files) override; diff --git a/lldb/source/Symbol/CMakeLists.txt b/lldb/source/Symbol/CMakeLists.txt index 19b6f79efbb..6372fffde1f 100644 --- a/lldb/source/Symbol/CMakeLists.txt +++ b/lldb/source/Symbol/CMakeLists.txt @@ -10,6 +10,7 @@ add_lldb_library(lldbSymbol CompilerType.cpp CompileUnit.cpp CompactUnwindInfo.cpp + DebugMacros.cpp Declaration.cpp DWARFCallFrameInfo.cpp Function.cpp diff --git a/lldb/source/Symbol/CompileUnit.cpp b/lldb/source/Symbol/CompileUnit.cpp index ffa7742b34a..50eda880637 100644 --- a/lldb/source/Symbol/CompileUnit.cpp +++ b/lldb/source/Symbol/CompileUnit.cpp @@ -268,6 +268,37 @@ CompileUnit::SetLineTable(LineTable* line_table) m_line_table_ap.reset(line_table); } +DebugMacros* +CompileUnit::GetDebugMacros() +{ + if (m_debug_macros_sp.get() == nullptr) + { + if (m_flags.IsClear(flagsParsedDebugMacros)) + { + m_flags.Set(flagsParsedDebugMacros); + SymbolVendor* symbol_vendor = GetModule()->GetSymbolVendor(); + if (symbol_vendor) + { + SymbolContext sc; + CalculateSymbolContext(&sc); + symbol_vendor->ParseCompileUnitDebugMacros(sc); + } + } + } + + return m_debug_macros_sp.get(); +} + +void +CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) +{ + if (debug_macros_sp.get() == nullptr) + m_flags.Clear(flagsParsedDebugMacros); + else + m_flags.Set(flagsParsedDebugMacros); + m_debug_macros_sp = debug_macros_sp; +} + VariableListSP CompileUnit::GetVariableList(bool can_create) { diff --git a/lldb/source/Symbol/DebugMacros.cpp b/lldb/source/Symbol/DebugMacros.cpp new file mode 100644 index 00000000000..88a28ba75e6 --- /dev/null +++ b/lldb/source/Symbol/DebugMacros.cpp @@ -0,0 +1,65 @@ +//===-- DebugMacros.cpp -----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "lldb/Symbol/DebugMacros.h" + +#include "lldb/Symbol/CompileUnit.h" + +using namespace lldb_private; + +DebugMacroEntry::DebugMacroEntry(EntryType type, + uint32_t line, + uint32_t debug_line_file_idx, + const char *str) + : m_type(type), + m_line(line), + m_debug_line_file_idx(debug_line_file_idx), + m_str(str) +{ } + +DebugMacroEntry::DebugMacroEntry(EntryType type, + const DebugMacrosSP &debug_macros_sp) + : m_type(type), m_line(0), m_debug_line_file_idx(0), m_debug_macros_sp(debug_macros_sp) +{ } + +const FileSpec& +DebugMacroEntry::GetFileSpec(CompileUnit *comp_unit) const +{ + return comp_unit->GetSupportFiles().GetFileSpecAtIndex(m_debug_line_file_idx); +} + +DebugMacroEntry +DebugMacroEntry::CreateDefineEntry(uint32_t line, const char *str) +{ + return DebugMacroEntry(DebugMacroEntry::DEFINE, line, 0, str); +} + +DebugMacroEntry +DebugMacroEntry::CreateUndefEntry(uint32_t line, const char *str) +{ + return DebugMacroEntry(DebugMacroEntry::UNDEF, line, 0, str); +} + +DebugMacroEntry +DebugMacroEntry::CreateStartFileEntry(uint32_t line, uint32_t debug_line_file_idx) +{ + return DebugMacroEntry(DebugMacroEntry::START_FILE, line, debug_line_file_idx, nullptr); +} + +DebugMacroEntry +DebugMacroEntry::CreateEndFileEntry() +{ + return DebugMacroEntry(DebugMacroEntry::END_FILE, 0, 0, nullptr); +} + +DebugMacroEntry +DebugMacroEntry::CreateIndirectEntry(const DebugMacrosSP &debug_macros_sp) +{ + return DebugMacroEntry(DebugMacroEntry::INDIRECT, debug_macros_sp); +} diff --git a/lldb/source/Symbol/ObjectFile.cpp b/lldb/source/Symbol/ObjectFile.cpp index a07914106b2..99f9236a2cd 100644 --- a/lldb/source/Symbol/ObjectFile.cpp +++ b/lldb/source/Symbol/ObjectFile.cpp @@ -362,6 +362,7 @@ ObjectFile::GetAddressClass (addr_t file_addr) case eSectionTypeDWARFDebugLine: case eSectionTypeDWARFDebugLoc: case eSectionTypeDWARFDebugMacInfo: + case eSectionTypeDWARFDebugMacro: case eSectionTypeDWARFDebugPubNames: case eSectionTypeDWARFDebugPubTypes: case eSectionTypeDWARFDebugRanges: diff --git a/lldb/source/Symbol/SymbolVendor.cpp b/lldb/source/Symbol/SymbolVendor.cpp index b361d400f22..b9ec9a1c8a7 100644 --- a/lldb/source/Symbol/SymbolVendor.cpp +++ b/lldb/source/Symbol/SymbolVendor.cpp @@ -186,6 +186,18 @@ SymbolVendor::ParseCompileUnitLineTable (const SymbolContext &sc) } bool +SymbolVendor::ParseCompileUnitDebugMacros (const SymbolContext &sc) +{ + ModuleSP module_sp(GetModule()); + if (module_sp) + { + lldb_private::Mutex::Locker locker(module_sp->GetMutex()); + if (m_sym_file_ap.get()) + return m_sym_file_ap->ParseCompileUnitDebugMacros(sc); + } + return false; +} +bool SymbolVendor::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) { ModuleSP module_sp(GetModule()); diff --git a/lldb/source/Utility/ConvertEnum.cpp b/lldb/source/Utility/ConvertEnum.cpp index ecadc7120c9..3231397a05e 100644 --- a/lldb/source/Utility/ConvertEnum.cpp +++ b/lldb/source/Utility/ConvertEnum.cpp @@ -77,6 +77,8 @@ lldb_private::GetSectionTypeAsCString(lldb::SectionType sect_type) return "dwarf-loc"; case eSectionTypeDWARFDebugMacInfo: return "dwarf-macinfo"; + case eSectionTypeDWARFDebugMacro: + return "dwarf-macro"; case eSectionTypeDWARFDebugPubNames: return "dwarf-pubnames"; case eSectionTypeDWARFDebugPubTypes: |
