[LLDB][Breakpad] Make lldb understand INLINE and INLINE_ORIGIN records in breakpad.

[zequanwu]

Summary

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.

[shafik]

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

318

/*mangled=*/nullptr, /*decl_ptr=*/nullptr

see clang-tidy check bugprone-argument-comment

[zequanwu]

add argument comments.

[labath]

Looks pretty good. I might have split the record parsing functions into a separate patch, but this is not bad either.

Just one comment about error handling.

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

315–316

In lldb, we treat (or at least try to) debug info as "user input", meaning invalid/inconsistent debug info should not crash the debugger. While the situation is not as critical for breakpad as it is for dwarf (due to it not having as many producers), I think the principle remains.

It doesn't really matter much how you handle invalid records (like, it'd be fine if you just throw away all inline info for the affected function), but it'd be nice if it does not crash lldb.

[zequanwu]

Use empty callsite_file or name if index is out of range.

[labath]

In D113330#3119254, @zequanwu wrote:

Use empty callsite_file or name if index is out of range.

It'd be nice if you could also extend the test case to cover this scenario.

[zequanwu]

Rebased and add test cases for out of range file/origin index.

lldb/include/lldb/Symbol/Block.h

public:
   }
 
   bool BlockInfoHasBeenParsed() const { return m_parsed_block_info; }
 
   void SetBlockInfoHasBeenParsed(bool b, bool set_children);
 
   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);
 
   bool GetRangeContainingAddress(const Address &addr, AddressRange &range);
 
   bool GetRangeContainingLoadAddress(lldb::addr_t load_addr, Target &target,
                                      AddressRange &range);

lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h

 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/FormatProviders.h"
 
 namespace lldb_private {
 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
   /// records, but the full parse can still fail in case of corrupted input.
   static llvm::Optional<Kind> classify(llvm::StringRef Line);
 
 protected:
   Record(Kind K) : TheKind(K) {}
public:
   llvm::StringRef Name;
 };
 
 inline bool operator==(const FileRecord &L, const FileRecord &R) {
   return L.Number == R.Number && L.Name == R.Name;
 }
 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);
   FuncRecord(bool Multiple, lldb::addr_t Address, lldb::addr_t Size,
              lldb::addr_t ParamSize, llvm::StringRef Name)
       : Record(Module), Multiple(Multiple), Address(Address), Size(Size),
         ParamSize(ParamSize), Name(Name) {}
 
   bool Multiple;
   lldb::addr_t Address;
   lldb::addr_t Size;
   lldb::addr_t ParamSize;
   llvm::StringRef Name;
 };
 
 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);
   LineRecord(lldb::addr_t Address, lldb::addr_t Size, uint32_t LineNum,
              size_t FileNum)
       : Record(Line), Address(Address), Size(Size), LineNum(LineNum),
         FileNum(FileNum) {}
 

lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp

 namespace {
 enum class Token {
   Unknown,
   Module,
   Info,
   CodeID,
   File,
   Func,
+  Inline,
+  InlineOrigin,
   Public,
   Stack,
   CFI,
   Init,
   Win,
 };
 }
 
 template<typename T>
 static T stringTo(llvm::StringRef Str);
 
 template <> Token stringTo<Token>(llvm::StringRef Str) {
   return llvm::StringSwitch<Token>(Str)
       .Case("MODULE", Token::Module)
       .Case("INFO", Token::Info)
       .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)
       .Case("INIT", Token::Init)
       .Case("WIN", Token::Win)
       .Default(Token::Unknown);
 }
 
