1 //===-- SymbolFileBreakpad.cpp ----------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h"
10 #include "Plugins/ObjectFile/Breakpad/BreakpadRecords.h"
11 #include "Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Core/Section.h"
15 #include "lldb/Host/FileSystem.h"
16 #include "lldb/Symbol/CompileUnit.h"
17 #include "lldb/Symbol/ObjectFile.h"
18 #include "lldb/Symbol/PostfixExpression.h"
19 #include "lldb/Symbol/SymbolVendor.h"
20 #include "lldb/Symbol/TypeMap.h"
21 #include "lldb/Utility/Log.h"
22 #include "lldb/Utility/StreamString.h"
23 #include "llvm/ADT/StringExtras.h"
24 
25 using namespace lldb;
26 using namespace lldb_private;
27 using namespace lldb_private::breakpad;
28 
29 class SymbolFileBreakpad::LineIterator {
30 public:
31   // begin iterator for sections of given type
32   LineIterator(ObjectFile &obj, Record::Kind section_type)
33       : m_obj(&obj), m_section_type(toString(section_type)),
34         m_next_section_idx(0), m_next_line(llvm::StringRef::npos) {
35     ++*this;
36   }
37 
38   // An iterator starting at the position given by the bookmark.
39   LineIterator(ObjectFile &obj, Record::Kind section_type, Bookmark bookmark);
40 
41   // end iterator
42   explicit LineIterator(ObjectFile &obj)
43       : m_obj(&obj),
44         m_next_section_idx(m_obj->GetSectionList()->GetNumSections(0)),
45         m_current_line(llvm::StringRef::npos),
46         m_next_line(llvm::StringRef::npos) {}
47 
48   friend bool operator!=(const LineIterator &lhs, const LineIterator &rhs) {
49     assert(lhs.m_obj == rhs.m_obj);
50     if (lhs.m_next_section_idx != rhs.m_next_section_idx)
51       return true;
52     if (lhs.m_current_line != rhs.m_current_line)
53       return true;
54     assert(lhs.m_next_line == rhs.m_next_line);
55     return false;
56   }
57 
58   const LineIterator &operator++();
59   llvm::StringRef operator*() const {
60     return m_section_text.slice(m_current_line, m_next_line);
61   }
62 
63   Bookmark GetBookmark() const {
64     return Bookmark{m_next_section_idx, m_current_line};
65   }
66 
67 private:
68   ObjectFile *m_obj;
69   ConstString m_section_type;
70   uint32_t m_next_section_idx;
71   llvm::StringRef m_section_text;
72   size_t m_current_line;
73   size_t m_next_line;
74 
75   void FindNextLine() {
76     m_next_line = m_section_text.find('\n', m_current_line);
77     if (m_next_line != llvm::StringRef::npos) {
78       ++m_next_line;
79       if (m_next_line >= m_section_text.size())
80         m_next_line = llvm::StringRef::npos;
81     }
82   }
83 };
84 
85 SymbolFileBreakpad::LineIterator::LineIterator(ObjectFile &obj,
86                                                Record::Kind section_type,
87                                                Bookmark bookmark)
88     : m_obj(&obj), m_section_type(toString(section_type)),
89       m_next_section_idx(bookmark.section), m_current_line(bookmark.offset) {
90   Section &sect =
91       *obj.GetSectionList()->GetSectionAtIndex(m_next_section_idx - 1);
92   assert(sect.GetName() == m_section_type);
93 
94   DataExtractor data;
95   obj.ReadSectionData(&sect, data);
96   m_section_text = toStringRef(data.GetData());
97 
98   assert(m_current_line < m_section_text.size());
99   FindNextLine();
100 }
101 
102 const SymbolFileBreakpad::LineIterator &
103 SymbolFileBreakpad::LineIterator::operator++() {
104   const SectionList &list = *m_obj->GetSectionList();
105   size_t num_sections = list.GetNumSections(0);
106   while (m_next_line != llvm::StringRef::npos ||
107          m_next_section_idx < num_sections) {
108     if (m_next_line != llvm::StringRef::npos) {
109       m_current_line = m_next_line;
110       FindNextLine();
111       return *this;
112     }
113 
114     Section &sect = *list.GetSectionAtIndex(m_next_section_idx++);
115     if (sect.GetName() != m_section_type)
116       continue;
117     DataExtractor data;
118     m_obj->ReadSectionData(&sect, data);
119     m_section_text = toStringRef(data.GetData());
120     m_next_line = 0;
121   }
122   // We've reached the end.
123   m_current_line = m_next_line;
124   return *this;
125 }
126 
127 llvm::iterator_range<SymbolFileBreakpad::LineIterator>
128 SymbolFileBreakpad::lines(Record::Kind section_type) {
129   return llvm::make_range(LineIterator(*m_obj_file, section_type),
130                           LineIterator(*m_obj_file));
131 }
132 
133 namespace {
134 // A helper class for constructing the list of support files for a given compile
135 // unit.
136 class SupportFileMap {
137 public:
138   // Given a breakpad file ID, return a file ID to be used in the support files
139   // for this compile unit.
140   size_t operator[](size_t file) {
141     return m_map.try_emplace(file, m_map.size() + 1).first->second;
142   }
143 
144   // Construct a FileSpecList containing only the support files relevant for
145   // this compile unit (in the correct order).
146   FileSpecList translate(const FileSpec &cu_spec,
147                          llvm::ArrayRef<FileSpec> all_files);
148 
149 private:
150   llvm::DenseMap<size_t, size_t> m_map;
151 };
152 } // namespace
153 
154 FileSpecList SupportFileMap::translate(const FileSpec &cu_spec,
155                                        llvm::ArrayRef<FileSpec> all_files) {
156   std::vector<FileSpec> result;
157   result.resize(m_map.size() + 1);
158   result[0] = cu_spec;
159   for (const auto &KV : m_map) {
160     if (KV.first < all_files.size())
161       result[KV.second] = all_files[KV.first];
162   }
163   return FileSpecList(std::move(result));
164 }
165 
166 void SymbolFileBreakpad::Initialize() {
167   PluginManager::RegisterPlugin(GetPluginNameStatic(),
168                                 GetPluginDescriptionStatic(), CreateInstance,
169                                 DebuggerInitialize);
170 }
171 
172 void SymbolFileBreakpad::Terminate() {
173   PluginManager::UnregisterPlugin(CreateInstance);
174 }
175 
176 ConstString SymbolFileBreakpad::GetPluginNameStatic() {
177   static ConstString g_name("breakpad");
178   return g_name;
179 }
180 
181 uint32_t SymbolFileBreakpad::CalculateAbilities() {
182   if (!m_obj_file)
183     return 0;
184   if (m_obj_file->GetPluginName() != ObjectFileBreakpad::GetPluginNameStatic())
185     return 0;
186 
187   return CompileUnits | Functions | LineTables;
188 }
189 
190 uint32_t SymbolFileBreakpad::CalculateNumCompileUnits() {
191   ParseCUData();
192   return m_cu_data->GetSize();
193 }
194 
195 CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
196   if (index >= m_cu_data->GetSize())
197     return nullptr;
198 
199   CompUnitData &data = m_cu_data->GetEntryRef(index).data;
200 
201   ParseFileRecords();
202 
203   FileSpec spec;
204 
205   // The FileSpec of the compile unit will be the file corresponding to the
206   // first LINE record.
207   LineIterator It(*m_obj_file, Record::Func, data.bookmark), End(*m_obj_file);
208   assert(Record::classify(*It) == Record::Func);
209   ++It; // Skip FUNC record.
210   if (It != End) {
211     auto record = LineRecord::parse(*It);
212     if (record && record->FileNum < m_files->size())
213       spec = (*m_files)[record->FileNum];
214   }
215 
216   auto cu_sp = std::make_shared<CompileUnit>(m_obj_file->GetModule(),
217                                              /*user_data*/ nullptr, spec, index,
218                                              eLanguageTypeUnknown,
219                                              /*is_optimized*/ eLazyBoolNo);
220 
221   SetCompileUnitAtIndex(index, cu_sp);
222   return cu_sp;
223 }
224 
225 size_t SymbolFileBreakpad::ParseFunctions(CompileUnit &comp_unit) {
226   // TODO
227   return 0;
228 }
229 
230 bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) {
231   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
232   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
233 
234   if (!data.line_table_up)
235     ParseLineTableAndSupportFiles(comp_unit, data);
236 
237   comp_unit.SetLineTable(data.line_table_up.release());
238   return true;
239 }
240 
241 bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit,
242                                            FileSpecList &support_files) {
243   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
244   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
245   if (!data.support_files)
246     ParseLineTableAndSupportFiles(comp_unit, data);
247 
248   support_files = std::move(*data.support_files);
249   return true;
250 }
251 
252 uint32_t
253 SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
254                                          SymbolContextItem resolve_scope,
255                                          SymbolContext &sc) {
256   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
257   if (!(resolve_scope & (eSymbolContextCompUnit | eSymbolContextLineEntry)))
258     return 0;
259 
260   ParseCUData();
261   uint32_t idx =
262       m_cu_data->FindEntryIndexThatContains(so_addr.GetFileAddress());
263   if (idx == UINT32_MAX)
264     return 0;
265 
266   sc.comp_unit = GetCompileUnitAtIndex(idx).get();
267   SymbolContextItem result = eSymbolContextCompUnit;
268   if (resolve_scope & eSymbolContextLineEntry) {
269     if (sc.comp_unit->GetLineTable()->FindLineEntryByAddress(so_addr,
270                                                              sc.line_entry)) {
271       result |= eSymbolContextLineEntry;
272     }
273   }
274 
275   return result;
276 }
277 
278 uint32_t SymbolFileBreakpad::ResolveSymbolContext(
279     const FileSpec &file_spec, uint32_t line, bool check_inlines,
280     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
281   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
282   if (!(resolve_scope & eSymbolContextCompUnit))
283     return 0;
284 
285   uint32_t old_size = sc_list.GetSize();
286   for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
287     CompileUnit &cu = *GetCompileUnitAtIndex(i);
288     cu.ResolveSymbolContext(file_spec, line, check_inlines,
289                             /*exact*/ false, resolve_scope, sc_list);
290   }
291   return sc_list.GetSize() - old_size;
292 }
293 
294 uint32_t SymbolFileBreakpad::FindFunctions(
295     ConstString name, const CompilerDeclContext *parent_decl_ctx,
296     FunctionNameType name_type_mask, bool include_inlines, bool append,
297     SymbolContextList &sc_list) {
298   // TODO
299   if (!append)
300     sc_list.Clear();
301   return sc_list.GetSize();
302 }
303 
304 uint32_t SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
305                                            bool include_inlines, bool append,
306                                            SymbolContextList &sc_list) {
307   // TODO
308   if (!append)
309     sc_list.Clear();
310   return sc_list.GetSize();
311 }
312 
313 uint32_t SymbolFileBreakpad::FindTypes(
314     ConstString name, const CompilerDeclContext *parent_decl_ctx,
315     bool append, uint32_t max_matches,
316     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
317   if (!append)
318     types.Clear();
319   return types.GetSize();
320 }
321 
322 size_t
323 SymbolFileBreakpad::FindTypes(const std::vector<CompilerContext> &context,
324                               bool append, TypeMap &types) {
325   if (!append)
326     types.Clear();
327   return types.GetSize();
328 }
329 
330 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
331   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
332   Module &module = *m_obj_file->GetModule();
333   addr_t base = GetBaseFileAddress();
334   if (base == LLDB_INVALID_ADDRESS) {
335     LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping "
336                   "symtab population.");
337     return;
338   }
339 
340   const SectionList &list = *module.GetSectionList();
341   llvm::DenseMap<addr_t, Symbol> symbols;
342   auto add_symbol = [&](addr_t address, llvm::Optional<addr_t> size,
343                         llvm::StringRef name) {
344     address += base;
345     SectionSP section_sp = list.FindSectionContainingFileAddress(address);
346     if (!section_sp) {
347       LLDB_LOG(log,
348                "Ignoring symbol {0}, whose address ({1}) is outside of the "
349                "object file. Mismatched symbol file?",
350                name, address);
351       return;
352     }
353     symbols.try_emplace(
354         address, /*symID*/ 0, Mangled(name, /*is_mangled*/ false),
355         eSymbolTypeCode, /*is_global*/ true, /*is_debug*/ false,
356         /*is_trampoline*/ false, /*is_artificial*/ false,
357         AddressRange(section_sp, address - section_sp->GetFileAddress(),
358                      size.getValueOr(0)),
359         size.hasValue(), /*contains_linker_annotations*/ false, /*flags*/ 0);
360   };
361 
362   for (llvm::StringRef line : lines(Record::Func)) {
363     if (auto record = FuncRecord::parse(line))
364       add_symbol(record->Address, record->Size, record->Name);
365   }
366 
367   for (llvm::StringRef line : lines(Record::Public)) {
368     if (auto record = PublicRecord::parse(line))
369       add_symbol(record->Address, llvm::None, record->Name);
370     else
371       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line);
372   }
373 
374   for (auto &KV : symbols)
375     symtab.AddSymbol(std::move(KV.second));
376   symtab.CalculateSymbolSizes();
377 }
378 
379 static llvm::Optional<std::pair<llvm::StringRef, llvm::StringRef>>
380 GetRule(llvm::StringRef &unwind_rules) {
381   // Unwind rules are of the form
382   //   register1: expression1 register2: expression2 ...
383   // We assume none of the tokens in expression<n> end with a colon.
384 
385   llvm::StringRef lhs, rest;
386   std::tie(lhs, rest) = getToken(unwind_rules);
387   if (!lhs.consume_back(":"))
388     return llvm::None;
389 
390   // Seek forward to the next register: expression pair
391   llvm::StringRef::size_type pos = rest.find(": ");
392   if (pos == llvm::StringRef::npos) {
393     // No pair found, this means the rest of the string is a single expression.
394     unwind_rules = llvm::StringRef();
395     return std::make_pair(lhs, rest);
396   }
397 
398   // Go back one token to find the end of the current rule.
399   pos = rest.rfind(' ', pos);
400   if (pos == llvm::StringRef::npos)
401     return llvm::None;
402 
403   llvm::StringRef rhs = rest.take_front(pos);
404   unwind_rules = rest.drop_front(pos);
405   return std::make_pair(lhs, rhs);
406 }
407 
408 static const RegisterInfo *
409 ResolveRegister(const SymbolFile::RegisterInfoResolver &resolver,
410                 llvm::StringRef name) {
411   if (name.consume_front("$"))
412     return resolver.ResolveName(name);
413 
414   return nullptr;
415 }
416 
417 static const RegisterInfo *
418 ResolveRegisterOrRA(const SymbolFile::RegisterInfoResolver &resolver,
419                     llvm::StringRef name) {
420   if (name == ".ra")
421     return resolver.ResolveNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
422   return ResolveRegister(resolver, name);
423 }
424 
425 bool SymbolFileBreakpad::ParseUnwindRow(llvm::StringRef unwind_rules,
426                                         const RegisterInfoResolver &resolver,
427                                         UnwindPlan::Row &row) {
428   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
429 
430   llvm::BumpPtrAllocator node_alloc;
431   while (auto rule = GetRule(unwind_rules)) {
432     node_alloc.Reset();
433     llvm::StringRef lhs = rule->first;
434     postfix::Node *rhs = postfix::Parse(rule->second, node_alloc);
435     if (!rhs) {
436       LLDB_LOG(log, "Could not parse `{0}` as unwind rhs.", rule->second);
437       return false;
438     }
439 
440     bool success = postfix::ResolveSymbols(
441         rhs, [&](postfix::SymbolNode &symbol) -> postfix::Node * {
442           llvm::StringRef name = symbol.GetName();
443           if (name == ".cfa" && lhs != ".cfa")
444             return postfix::MakeNode<postfix::InitialValueNode>(node_alloc);
445 
446           if (const RegisterInfo *info = ResolveRegister(resolver, name)) {
447             return postfix::MakeNode<postfix::RegisterNode>(
448                 node_alloc, info->kinds[eRegisterKindLLDB]);
449           }
450           return nullptr;
451         });
452 
453     if (!success) {
454       LLDB_LOG(log, "Resolving symbols in `{0}` failed.", rule->second);
455       return false;
456     }
457 
458     ArchSpec arch = m_obj_file->GetArchitecture();
459     StreamString dwarf(Stream::eBinary, arch.GetAddressByteSize(),
460                        arch.GetByteOrder());
461     ToDWARF(*rhs, dwarf);
462     uint8_t *saved = m_allocator.Allocate<uint8_t>(dwarf.GetSize());
463     std::memcpy(saved, dwarf.GetData(), dwarf.GetSize());
464 
465     if (lhs == ".cfa") {
466       row.GetCFAValue().SetIsDWARFExpression(saved, dwarf.GetSize());
467     } else if (const RegisterInfo *info = ResolveRegisterOrRA(resolver, lhs)) {
468       UnwindPlan::Row::RegisterLocation loc;
469       loc.SetIsDWARFExpression(saved, dwarf.GetSize());
470       row.SetRegisterInfo(info->kinds[eRegisterKindLLDB], loc);
471     } else
472       LLDB_LOG(log, "Invalid register `{0}` in unwind rule.", lhs);
473   }
474   if (unwind_rules.empty())
475     return true;
476 
477   LLDB_LOG(log, "Could not parse `{0}` as an unwind rule.", unwind_rules);
478   return false;
479 }
480 
481 UnwindPlanSP
482 SymbolFileBreakpad::GetUnwindPlan(const Address &address,
483                                   const RegisterInfoResolver &resolver) {
484   ParseUnwindData();
485   const UnwindMap::Entry *entry =
486       m_unwind_data->FindEntryThatContains(address.GetFileAddress());
487   if (!entry)
488     return nullptr;
489 
490   addr_t base = GetBaseFileAddress();
491   if (base == LLDB_INVALID_ADDRESS)
492     return nullptr;
493 
494   LineIterator It(*m_obj_file, Record::StackCFI, entry->data), End(*m_obj_file);
495   llvm::Optional<StackCFIRecord> init_record = StackCFIRecord::parse(*It);
496   assert(init_record.hasValue());
497   assert(init_record->Size.hasValue());
498 
499   auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB);
500   plan_sp->SetSourceName("breakpad STACK CFI");
501   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
502   plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
503   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
504   plan_sp->SetPlanValidAddressRange(
505       AddressRange(base + init_record->Address, *init_record->Size,
506                    m_obj_file->GetModule()->GetSectionList()));
507 
508   auto row_sp = std::make_shared<UnwindPlan::Row>();
509   row_sp->SetOffset(0);
510   if (!ParseUnwindRow(init_record->UnwindRules, resolver, *row_sp))
511     return nullptr;
512   plan_sp->AppendRow(row_sp);
513   for (++It; It != End; ++It) {
514     llvm::Optional<StackCFIRecord> record = StackCFIRecord::parse(*It);
515     if (!record.hasValue())
516       return nullptr;
517     if (record->Size.hasValue())
518       break;
519 
520     row_sp = std::make_shared<UnwindPlan::Row>(*row_sp);
521     row_sp->SetOffset(record->Address - init_record->Address);
522     if (!ParseUnwindRow(record->UnwindRules, resolver, *row_sp))
523       return nullptr;
524     plan_sp->AppendRow(row_sp);
525   }
526   return plan_sp;
527 }
528 
529 addr_t SymbolFileBreakpad::GetBaseFileAddress() {
530   return m_obj_file->GetModule()
531       ->GetObjectFile()
532       ->GetBaseAddress()
533       .GetFileAddress();
534 }
535 
536 // Parse out all the FILE records from the breakpad file. These will be needed
537 // when constructing the support file lists for individual compile units.
538 void SymbolFileBreakpad::ParseFileRecords() {
539   if (m_files)
540     return;
541   m_files.emplace();
542 
543   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
544   for (llvm::StringRef line : lines(Record::File)) {
545     auto record = FileRecord::parse(line);
546     if (!record) {
547       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line);
548       continue;
549     }
550 
551     if (record->Number >= m_files->size())
552       m_files->resize(record->Number + 1);
553     FileSpec::Style style = FileSpec::GuessPathStyle(record->Name)
554                                 .getValueOr(FileSpec::Style::native);
555     (*m_files)[record->Number] = FileSpec(record->Name, style);
556   }
557 }
558 
559 void SymbolFileBreakpad::ParseCUData() {
560   if (m_cu_data)
561     return;
562 
563   m_cu_data.emplace();
564   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
565   addr_t base = GetBaseFileAddress();
566   if (base == LLDB_INVALID_ADDRESS) {
567     LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address "
568                   "of object file.");
569   }
570 
571   // We shall create one compile unit for each FUNC record. So, count the number
572   // of FUNC records, and store them in m_cu_data, together with their ranges.
573   for (LineIterator It(*m_obj_file, Record::Func), End(*m_obj_file); It != End;
574        ++It) {
575     if (auto record = FuncRecord::parse(*It)) {
576       m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size,
577                                            CompUnitData(It.GetBookmark())));
578     } else
579       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
580   }
581   m_cu_data->Sort();
582 }
583 
584 // Construct the list of support files and line table entries for the given
585 // compile unit.
586 void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu,
587                                                        CompUnitData &data) {
588   addr_t base = GetBaseFileAddress();
589   assert(base != LLDB_INVALID_ADDRESS &&
590          "How did we create compile units without a base address?");
591 
592   SupportFileMap map;
593   data.line_table_up = llvm::make_unique<LineTable>(&cu);
594   std::unique_ptr<LineSequence> line_seq_up(
595       data.line_table_up->CreateLineSequenceContainer());
596   llvm::Optional<addr_t> next_addr;
597   auto finish_sequence = [&]() {
598     data.line_table_up->AppendLineEntryToSequence(
599         line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0,
600         /*file_idx*/ 0, /*is_start_of_statement*/ false,
601         /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false,
602         /*is_epilogue_begin*/ false, /*is_terminal_entry*/ true);
603     data.line_table_up->InsertSequence(line_seq_up.get());
604     line_seq_up->Clear();
605   };
606 
607   LineIterator It(*m_obj_file, Record::Func, data.bookmark), End(*m_obj_file);
608   assert(Record::classify(*It) == Record::Func);
609   for (++It; It != End; ++It) {
610     auto record = LineRecord::parse(*It);
611     if (!record)
612       break;
613 
614     record->Address += base;
615 
616     if (next_addr && *next_addr != record->Address) {
617       // Discontiguous entries. Finish off the previous sequence and reset.
618       finish_sequence();
619     }
620     data.line_table_up->AppendLineEntryToSequence(
621         line_seq_up.get(), record->Address, record->LineNum, /*column*/ 0,
622         map[record->FileNum], /*is_start_of_statement*/ true,
623         /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false,
624         /*is_epilogue_begin*/ false, /*is_terminal_entry*/ false);
625     next_addr = record->Address + record->Size;
626   }
627   if (next_addr)
628     finish_sequence();
629   data.support_files = map.translate(cu, *m_files);
630 }
631 
632 void SymbolFileBreakpad::ParseUnwindData() {
633   if (m_unwind_data)
634     return;
635 
636   m_unwind_data.emplace();
637   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
638   addr_t base = GetBaseFileAddress();
639   if (base == LLDB_INVALID_ADDRESS) {
640     LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address "
641                   "of object file.");
642   }
643 
644   for (LineIterator It(*m_obj_file, Record::StackCFI), End(*m_obj_file);
645        It != End; ++It) {
646     if (auto record = StackCFIRecord::parse(*It)) {
647       if (record->Size)
648         m_unwind_data->Append(UnwindMap::Entry(
649             base + record->Address, *record->Size, It.GetBookmark()));
650     } else
651       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
652   }
653   m_unwind_data->Sort();
654 }
655