Author: Zequan Wu Date: 2021-11-10T11:20:32-08:00 New Revision: cc9ced0ed4202a4f8a550551bbb14584f93f3055
URL: https://github.com/llvm/llvm-project/commit/cc9ced0ed4202a4f8a550551bbb14584f93f3055 DIFF: https://github.com/llvm/llvm-project/commit/cc9ced0ed4202a4f8a550551bbb14584f93f3055.diff LOG: [LLDB][Breakpad] Make lldb understand INLINE and INLINE_ORIGIN records in breakpad. Teach LLDB to understand INLINE and INLINE_ORIGIN records in breakpad. They have the following formats: ``` INLINE inline_nest_level call_site_line call_site_file_num origin_num [address size]+ INLINE_ORIGIN origin_num name ``` `INLNIE_ORIGIN` is simply a string pool for INLINE so that we won't have duplicated names for inlined functions and can show up anywhere in the symbol file. `INLINE` follows immediately after `FUNC` represents the ranges of momery address that has functions inlined inside the function. Differential Revision: https://reviews.llvm.org/D113330 Added: lldb/test/Shell/SymbolFile/Breakpad/Inputs/inline-record.syms lldb/test/Shell/SymbolFile/Breakpad/inline-record.test Modified: lldb/include/lldb/Symbol/Block.h lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h lldb/source/Symbol/Block.cpp lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp Removed: ################################################################################ diff --git a/lldb/include/lldb/Symbol/Block.h b/lldb/include/lldb/Symbol/Block.h index de94556d3f228..02fd2add53103 100644 --- a/lldb/include/lldb/Symbol/Block.h +++ b/lldb/include/lldb/Symbol/Block.h @@ -338,6 +338,8 @@ class Block : public UserID, public SymbolContextScope { Block *FindBlockByID(lldb::user_id_t block_id); + Block *FindInnermostBlockByOffset(const lldb::addr_t offset); + size_t GetNumRanges() const { return m_ranges.GetSize(); } bool GetRangeContainingOffset(const lldb::addr_t offset, Range &range); diff --git a/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp b/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp index bd8eeedce57d4..24941be515de0 100644 --- a/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp +++ b/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp @@ -23,6 +23,8 @@ enum class Token { CodeID, File, Func, + Inline, + InlineOrigin, Public, Stack, CFI, @@ -41,6 +43,8 @@ template <> Token stringTo<Token>(llvm::StringRef Str) { .Case("CODE_ID", Token::CodeID) .Case("FILE", Token::File) .Case("FUNC", Token::Func) + .Case("INLINE", Token::Inline) + .Case("INLINE_ORIGIN", Token::InlineOrigin) .Case("PUBLIC", Token::Public) .Case("STACK", Token::Stack) .Case("CFI", Token::CFI) @@ -145,7 +149,10 @@ llvm::Optional<Record::Kind> Record::classify(llvm::StringRef Line) { default: return llvm::None; } - + case Token::Inline: + return Record::Inline; + case Token::InlineOrigin: + return Record::InlineOrigin; case Token::Unknown: // Optimistically assume that any unrecognised token means this is a line // record, those don't have a special keyword and start directly with a @@ -216,9 +223,11 @@ llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS, return OS << "INFO CODE_ID " << R.ID.GetAsString(); } -llvm::Optional<FileRecord> FileRecord::parse(llvm::StringRef Line) { - // FILE number name - if (consume<Token>(Line) != Token::File) +template <typename T> +static llvm::Optional<T> parseNumberName(llvm::StringRef Line, + Token TokenType) { + // TOKEN number name + if (consume<Token>(Line) != TokenType) return llvm::None; llvm::StringRef Str; @@ -231,7 +240,12 @@ llvm::Optional<FileRecord> FileRecord::parse(llvm::StringRef Line) { if (Name.empty()) return llvm::None; - return FileRecord(Number, Name); + return T(Number, Name); +} + +llvm::Optional<FileRecord> FileRecord::parse(llvm::StringRef Line) { + // FILE number name + return parseNumberName<FileRecord>(Line, Token::File); } llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS, @@ -239,6 +253,17 @@ llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS, return OS << "FILE " << R.Number << " " << R.Name; } +llvm::Optional<InlineOriginRecord> +InlineOriginRecord::parse(llvm::StringRef Line) { + // INLINE_ORIGIN number name + return parseNumberName<InlineOriginRecord>(Line, Token::InlineOrigin); +} + +llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS, + const InlineOriginRecord &R) { + return OS << "INLINE_ORIGIN " << R.Number << " " << R.Name; +} + static bool parsePublicOrFunc(llvm::StringRef Line, bool &Multiple, lldb::addr_t &Address, lldb::addr_t *Size, lldb::addr_t &ParamSize, llvm::StringRef &Name) { @@ -299,6 +324,58 @@ llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS, R.ParamSize, R.Name); } +llvm::Optional<InlineRecord> InlineRecord::parse(llvm::StringRef Line) { + // INLINE inline_nest_level call_site_line call_site_file_num origin_num + // [address size]+ + if (consume<Token>(Line) != Token::Inline) + return llvm::None; + + llvm::SmallVector<llvm::StringRef> Tokens; + SplitString(Line, Tokens, " "); + if (Tokens.size() < 6 || Tokens.size() % 2 == 1) + return llvm::None; + + size_t InlineNestLevel; + uint32_t CallSiteLineNum; + size_t CallSiteFileNum; + size_t OriginNum; + if (!(to_integer(Tokens[0], InlineNestLevel) && + to_integer(Tokens[1], CallSiteLineNum) && + to_integer(Tokens[2], CallSiteFileNum) && + to_integer(Tokens[3], OriginNum))) + return llvm::None; + + InlineRecord Record = InlineRecord(InlineNestLevel, CallSiteLineNum, + CallSiteFileNum, OriginNum); + for (size_t i = 4; i < Tokens.size(); i += 2) { + lldb::addr_t Address; + if (!to_integer(Tokens[i], Address, 16)) + return llvm::None; + lldb::addr_t Size; + if (!to_integer(Tokens[i + 1].trim(), Size, 16)) + return llvm::None; + Record.Ranges.emplace_back(Address, Size); + } + return Record; +} + +bool breakpad::operator==(const InlineRecord &L, const InlineRecord &R) { + return L.InlineNestLevel == R.InlineNestLevel && + L.CallSiteLineNum == R.CallSiteLineNum && + L.CallSiteFileNum == R.CallSiteFileNum && L.OriginNum == R.OriginNum && + L.Ranges == R.Ranges; +} + +llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS, + const InlineRecord &R) { + OS << llvm::formatv("INLINE {0} {1} {2} {3}", R.InlineNestLevel, + R.CallSiteLineNum, R.CallSiteFileNum, R.OriginNum); + for (const auto &range : R.Ranges) { + OS << llvm::formatv(" {0:x-} {1:x-}", range.first, range.second); + } + return OS; +} + llvm::Optional<LineRecord> LineRecord::parse(llvm::StringRef Line) { lldb::addr_t Address; llvm::StringRef Str; @@ -490,6 +567,10 @@ llvm::StringRef breakpad::toString(Record::Kind K) { return "FILE"; case Record::Func: return "FUNC"; + case Record::Inline: + return "INLINE"; + case Record::InlineOrigin: + return "INLINE_ORIGIN"; case Record::Line: return "LINE"; case Record::Public: diff --git a/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h b/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h index 1620a1210b840..8a11323d521c0 100644 --- a/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h +++ b/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h @@ -20,7 +20,18 @@ namespace breakpad { class Record { public: - enum Kind { Module, Info, File, Func, Line, Public, StackCFI, StackWin }; + enum Kind { + Module, + Info, + File, + Func, + Inline, + InlineOrigin, + Line, + Public, + StackCFI, + StackWin + }; /// Attempt to guess the kind of the record present in the argument without /// doing a full parse. The returned kind will always be correct for valid @@ -89,6 +100,23 @@ inline bool operator==(const FileRecord &L, const FileRecord &R) { } llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const FileRecord &R); +class InlineOriginRecord : public Record { +public: + static llvm::Optional<InlineOriginRecord> parse(llvm::StringRef Line); + InlineOriginRecord(size_t Number, llvm::StringRef Name) + : Record(InlineOrigin), Number(Number), Name(Name) {} + + size_t Number; + llvm::StringRef Name; +}; + +inline bool operator==(const InlineOriginRecord &L, + const InlineOriginRecord &R) { + return L.Number == R.Number && L.Name == R.Name; +} +llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, + const InlineOriginRecord &R); + class FuncRecord : public Record { public: static llvm::Optional<FuncRecord> parse(llvm::StringRef Line); @@ -107,6 +135,26 @@ class FuncRecord : public Record { bool operator==(const FuncRecord &L, const FuncRecord &R); llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const FuncRecord &R); +class InlineRecord : public Record { +public: + static llvm::Optional<InlineRecord> parse(llvm::StringRef Line); + InlineRecord(size_t InlineNestLevel, uint32_t CallSiteLineNum, + size_t CallSiteFileNum, size_t OriginNum) + : Record(Inline), InlineNestLevel(InlineNestLevel), + CallSiteLineNum(CallSiteLineNum), CallSiteFileNum(CallSiteFileNum), + OriginNum(OriginNum) {} + + size_t InlineNestLevel; + uint32_t CallSiteLineNum; + size_t CallSiteFileNum; + size_t OriginNum; + // A vector of address range covered by this inline + std::vector<std::pair<lldb::addr_t, lldb::addr_t>> Ranges; +}; + +bool operator==(const InlineRecord &L, const InlineRecord &R); +llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const InlineRecord &R); + class LineRecord : public Record { public: static llvm::Optional<LineRecord> parse(llvm::StringRef Line); diff --git a/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp b/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp index f24d7c2fdd551..bad730512ff49 100644 --- a/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp +++ b/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp @@ -148,9 +148,9 @@ void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) { std::tie(line, text) = text.split('\n'); llvm::Optional<Record::Kind> next_section = Record::classify(line); - if (next_section == Record::Line) { - // Line records logically belong to the preceding Func record, so we put - // them in the same section. + if (next_section == Record::Line || next_section == Record::Inline) { + // Line/Inline records logically belong to the preceding Func record, so + // we put them in the same section. next_section = Record::Func; } if (next_section == current_section) diff --git a/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp b/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp index 3795147668c88..b07674af3bd9f 100644 --- a/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp +++ b/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp @@ -204,6 +204,10 @@ CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) { End(*m_objfile_sp); assert(Record::classify(*It) == Record::Func); ++It; // Skip FUNC record. + // Skip INLINE records. + while (It != End && Record::classify(*It) == Record::Inline) + ++It; + if (It != End) { auto record = LineRecord::parse(*It); if (record && record->FileNum < m_files->size()) @@ -282,13 +286,88 @@ bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit, return true; } +size_t SymbolFileBreakpad::ParseBlocksRecursive(Function &func) { + std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); + CompileUnit *comp_unit = func.GetCompileUnit(); + lldbassert(comp_unit); + ParseInlineOriginRecords(); + // A vector of current each level's parent block. For example, when parsing + // "INLINE 0 ...", the current level is 0 and its parent block is the + // funciton block at index 0. + std::vector<Block *> blocks; + Block &block = func.GetBlock(false); + block.AddRange(Block::Range(0, func.GetAddressRange().GetByteSize())); + blocks.push_back(&block); + + size_t blocks_added = 0; + addr_t func_base = func.GetAddressRange().GetBaseAddress().GetOffset(); + CompUnitData &data = m_cu_data->GetEntryRef(comp_unit->GetID()).data; + LineIterator It(*m_objfile_sp, Record::Func, data.bookmark), + End(*m_objfile_sp); + ++It; // Skip the FUNC record. + size_t last_added_nest_level = 0; + while (It != End && Record::classify(*It) == Record::Inline) { + if (auto record = InlineRecord::parse(*It)) { + if (record->InlineNestLevel == 0 || + record->InlineNestLevel <= last_added_nest_level + 1) { + last_added_nest_level = record->InlineNestLevel; + BlockSP block_sp = std::make_shared<Block>(It.GetBookmark().offset); + FileSpec callsite_file; + if (record->CallSiteFileNum < m_files->size()) + callsite_file = (*m_files)[record->CallSiteFileNum]; + llvm::StringRef name; + if (record->OriginNum < m_inline_origins->size()) + name = (*m_inline_origins)[record->OriginNum]; + + Declaration callsite(callsite_file, record->CallSiteLineNum); + block_sp->SetInlinedFunctionInfo(name.str().c_str(), + /*mangled=*/nullptr, + /*decl_ptr=*/nullptr, &callsite); + for (const auto &range : record->Ranges) { + block_sp->AddRange( + Block::Range(range.first - func_base, range.second)); + } + block_sp->FinalizeRanges(); + + blocks[record->InlineNestLevel]->AddChild(block_sp); + if (record->InlineNestLevel + 1 >= blocks.size()) { + blocks.resize(blocks.size() + 1); + } + blocks[record->InlineNestLevel + 1] = block_sp.get(); + ++blocks_added; + } + } + ++It; + } + return blocks_added; +} + +void SymbolFileBreakpad::ParseInlineOriginRecords() { + if (m_inline_origins) + return; + m_inline_origins.emplace(); + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); + for (llvm::StringRef line : lines(Record::InlineOrigin)) { + auto record = InlineOriginRecord::parse(line); + if (!record) { + LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line); + continue; + } + + if (record->Number >= m_inline_origins->size()) + m_inline_origins->resize(record->Number + 1); + (*m_inline_origins)[record->Number] = record->Name; + } +} + uint32_t SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr, SymbolContextItem resolve_scope, SymbolContext &sc) { std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); if (!(resolve_scope & (eSymbolContextCompUnit | eSymbolContextLineEntry | - eSymbolContextFunction))) + eSymbolContextFunction | eSymbolContextBlock))) return 0; ParseCUData(); @@ -305,11 +384,20 @@ SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr, result |= eSymbolContextLineEntry; } } - if (resolve_scope & eSymbolContextFunction) { + + if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) { FunctionSP func_sp = GetOrCreateFunction(*sc.comp_unit); if (func_sp) { sc.function = func_sp.get(); result |= eSymbolContextFunction; + if (resolve_scope & eSymbolContextBlock) { + Block &block = func_sp->GetBlock(true); + sc.block = block.FindInnermostBlockByOffset( + so_addr.GetFileAddress() - + sc.function->GetAddressRange().GetBaseAddress().GetFileAddress()); + if (sc.block) + result |= eSymbolContextBlock; + } } } @@ -774,6 +862,10 @@ void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu, End(*m_objfile_sp); assert(Record::classify(*It) == Record::Func); for (++It; It != End; ++It) { + // Skip INLINE records + if (Record::classify(*It) == Record::Inline) + continue; + auto record = LineRecord::parse(*It); if (!record) break; diff --git a/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h b/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h index 9ade484dc7090..bf3e25c1a63ed 100644 --- a/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h +++ b/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h @@ -81,7 +81,7 @@ class SymbolFileBreakpad : public SymbolFile { return false; } - size_t ParseBlocksRecursive(Function &func) override { return 0; } + size_t ParseBlocksRecursive(Function &func) override; void FindGlobalVariables(ConstString name, const CompilerDeclContext &parent_decl_ctx, @@ -223,11 +223,13 @@ class SymbolFileBreakpad : public SymbolFile { UnwindPlan::Row &row); lldb::UnwindPlanSP ParseWinUnwindPlan(const Bookmark &bookmark, const RegisterInfoResolver &resolver); + void ParseInlineOriginRecords(); using CompUnitMap = RangeDataVector<lldb::addr_t, lldb::addr_t, CompUnitData>; llvm::Optional<std::vector<FileSpec>> m_files; llvm::Optional<CompUnitMap> m_cu_data; + llvm::Optional<std::vector<llvm::StringRef>> m_inline_origins; using UnwindMap = RangeDataVector<lldb::addr_t, lldb::addr_t, Bookmark>; struct UnwindData { diff --git a/lldb/source/Symbol/Block.cpp b/lldb/source/Symbol/Block.cpp index fc246ac8575d4..4aafef34bd2de 100644 --- a/lldb/source/Symbol/Block.cpp +++ b/lldb/source/Symbol/Block.cpp @@ -122,6 +122,16 @@ Block *Block::FindBlockByID(user_id_t block_id) { return matching_block; } +Block *Block::FindInnermostBlockByOffset(const lldb::addr_t offset) { + if (!Contains(offset)) + return nullptr; + for (const BlockSP &block_sp : m_children) { + if (Block *block = block_sp->FindInnermostBlockByOffset(offset)) + return block; + } + return this; +} + void Block::CalculateSymbolContext(SymbolContext *sc) { if (m_parent_scope) m_parent_scope->CalculateSymbolContext(sc); diff --git a/lldb/test/Shell/SymbolFile/Breakpad/Inputs/inline-record.syms b/lldb/test/Shell/SymbolFile/Breakpad/Inputs/inline-record.syms new file mode 100644 index 0000000000000..2ba5a092c3e3c --- /dev/null +++ b/lldb/test/Shell/SymbolFile/Breakpad/Inputs/inline-record.syms @@ -0,0 +1,17 @@ +MODULE Linux x86_64 761550E08086333960A9074A9CE2895C0 a.out +INFO CODE_ID E05015768680393360A9074A9CE2895C +FILE 0 /tmp/a.c +FILE 1 /tmp/b.c +INLINE_ORIGIN 0 inlined_f1 +INLINE_ORIGIN 1 inlined_f2 +FUNC 10 10 0 f1 +INLINE 0 8 0 0 10 5 17 4 +10 10 3 0 +FUNC 20 10 0 f2 +INLINE 0 3 0 0 23 a +INLINE 1 4 1 1 23 5 +20 10 2 1 +FUNC 30 10 0 f3 +INLINE 0 3 999 0 30 5 +INLINE 0 3 0 999 35 5 +30 10 3 1 diff --git a/lldb/test/Shell/SymbolFile/Breakpad/inline-record.test b/lldb/test/Shell/SymbolFile/Breakpad/inline-record.test new file mode 100644 index 0000000000000..ebf777657f883 --- /dev/null +++ b/lldb/test/Shell/SymbolFile/Breakpad/inline-record.test @@ -0,0 +1,56 @@ +# RUN: yaml2obj %S/Inputs/basic-elf.yaml -o %T/inline-record.out +# RUN: %lldb %T/inline-record.out -o "target symbols add -s inline-record.out %S/Inputs/inline-record.syms" \ +# RUN: -s %s | FileCheck --match-full-lines %s + +# CHECK-LABEL: (lldb) image lookup -a 0x400010 -v +# CHECK: Summary: inline-record.out`f1 [inlined] inlined_f1 at a.c:3 +# CHECK-NEXT: inline-record.out`f1 at a.c:8 +# CHECK: Function: id = {0x00000000}, name = "f1", range = [0x0000000000400010-0x0000000000400020) +# CHECK-NEXT: Blocks: id = {0x00000000}, range = [0x00400010-0x00400020) +# CHECK-NEXT: id = {0x00000010}, ranges = [0x00400010-0x00400015)[0x00400017-0x0040001b), name = "inlined_f1" + +# CHECK-LABEL: (lldb) image lookup -a 0x400016 -v +# CHECK: Summary: inline-record.out`f1 + 6 at a.c:3 +# CHECK-NOT: inline-record.out`f1 +# CHECK: Function: id = {0x00000000}, name = "f1", range = [0x0000000000400010-0x0000000000400020) +# CHECK-NEXT: Blocks: id = {0x00000000}, range = [0x00400010-0x00400020) + +# CHECK-LABEL: (lldb) image lookup -a 0x400023 -v +# CHECK: Summary: inline-record.out`f2 + 3 [inlined] inlined_f2 at b.c:2 +# CHECK-NEXT: inline-record.out`f2 + 3 [inlined] inlined_f1 at b.c:4 +# CHECK-NEXT: inline-record.out`f2 + 3 at a.c:3 +# CHECK: Function: id = {0x00000001}, name = "f2", range = [0x0000000000400020-0x0000000000400030) +# CHECK-NEXT: Blocks: id = {0x00000001}, range = [0x00400020-0x00400030) +# CHECK-NEXT: id = {0x00000043}, range = [0x00400023-0x0040002d), name = "inlined_f1" +# CHECK-NEXT: id = {0x00000057}, range = [0x00400023-0x00400028), name = "inlined_f2" + +# CHECK-LABEL: (lldb) image lookup -a 0x400029 -v +# CHECK: Summary: inline-record.out`f2 + 9 [inlined] inlined_f1 + 6 at b.c:2 +# CHECK-NEXT: inline-record.out`f2 + 3 at a.c:3 +# CHECK: Function: id = {0x00000001}, name = "f2", range = [0x0000000000400020-0x0000000000400030) +# CHECK-NEXT: Blocks: id = {0x00000001}, range = [0x00400020-0x00400030) +# CHECK-NEXT: id = {0x00000043}, range = [0x00400023-0x0040002d), name = "inlined_f1" + +# CHECK-LABEL: (lldb) image lookup -a 0x400030 -v +# CHECK: Summary: inline-record.out`f3 [inlined] inlined_f1 at b.c:3 +# CHECK-NEXT: inline-record.out`f3 at 3 +# CHECK: Function: id = {0x00000002}, name = "f3", range = [0x0000000000400030-0x0000000000400040) +# CHECK-NEXT: Blocks: id = {0x00000002}, range = [0x00400030-0x00400040) +# CHECK-NEXT: id = {0x00000085}, range = [0x00400030-0x00400035), name = "inlined_f1" + + +# CHECK-LABEL: (lldb) image lookup -a 0x400035 -v +# CHECK: Summary: inline-record.out`f3 + 5 [inlined] at b.c:3 +# CHECK-NEXT: inline-record.out`f3 + 5 at a.c:3 +# CHECK: Function: id = {0x00000002}, name = "f3", range = [0x0000000000400030-0x0000000000400040) +# CHECK-NEXT: Blocks: id = {0x00000002}, range = [0x00400030-0x00400040) +# CHECK-NEXT: id = {0x0000009b}, range = [0x00400035-0x0040003a) + +image lookup -a 0x400010 -v +image lookup -a 0x400016 -v +image lookup -a 0x400023 -v +image lookup -a 0x400029 -v +# Folling addresses are inside INLINE records that have file index or origin index out of range. +image lookup -a 0x400030 -v +image lookup -a 0x400035 -v +exit diff --git a/lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp b/lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp index b621ad233e6a6..66f2b86331925 100644 --- a/lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp +++ b/lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp @@ -18,6 +18,8 @@ TEST(Record, classify) { EXPECT_EQ(Record::Info, Record::classify("INFO")); EXPECT_EQ(Record::File, Record::classify("FILE")); EXPECT_EQ(Record::Func, Record::classify("FUNC")); + EXPECT_EQ(Record::Inline, Record::classify("INLINE")); + EXPECT_EQ(Record::InlineOrigin, Record::classify("INLINE_ORIGIN")); EXPECT_EQ(Record::Public, Record::classify("PUBLIC")); EXPECT_EQ(Record::StackCFI, Record::classify("STACK CFI")); EXPECT_EQ(Record::StackWin, Record::classify("STACK WIN")); @@ -76,6 +78,27 @@ TEST(FuncRecord, parse) { EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC")); } +TEST(InlineOriginRecord, parse) { + EXPECT_EQ(InlineOriginRecord(47, "foo"), + InlineOriginRecord::parse("INLINE_ORIGIN 47 foo")); + EXPECT_EQ(llvm::None, InlineOriginRecord::parse("INLINE_ORIGIN 47")); + EXPECT_EQ(llvm::None, InlineOriginRecord::parse("INLINE_ORIGIN")); + EXPECT_EQ(llvm::None, InlineOriginRecord::parse("")); +} + +TEST(InlineRecord, parse) { + InlineRecord record1 = InlineRecord(0, 1, 2, 3); + record1.Ranges.emplace_back(4, 5); + EXPECT_EQ(record1, InlineRecord::parse("INLINE 0 1 2 3 4 5")); + record1.Ranges.emplace_back(6, 7); + EXPECT_EQ(record1, InlineRecord::parse("INLINE 0 1 2 3 4 5 6 7")); + EXPECT_EQ(llvm::None, InlineRecord::parse("INLINE 0 1 2 3")); + EXPECT_EQ(llvm::None, InlineRecord::parse("INLINE 0 1 2 3 4 5 6")); + EXPECT_EQ(llvm::None, InlineRecord::parse("INLNIE 0")); + EXPECT_EQ(llvm::None, InlineRecord::parse("")); + EXPECT_EQ(llvm::None, InlineRecord::parse("FUNC")); +} + TEST(LineRecord, parse) { EXPECT_EQ(LineRecord(0x47, 0x74, 47, 74), LineRecord::parse("47 74 47 74")); EXPECT_EQ(llvm::None, LineRecord::parse("47 74 47")); _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