case Token::Stack:
     switch (Tok) {
     case Token::CFI:
       return Record::StackCFI;
     case Token::Win:
       return Record::StackWin;
     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
     // hex number.
     return Record::Line;
 
   case Token::CodeID:
   case Token::CFI:
llvm::Optional<InfoRecord> InfoRecord::parse(llvm::StringRef Line) {
   return InfoRecord(std::move(ID));
 }
 
 llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                         const InfoRecord &R) {
   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;
   size_t Number;
   std::tie(Str, Line) = getToken(Line);
   if (!to_integer(Str, Number))
     return llvm::None;
 
   llvm::StringRef Name = Line.trim();
   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,
                                         const FileRecord &R) {
   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) {
   // PUBLIC [m] address param_size name
   // or
   // FUNC [m] address size param_size name
 
   Token Tok = Size ? Token::Func : Token::Public;

 }
 llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
                                         const FuncRecord &R) {
   return OS << llvm::formatv("FUNC {0}{1:x-} {2:x-} {3:x-} {4}",
                              R.Multiple ? "m " : "", R.Address, R.Size,
                              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;
   std::tie(Str, Line) = getToken(Line);
   if (!to_integer(Str, Address, 16))
     return llvm::None;
 
   lldb::addr_t Size;
llvm::StringRef breakpad::toString(Record::Kind K) {
   case Record::Module:
     return "MODULE";
   case Record::Info:
     return "INFO";
   case Record::File:
     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:
     return "PUBLIC";
   case Record::StackCFI:
     return "STACK CFI";
   case Record::StackWin:
     return "STACK WIN";
   }
   llvm_unreachable("Unknown record kind!");
 }

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

auto maybe_add_section = [&](const uint8_t *end_ptr) {
     m_sections_up->AddSection(section_sp);
     unified_section_list.AddSection(section_sp);
   };
   while (!text.empty()) {
     llvm::StringRef line;
     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)
       continue;
 
     // Changing sections, finish off the previous one, if there was any.
     maybe_add_section(line.bytes_begin());
     // And start a new one.
     current_section = next_section;
     section_start = line.bytes_begin() - m_data.GetDataStart();
   }
   // Finally, add the last section.
   maybe_add_section(m_data.GetDataEnd());
 }

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
   size_t ParseTypes(CompileUnit &cu) override { return 0; }
 
   bool ParseImportedModules(
       const SymbolContext &sc,
       std::vector<lldb_private::SourceModule> &imported_modules) override {
     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,
                            uint32_t max_matches,
                            VariableList &variables) override {}
 
   size_t ParseVariablesForContext(const SymbolContext &sc) override {
     return 0;
private:
   llvm::ArrayRef<uint8_t> SaveAsDWARF(postfix::Node &node);
   lldb::UnwindPlanSP ParseCFIUnwindPlan(const Bookmark &bookmark,
                                         const RegisterInfoResolver &resolver);
   bool ParseCFIUnwindRow(llvm::StringRef unwind_rules,
                          const RegisterInfoResolver &resolver,
                          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 {
     UnwindMap cfi;
     UnwindMap win;
   };
   llvm::Optional<UnwindData> m_unwind_data;
   llvm::BumpPtrAllocator m_allocator;
 };
 
 } // namespace breakpad
 } // namespace lldb_private
 
 #endif

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
   FileSpec spec;
 
   // The FileSpec of the compile unit will be the file corresponding to the
   // first LINE record.
   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
       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())
       spec = (*m_files)[record->FileNum];
   }
 
   auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(),
                                              /*user_data*/ nullptr, spec, index,
bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit,
   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
   if (!data.support_files)
     ParseLineTableAndSupportFiles(comp_unit, data);
 
   support_files = std::move(*data.support_files);
   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();
   uint32_t idx =
       m_cu_data->FindEntryIndexThatContains(so_addr.GetFileAddress());
   if (idx == UINT32_MAX)
     return 0;
 
   sc.comp_unit = GetCompileUnitAtIndex(idx).get();
   SymbolContextItem result = eSymbolContextCompUnit;
   if (resolve_scope & eSymbolContextLineEntry) {
     if (sc.comp_unit->GetLineTable()->FindLineEntryByAddress(so_addr,
                                                              sc.line_entry)) {
       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;
+      }
     }
   }
 
   return result;
 }
 
 uint32_t SymbolFileBreakpad::ResolveSymbolContext(
     const SourceLocationSpec &src_location_spec,
auto finish_sequence = [&]() {
     sequences.push_back(std::move(line_seq_up));
     line_seq_up = LineTable::CreateLineSequenceContainer();
   };
 
   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
       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;
 
     record->Address += base;
 
     if (next_addr && *next_addr != record->Address) {
       // Discontiguous entries. Finish off the previous sequence and reset.

lldb/source/Symbol/Block.cpp

Block *Block::FindBlockByID(user_id_t block_id) {
   for (pos = m_children.begin(); pos != end; ++pos) {
     matching_block = (*pos)->FindBlockByID(block_id);
     if (matching_block)
       break;
   }
   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);
   sc->block = this;
 }
 
 lldb::ModuleSP Block::CalculateSymbolContextModule() {
   if (m_parent_scope)

lldb/test/Shell/SymbolFile/Breakpad/Inputs/inline-record.syms

+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

lldb/test/Shell/SymbolFile/Breakpad/inline-record.test

+# 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

lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp

 using namespace lldb_private;
 using namespace lldb_private::breakpad;
 
 TEST(Record, classify) {
   EXPECT_EQ(Record::Module, Record::classify("MODULE"));
   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"));
 
   // Any obviously incorrect lines will be classified as such.
   EXPECT_EQ(llvm::None, Record::classify("STACK"));
   EXPECT_EQ(llvm::None, Record::classify("STACK CODE_ID"));
   EXPECT_EQ(llvm::None, Record::classify("CODE_ID"));
TEST(FuncRecord, parse) {
   EXPECT_EQ(llvm::None, FuncRecord::parse("PUBLIC 47 7 8 foo"));
   EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC 47 7 8"));
   EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC 47 7"));
   EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC 47"));
   EXPECT_EQ(llvm::None, FuncRecord::parse("FUNC m"));
   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"));
   EXPECT_EQ(llvm::None, LineRecord::parse("47 74"));
   EXPECT_EQ(llvm::None, LineRecord::parse("47"));
   EXPECT_EQ(llvm::None, LineRecord::parse(""));
   EXPECT_EQ(llvm::None, LineRecord::parse("FUNC"));
 }