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

   1 //===-- SymbolFileBreakpad.cpp --------------------------------------------===//
   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/SymbolVendor.h"
  19 #include "lldb/Symbol/TypeMap.h"
  20 #include "lldb/Utility/LLDBLog.h"
  21 #include "lldb/Utility/Log.h"
  22 #include "lldb/Utility/StreamString.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include <optional>
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28 using namespace lldb_private::breakpad;
  29
  30 LLDB_PLUGIN_DEFINE(SymbolFileBreakpad)
  31
  32 char SymbolFileBreakpad::ID;
  33
  34 class SymbolFileBreakpad::LineIterator {
  35 public:
  36   // begin iterator for sections of given type
  37   LineIterator(ObjectFile &obj, Record::Kind section_type)
  38       : m_obj(&obj), m_section_type(toString(section_type)),
  39         m_next_section_idx(0), m_next_line(llvm::StringRef::npos) {
  40     ++*this;
  41   }
  42
  43   // An iterator starting at the position given by the bookmark.
  44   LineIterator(ObjectFile &obj, Record::Kind section_type, Bookmark bookmark);
  45
  46   // end iterator
  47   explicit LineIterator(ObjectFile &obj)
  48       : m_obj(&obj),
  49         m_next_section_idx(m_obj->GetSectionList()->GetNumSections(0)),
  50         m_current_line(llvm::StringRef::npos),
  51         m_next_line(llvm::StringRef::npos) {}
  52
  53   friend bool operator!=(const LineIterator &lhs, const LineIterator &rhs) {
  54     assert(lhs.m_obj == rhs.m_obj);
  55     if (lhs.m_next_section_idx != rhs.m_next_section_idx)
  56       return true;
  57     if (lhs.m_current_line != rhs.m_current_line)
  58       return true;
  59     assert(lhs.m_next_line == rhs.m_next_line);
  60     return false;
  61   }
  62
  63   const LineIterator &operator++();
  64   llvm::StringRef operator*() const {
  65     return m_section_text.slice(m_current_line, m_next_line);
  66   }
  67
  68   Bookmark GetBookmark() const {
  69     return Bookmark{m_next_section_idx, m_current_line};
  70   }
  71
  72 private:
  73   ObjectFile *m_obj;
  74   ConstString m_section_type;
  75   uint32_t m_next_section_idx;
  76   llvm::StringRef m_section_text;
  77   size_t m_current_line;
  78   size_t m_next_line;
  79
  80   void FindNextLine() {
  81     m_next_line = m_section_text.find('\n', m_current_line);
  82     if (m_next_line != llvm::StringRef::npos) {
  83       ++m_next_line;
  84       if (m_next_line >= m_section_text.size())
  85         m_next_line = llvm::StringRef::npos;
  86     }
  87   }
  88 };
  89
  90 SymbolFileBreakpad::LineIterator::LineIterator(ObjectFile &obj,
  91                                                Record::Kind section_type,
  92                                                Bookmark bookmark)
  93     : m_obj(&obj), m_section_type(toString(section_type)),
  94       m_next_section_idx(bookmark.section), m_current_line(bookmark.offset) {
  95   Section &sect =
  96       *obj.GetSectionList()->GetSectionAtIndex(m_next_section_idx - 1);
  97   assert(sect.GetName() == m_section_type);
  98
  99   DataExtractor data;
 100   obj.ReadSectionData(&sect, data);
 101   m_section_text = toStringRef(data.GetData());
 102
 103   assert(m_current_line < m_section_text.size());
 104   FindNextLine();
 105 }
 106
 107 const SymbolFileBreakpad::LineIterator &
 108 SymbolFileBreakpad::LineIterator::operator++() {
 109   const SectionList &list = *m_obj->GetSectionList();
 110   size_t num_sections = list.GetNumSections(0);
 111   while (m_next_line != llvm::StringRef::npos ||
 112          m_next_section_idx < num_sections) {
 113     if (m_next_line != llvm::StringRef::npos) {
 114       m_current_line = m_next_line;
 115       FindNextLine();
 116       return *this;
 117     }
 118
 119     Section &sect = *list.GetSectionAtIndex(m_next_section_idx++);
 120     if (sect.GetName() != m_section_type)
 121       continue;
 122     DataExtractor data;
 123     m_obj->ReadSectionData(&sect, data);
 124     m_section_text = toStringRef(data.GetData());
 125     m_next_line = 0;
 126   }
 127   // We've reached the end.
 128   m_current_line = m_next_line;
 129   return *this;
 130 }
 131
 132 llvm::iterator_range<SymbolFileBreakpad::LineIterator>
 133 SymbolFileBreakpad::lines(Record::Kind section_type) {
 134   return llvm::make_range(LineIterator(*m_objfile_sp, section_type),
 135                           LineIterator(*m_objfile_sp));
 136 }
 137
 138 namespace {
 139 // A helper class for constructing the list of support files for a given compile
 140 // unit.
 141 class SupportFileMap {
 142 public:
 143   // Given a breakpad file ID, return a file ID to be used in the support files
 144   // for this compile unit.
 145   size_t operator[](size_t file) {
 146     return m_map.try_emplace(file, m_map.size() + 1).first->second;
 147   }
 148
 149   // Construct a FileSpecList containing only the support files relevant for
 150   // this compile unit (in the correct order).
 151   FileSpecList translate(const FileSpec &cu_spec,
 152                          llvm::ArrayRef<FileSpec> all_files);
 153
 154 private:
 155   llvm::DenseMap<size_t, size_t> m_map;
 156 };
 157 } // namespace
 158
 159 FileSpecList SupportFileMap::translate(const FileSpec &cu_spec,
 160                                        llvm::ArrayRef<FileSpec> all_files) {
 161   std::vector<FileSpec> result;
 162   result.resize(m_map.size() + 1);
 163   result[0] = cu_spec;
 164   for (const auto &KV : m_map) {
 165     if (KV.first < all_files.size())
 166       result[KV.second] = all_files[KV.first];
 167   }
 168   return FileSpecList(std::move(result));
 169 }
 170
 171 void SymbolFileBreakpad::Initialize() {
 172   PluginManager::RegisterPlugin(GetPluginNameStatic(),
 173                                 GetPluginDescriptionStatic(), CreateInstance,
 174                                 DebuggerInitialize);
 175 }
 176
 177 void SymbolFileBreakpad::Terminate() {
 178   PluginManager::UnregisterPlugin(CreateInstance);
 179 }
 180
 181 uint32_t SymbolFileBreakpad::CalculateAbilities() {
 182   if (!m_objfile_sp || !llvm::isa<ObjectFileBreakpad>(*m_objfile_sp))
 183     return 0;
 184
 185   return CompileUnits | Functions | LineTables;
 186 }
 187
 188 uint32_t SymbolFileBreakpad::CalculateNumCompileUnits() {
 189   ParseCUData();
 190   return m_cu_data->GetSize();
 191 }
 192
 193 CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) {
 194   if (index >= m_cu_data->GetSize())
 195     return nullptr;
 196
 197   CompUnitData &data = m_cu_data->GetEntryRef(index).data;
 198
 199   ParseFileRecords();
 200
 201   FileSpec spec;
 202
 203   // The FileSpec of the compile unit will be the file corresponding to the
 204   // first LINE record.
 205   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
 206       End(*m_objfile_sp);
 207   assert(Record::classify(*It) == Record::Func);
 208   ++It; // Skip FUNC record.
 209   // Skip INLINE records.
 210   while (It != End && Record::classify(*It) == Record::Inline)
 211     ++It;
 212
 213   if (It != End) {
 214     auto record = LineRecord::parse(*It);
 215     if (record && record->FileNum < m_files->size())
 216       spec = (*m_files)[record->FileNum];
 217   }
 218
 219   auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(),
 220                                              /*user_data*/ nullptr, spec, index,
 221                                              eLanguageTypeUnknown,
 222                                              /*is_optimized*/ eLazyBoolNo);
 223
 224   SetCompileUnitAtIndex(index, cu_sp);
 225   return cu_sp;
 226 }
 227
 228 FunctionSP SymbolFileBreakpad::GetOrCreateFunction(CompileUnit &comp_unit) {
 229   user_id_t id = comp_unit.GetID();
 230   if (FunctionSP func_sp = comp_unit.FindFunctionByUID(id))
 231     return func_sp;
 232
 233   Log *log = GetLog(LLDBLog::Symbols);
 234   FunctionSP func_sp;
 235   addr_t base = GetBaseFileAddress();
 236   if (base == LLDB_INVALID_ADDRESS) {
 237     LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping "
 238                   "symtab population.");
 239     return func_sp;
 240   }
 241
 242   const SectionList *list = comp_unit.GetModule()->GetSectionList();
 243   CompUnitData &data = m_cu_data->GetEntryRef(id).data;
 244   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark);
 245   assert(Record::classify(*It) == Record::Func);
 246
 247   if (auto record = FuncRecord::parse(*It)) {
 248     Mangled func_name;
 249     func_name.SetValue(ConstString(record->Name));
 250     addr_t address = record->Address + base;
 251     SectionSP section_sp = list->FindSectionContainingFileAddress(address);
 252     if (section_sp) {
 253       AddressRange func_range(
 254           section_sp, address - section_sp->GetFileAddress(), record->Size);
 255       // Use the CU's id because every CU has only one function inside.
 256       func_sp = std::make_shared<Function>(&comp_unit, id, 0, func_name,
 257                                            nullptr, func_range);
 258       comp_unit.AddFunction(func_sp);
 259     }
 260   }
 261   return func_sp;
 262 }
 263
 264 size_t SymbolFileBreakpad::ParseFunctions(CompileUnit &comp_unit) {
 265   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 266   return GetOrCreateFunction(comp_unit) ? 1 : 0;
 267 }
 268
 269 bool SymbolFileBreakpad::ParseLineTable(CompileUnit &comp_unit) {
 270   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 271   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
 272
 273   if (!data.line_table_up)
 274     ParseLineTableAndSupportFiles(comp_unit, data);
 275
 276   comp_unit.SetLineTable(data.line_table_up.release());
 277   return true;
 278 }
 279
 280 bool SymbolFileBreakpad::ParseSupportFiles(CompileUnit &comp_unit,
 281                                            FileSpecList &support_files) {
 282   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 283   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit.GetID()).data;
 284   if (!data.support_files)
 285     ParseLineTableAndSupportFiles(comp_unit, data);
 286
 287   support_files = std::move(*data.support_files);
 288   return true;
 289 }
 290
 291 size_t SymbolFileBreakpad::ParseBlocksRecursive(Function &func) {
 292   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 293   CompileUnit *comp_unit = func.GetCompileUnit();
 294   lldbassert(comp_unit);
 295   ParseInlineOriginRecords();
 296   // A vector of current each level's parent block. For example, when parsing
 297   // "INLINE 0 ...", the current level is 0 and its parent block is the
 298   // function block at index 0.
 299   std::vector<Block *> blocks;
 300   Block &block = func.GetBlock(false);
 301   block.AddRange(Block::Range(0, func.GetAddressRange().GetByteSize()));
 302   blocks.push_back(&block);
 303
 304   size_t blocks_added = 0;
 305   addr_t func_base = func.GetAddressRange().GetBaseAddress().GetOffset();
 306   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit->GetID()).data;
 307   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
 308       End(*m_objfile_sp);
 309   ++It; // Skip the FUNC record.
 310   size_t last_added_nest_level = 0;
 311   while (It != End && Record::classify(*It) == Record::Inline) {
 312     if (auto record = InlineRecord::parse(*It)) {
 313       if (record->InlineNestLevel == 0 ||
 314           record->InlineNestLevel <= last_added_nest_level + 1) {
 315         last_added_nest_level = record->InlineNestLevel;
 316         BlockSP block_sp = std::make_shared<Block>(It.GetBookmark().offset);
 317         FileSpec callsite_file;
 318         if (record->CallSiteFileNum < m_files->size())
 319           callsite_file = (*m_files)[record->CallSiteFileNum];
 320         llvm::StringRef name;
 321         if (record->OriginNum < m_inline_origins->size())
 322           name = (*m_inline_origins)[record->OriginNum];
 323
 324         Declaration callsite(callsite_file, record->CallSiteLineNum);
 325         block_sp->SetInlinedFunctionInfo(name.str().c_str(),
 326                                          /*mangled=*/nullptr,
 327                                          /*decl_ptr=*/nullptr, &callsite);
 328         for (const auto &range : record->Ranges) {
 329           block_sp->AddRange(
 330               Block::Range(range.first - func_base, range.second));
 331         }
 332         block_sp->FinalizeRanges();
 333
 334         blocks[record->InlineNestLevel]->AddChild(block_sp);
 335         if (record->InlineNestLevel + 1 >= blocks.size()) {
 336           blocks.resize(blocks.size() + 1);
 337         }
 338         blocks[record->InlineNestLevel + 1] = block_sp.get();
 339         ++blocks_added;
 340       }
 341     }
 342     ++It;
 343   }
 344   return blocks_added;
 345 }
 346
 347 void SymbolFileBreakpad::ParseInlineOriginRecords() {
 348   if (m_inline_origins)
 349     return;
 350   m_inline_origins.emplace();
 351
 352   Log *log = GetLog(LLDBLog::Symbols);
 353   for (llvm::StringRef line : lines(Record::InlineOrigin)) {
 354     auto record = InlineOriginRecord::parse(line);
 355     if (!record) {
 356       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line);
 357       continue;
 358     }
 359
 360     if (record->Number >= m_inline_origins->size())
 361       m_inline_origins->resize(record->Number + 1);
 362     (*m_inline_origins)[record->Number] = record->Name;
 363   }
 364 }
 365
 366 uint32_t
 367 SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
 368                                          SymbolContextItem resolve_scope,
 369                                          SymbolContext &sc) {
 370   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 371   if (!(resolve_scope & (eSymbolContextCompUnit | eSymbolContextLineEntry |
 372                          eSymbolContextFunction | eSymbolContextBlock)))
 373     return 0;
 374
 375   ParseCUData();
 376   uint32_t idx =
 377       m_cu_data->FindEntryIndexThatContains(so_addr.GetFileAddress());
 378   if (idx == UINT32_MAX)
 379     return 0;
 380
 381   sc.comp_unit = GetCompileUnitAtIndex(idx).get();
 382   SymbolContextItem result = eSymbolContextCompUnit;
 383   if (resolve_scope & eSymbolContextLineEntry) {
 384     if (sc.comp_unit->GetLineTable()->FindLineEntryByAddress(so_addr,
 385                                                              sc.line_entry)) {
 386       result |= eSymbolContextLineEntry;
 387     }
 388   }
 389
 390   if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
 391     FunctionSP func_sp = GetOrCreateFunction(*sc.comp_unit);
 392     if (func_sp) {
 393       sc.function = func_sp.get();
 394       result |= eSymbolContextFunction;
 395       if (resolve_scope & eSymbolContextBlock) {
 396         Block &block = func_sp->GetBlock(true);
 397         sc.block = block.FindInnermostBlockByOffset(
 398             so_addr.GetFileAddress() -
 399             sc.function->GetAddressRange().GetBaseAddress().GetFileAddress());
 400         if (sc.block)
 401           result |= eSymbolContextBlock;
 402       }
 403     }
 404   }
 405
 406   return result;
 407 }
 408
 409 uint32_t SymbolFileBreakpad::ResolveSymbolContext(
 410     const SourceLocationSpec &src_location_spec,
 411     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
 412   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 413   if (!(resolve_scope & eSymbolContextCompUnit))
 414     return 0;
 415
 416   uint32_t old_size = sc_list.GetSize();
 417   for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
 418     CompileUnit &cu = *GetCompileUnitAtIndex(i);
 419     cu.ResolveSymbolContext(src_location_spec, resolve_scope, sc_list);
 420   }
 421   return sc_list.GetSize() - old_size;
 422 }
 423
 424 void SymbolFileBreakpad::FindFunctions(
 425     const Module::LookupInfo &lookup_info,
 426     const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
 427     SymbolContextList &sc_list) {
 428   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 429   // TODO: Implement this with supported FunctionNameType.
 430
 431   ConstString name = lookup_info.GetLookupName();
 432   for (uint32_t i = 0; i < GetNumCompileUnits(); ++i) {
 433     CompUnitSP cu_sp = GetCompileUnitAtIndex(i);
 434     FunctionSP func_sp = GetOrCreateFunction(*cu_sp);
 435     if (func_sp && name == func_sp->GetNameNoArguments()) {
 436       SymbolContext sc;
 437       sc.comp_unit = cu_sp.get();
 438       sc.function = func_sp.get();
 439       sc.module_sp = func_sp->CalculateSymbolContextModule();
 440       sc_list.Append(sc);
 441     }
 442   }
 443 }
 444
 445 void SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
 446                                        bool include_inlines,
 447                                        SymbolContextList &sc_list) {
 448   // TODO
 449 }
 450
 451 void SymbolFileBreakpad::FindTypes(
 452     ConstString name, const CompilerDeclContext &parent_decl_ctx,
 453     uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
 454     TypeMap &types) {}
 455
 456 void SymbolFileBreakpad::FindTypes(
 457     llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
 458     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {}
 459
 460 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) {
 461   Log *log = GetLog(LLDBLog::Symbols);
 462   Module &module = *m_objfile_sp->GetModule();
 463   addr_t base = GetBaseFileAddress();
 464   if (base == LLDB_INVALID_ADDRESS) {
 465     LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping "
 466                   "symtab population.");
 467     return;
 468   }
 469
 470   const SectionList &list = *module.GetSectionList();
 471   llvm::DenseSet<addr_t> found_symbol_addresses;
 472   std::vector<Symbol> symbols;
 473   auto add_symbol = [&](addr_t address, std::optional<addr_t> size,
 474                         llvm::StringRef name) {
 475     address += base;
 476     SectionSP section_sp = list.FindSectionContainingFileAddress(address);
 477     if (!section_sp) {
 478       LLDB_LOG(log,
 479                "Ignoring symbol {0}, whose address ({1}) is outside of the "
 480                "object file. Mismatched symbol file?",
 481                name, address);
 482       return;
 483     }
 484     // Keep track of what addresses were already added so far and only add
 485     // the symbol with the first address.
 486     if (!found_symbol_addresses.insert(address).second)
 487       return;
 488     symbols.emplace_back(
 489         /*symID*/ 0, Mangled(name), eSymbolTypeCode,
 490         /*is_global*/ true, /*is_debug*/ false,
 491         /*is_trampoline*/ false, /*is_artificial*/ false,
 492         AddressRange(section_sp, address - section_sp->GetFileAddress(),
 493                      size.value_or(0)),
 494         size.has_value(), /*contains_linker_annotations*/ false, /*flags*/ 0);
 495   };
 496
 497   for (llvm::StringRef line : lines(Record::Public)) {
 498     if (auto record = PublicRecord::parse(line))
 499       add_symbol(record->Address, std::nullopt, record->Name);
 500     else
 501       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line);
 502   }
 503
 504   for (Symbol &symbol : symbols)
 505     symtab.AddSymbol(std::move(symbol));
 506   symtab.Finalize();
 507 }
 508
 509 llvm::Expected<lldb::addr_t>
 510 SymbolFileBreakpad::GetParameterStackSize(Symbol &symbol) {
 511   ParseUnwindData();
 512   if (auto *entry = m_unwind_data->win.FindEntryThatContains(
 513           symbol.GetAddress().GetFileAddress())) {
 514     auto record = StackWinRecord::parse(
 515         *LineIterator(*m_objfile_sp, Record::StackWin, entry->data));
 516     assert(record);
 517     return record->ParameterSize;
 518   }
 519   return llvm::createStringError(llvm::inconvertibleErrorCode(),
 520                                  "Parameter size unknown.");
 521 }
 522
 523 static std::optional<std::pair<llvm::StringRef, llvm::StringRef>>
 524 GetRule(llvm::StringRef &unwind_rules) {
 525   // Unwind rules are of the form
 526   //   register1: expression1 register2: expression2 ...
 527   // We assume none of the tokens in expression<n> end with a colon.
 528
 529   llvm::StringRef lhs, rest;
 530   std::tie(lhs, rest) = getToken(unwind_rules);
 531   if (!lhs.consume_back(":"))
 532     return std::nullopt;
 533
 534   // Seek forward to the next register: expression pair
 535   llvm::StringRef::size_type pos = rest.find(": ");
 536   if (pos == llvm::StringRef::npos) {
 537     // No pair found, this means the rest of the string is a single expression.
 538     unwind_rules = llvm::StringRef();
 539     return std::make_pair(lhs, rest);
 540   }
 541
 542   // Go back one token to find the end of the current rule.
 543   pos = rest.rfind(' ', pos);
 544   if (pos == llvm::StringRef::npos)
 545     return std::nullopt;
 546
 547   llvm::StringRef rhs = rest.take_front(pos);
 548   unwind_rules = rest.drop_front(pos);
 549   return std::make_pair(lhs, rhs);
 550 }
 551
 552 static const RegisterInfo *
 553 ResolveRegister(const llvm::Triple &triple,
 554                 const SymbolFile::RegisterInfoResolver &resolver,
 555                 llvm::StringRef name) {
 556   if (triple.isX86() || triple.isMIPS()) {
 557     // X86 and MIPS registers have '$' in front of their register names. Arm and
 558     // AArch64 don't.
 559     if (!name.consume_front("$"))
 560       return nullptr;
 561   }
 562   return resolver.ResolveName(name);
 563 }
 564
 565 static const RegisterInfo *
 566 ResolveRegisterOrRA(const llvm::Triple &triple,
 567                     const SymbolFile::RegisterInfoResolver &resolver,
 568                     llvm::StringRef name) {
 569   if (name == ".ra")
 570     return resolver.ResolveNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 571   return ResolveRegister(triple, resolver, name);
 572 }
 573
 574 llvm::ArrayRef<uint8_t> SymbolFileBreakpad::SaveAsDWARF(postfix::Node &node) {
 575   ArchSpec arch = m_objfile_sp->GetArchitecture();
 576   StreamString dwarf(Stream::eBinary, arch.GetAddressByteSize(),
 577                      arch.GetByteOrder());
 578   ToDWARF(node, dwarf);
 579   uint8_t *saved = m_allocator.Allocate<uint8_t>(dwarf.GetSize());
 580   std::memcpy(saved, dwarf.GetData(), dwarf.GetSize());
 581   return {saved, dwarf.GetSize()};
 582 }
 583
 584 bool SymbolFileBreakpad::ParseCFIUnwindRow(llvm::StringRef unwind_rules,
 585                                         const RegisterInfoResolver &resolver,
 586                                         UnwindPlan::Row &row) {
 587   Log *log = GetLog(LLDBLog::Symbols);
 588
 589   llvm::BumpPtrAllocator node_alloc;
 590   llvm::Triple triple = m_objfile_sp->GetArchitecture().GetTriple();
 591   while (auto rule = GetRule(unwind_rules)) {
 592     node_alloc.Reset();
 593     llvm::StringRef lhs = rule->first;
 594     postfix::Node *rhs = postfix::ParseOneExpression(rule->second, node_alloc);
 595     if (!rhs) {
 596       LLDB_LOG(log, "Could not parse `{0}` as unwind rhs.", rule->second);
 597       return false;
 598     }
 599
 600     bool success = postfix::ResolveSymbols(
 601         rhs, [&](postfix::SymbolNode &symbol) -> postfix::Node * {
 602           llvm::StringRef name = symbol.GetName();
 603           if (name == ".cfa" && lhs != ".cfa")
 604             return postfix::MakeNode<postfix::InitialValueNode>(node_alloc);
 605
 606           if (const RegisterInfo *info =
 607                   ResolveRegister(triple, resolver, name)) {
 608             return postfix::MakeNode<postfix::RegisterNode>(
 609                 node_alloc, info->kinds[eRegisterKindLLDB]);
 610           }
 611           return nullptr;
 612         });
 613
 614     if (!success) {
 615       LLDB_LOG(log, "Resolving symbols in `{0}` failed.", rule->second);
 616       return false;
 617     }
 618
 619     llvm::ArrayRef<uint8_t> saved = SaveAsDWARF(*rhs);
 620     if (lhs == ".cfa") {
 621       row.GetCFAValue().SetIsDWARFExpression(saved.data(), saved.size());
 622     } else if (const RegisterInfo *info =
 623                    ResolveRegisterOrRA(triple, resolver, lhs)) {
 624       UnwindPlan::Row::RegisterLocation loc;
 625       loc.SetIsDWARFExpression(saved.data(), saved.size());
 626       row.SetRegisterInfo(info->kinds[eRegisterKindLLDB], loc);
 627     } else
 628       LLDB_LOG(log, "Invalid register `{0}` in unwind rule.", lhs);
 629   }
 630   if (unwind_rules.empty())
 631     return true;
 632
 633   LLDB_LOG(log, "Could not parse `{0}` as an unwind rule.", unwind_rules);
 634   return false;
 635 }
 636
 637 UnwindPlanSP
 638 SymbolFileBreakpad::GetUnwindPlan(const Address &address,
 639                                   const RegisterInfoResolver &resolver) {
 640   ParseUnwindData();
 641   if (auto *entry =
 642           m_unwind_data->cfi.FindEntryThatContains(address.GetFileAddress()))
 643     return ParseCFIUnwindPlan(entry->data, resolver);
 644   if (auto *entry =
 645           m_unwind_data->win.FindEntryThatContains(address.GetFileAddress()))
 646     return ParseWinUnwindPlan(entry->data, resolver);
 647   return nullptr;
 648 }
 649
 650 UnwindPlanSP
 651 SymbolFileBreakpad::ParseCFIUnwindPlan(const Bookmark &bookmark,
 652                                        const RegisterInfoResolver &resolver) {
 653   addr_t base = GetBaseFileAddress();
 654   if (base == LLDB_INVALID_ADDRESS)
 655     return nullptr;
 656
 657   LineIterator It(*m_objfile_sp, Record::StackCFI, bookmark),
 658       End(*m_objfile_sp);
 659   std::optional<StackCFIRecord> init_record = StackCFIRecord::parse(*It);
 660   assert(init_record && init_record->Size &&
 661          "Record already parsed successfully in ParseUnwindData!");
 662
 663   auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB);
 664   plan_sp->SetSourceName("breakpad STACK CFI");
 665   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
 666   plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
 667   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
 668   plan_sp->SetPlanValidAddressRange(
 669       AddressRange(base + init_record->Address, *init_record->Size,
 670                    m_objfile_sp->GetModule()->GetSectionList()));
 671
 672   auto row_sp = std::make_shared<UnwindPlan::Row>();
 673   row_sp->SetOffset(0);
 674   if (!ParseCFIUnwindRow(init_record->UnwindRules, resolver, *row_sp))
 675     return nullptr;
 676   plan_sp->AppendRow(row_sp);
 677   for (++It; It != End; ++It) {
 678     std::optional<StackCFIRecord> record = StackCFIRecord::parse(*It);
 679     if (!record)
 680       return nullptr;
 681     if (record->Size)
 682       break;
 683
 684     row_sp = std::make_shared<UnwindPlan::Row>(*row_sp);
 685     row_sp->SetOffset(record->Address - init_record->Address);
 686     if (!ParseCFIUnwindRow(record->UnwindRules, resolver, *row_sp))
 687       return nullptr;
 688     plan_sp->AppendRow(row_sp);
 689   }
 690   return plan_sp;
 691 }
 692
 693 UnwindPlanSP
 694 SymbolFileBreakpad::ParseWinUnwindPlan(const Bookmark &bookmark,
 695                                        const RegisterInfoResolver &resolver) {
 696   Log *log = GetLog(LLDBLog::Symbols);
 697   addr_t base = GetBaseFileAddress();
 698   if (base == LLDB_INVALID_ADDRESS)
 699     return nullptr;
 700
 701   LineIterator It(*m_objfile_sp, Record::StackWin, bookmark);
 702   std::optional<StackWinRecord> record = StackWinRecord::parse(*It);
 703   assert(record && "Record already parsed successfully in ParseUnwindData!");
 704
 705   auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB);
 706   plan_sp->SetSourceName("breakpad STACK WIN");
 707   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
 708   plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
 709   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
 710   plan_sp->SetPlanValidAddressRange(
 711       AddressRange(base + record->RVA, record->CodeSize,
 712                    m_objfile_sp->GetModule()->GetSectionList()));
 713
 714   auto row_sp = std::make_shared<UnwindPlan::Row>();
 715   row_sp->SetOffset(0);
 716
 717   llvm::BumpPtrAllocator node_alloc;
 718   std::vector<std::pair<llvm::StringRef, postfix::Node *>> program =
 719       postfix::ParseFPOProgram(record->ProgramString, node_alloc);
 720
 721   if (program.empty()) {
 722     LLDB_LOG(log, "Invalid unwind rule: {0}.", record->ProgramString);
 723     return nullptr;
 724   }
 725   auto it = program.begin();
 726   llvm::Triple triple = m_objfile_sp->GetArchitecture().GetTriple();
 727   const auto &symbol_resolver =
 728       [&](postfix::SymbolNode &symbol) -> postfix::Node * {
 729     llvm::StringRef name = symbol.GetName();
 730     for (const auto &rule : llvm::make_range(program.begin(), it)) {
 731       if (rule.first == name)
 732         return rule.second;
 733     }
 734     if (const RegisterInfo *info = ResolveRegister(triple, resolver, name))
 735       return postfix::MakeNode<postfix::RegisterNode>(
 736           node_alloc, info->kinds[eRegisterKindLLDB]);
 737     return nullptr;
 738   };
 739
 740   // We assume the first value will be the CFA. It is usually called T0, but
 741   // clang will use T1, if it needs to realign the stack.
 742   auto *symbol = llvm::dyn_cast<postfix::SymbolNode>(it->second);
 743   if (symbol && symbol->GetName() == ".raSearch") {
 744     row_sp->GetCFAValue().SetRaSearch(record->LocalSize +
 745                                       record->SavedRegisterSize);
 746   } else {
 747     if (!postfix::ResolveSymbols(it->second, symbol_resolver)) {
 748       LLDB_LOG(log, "Resolving symbols in `{0}` failed.",
 749                record->ProgramString);
 750       return nullptr;
 751     }
 752     llvm::ArrayRef<uint8_t> saved  = SaveAsDWARF(*it->second);
 753     row_sp->GetCFAValue().SetIsDWARFExpression(saved.data(), saved.size());
 754   }
 755
 756   // Replace the node value with InitialValueNode, so that subsequent
 757   // expressions refer to the CFA value instead of recomputing the whole
 758   // expression.
 759   it->second = postfix::MakeNode<postfix::InitialValueNode>(node_alloc);
 760
 761
 762   // Now process the rest of the assignments.
 763   for (++it; it != program.end(); ++it) {
 764     const RegisterInfo *info = ResolveRegister(triple, resolver, it->first);
 765     // It is not an error if the resolution fails because the program may
 766     // contain temporary variables.
 767     if (!info)
 768       continue;
 769     if (!postfix::ResolveSymbols(it->second, symbol_resolver)) {
 770       LLDB_LOG(log, "Resolving symbols in `{0}` failed.",
 771                record->ProgramString);
 772       return nullptr;
 773     }
 774
 775     llvm::ArrayRef<uint8_t> saved = SaveAsDWARF(*it->second);
 776     UnwindPlan::Row::RegisterLocation loc;
 777     loc.SetIsDWARFExpression(saved.data(), saved.size());
 778     row_sp->SetRegisterInfo(info->kinds[eRegisterKindLLDB], loc);
 779   }
 780
 781   plan_sp->AppendRow(row_sp);
 782   return plan_sp;
 783 }
 784
 785 addr_t SymbolFileBreakpad::GetBaseFileAddress() {
 786   return m_objfile_sp->GetModule()
 787       ->GetObjectFile()
 788       ->GetBaseAddress()
 789       .GetFileAddress();
 790 }
 791
 792 // Parse out all the FILE records from the breakpad file. These will be needed
 793 // when constructing the support file lists for individual compile units.
 794 void SymbolFileBreakpad::ParseFileRecords() {
 795   if (m_files)
 796     return;
 797   m_files.emplace();
 798
 799   Log *log = GetLog(LLDBLog::Symbols);
 800   for (llvm::StringRef line : lines(Record::File)) {
 801     auto record = FileRecord::parse(line);
 802     if (!record) {
 803       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line);
 804       continue;
 805     }
 806
 807     if (record->Number >= m_files->size())
 808       m_files->resize(record->Number + 1);
 809     FileSpec::Style style = FileSpec::GuessPathStyle(record->Name)
 810                                 .value_or(FileSpec::Style::native);
 811     (*m_files)[record->Number] = FileSpec(record->Name, style);
 812   }
 813 }
 814
 815 void SymbolFileBreakpad::ParseCUData() {
 816   if (m_cu_data)
 817     return;
 818
 819   m_cu_data.emplace();
 820   Log *log = GetLog(LLDBLog::Symbols);
 821   addr_t base = GetBaseFileAddress();
 822   if (base == LLDB_INVALID_ADDRESS) {
 823     LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address "
 824                   "of object file.");
 825   }
 826
 827   // We shall create one compile unit for each FUNC record. So, count the number
 828   // of FUNC records, and store them in m_cu_data, together with their ranges.
 829   for (LineIterator It(*m_objfile_sp, Record::Func), End(*m_objfile_sp);
 830        It != End; ++It) {
 831     if (auto record = FuncRecord::parse(*It)) {
 832       m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size,
 833                                            CompUnitData(It.GetBookmark())));
 834     } else
 835       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
 836   }
 837   m_cu_data->Sort();
 838 }
 839
 840 // Construct the list of support files and line table entries for the given
 841 // compile unit.
 842 void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu,
 843                                                        CompUnitData &data) {
 844   addr_t base = GetBaseFileAddress();
 845   assert(base != LLDB_INVALID_ADDRESS &&
 846          "How did we create compile units without a base address?");
 847
 848   SupportFileMap map;
 849   std::vector<std::unique_ptr<LineSequence>> sequences;
 850   std::unique_ptr<LineSequence> line_seq_up =
 851       LineTable::CreateLineSequenceContainer();
 852   std::optional<addr_t> next_addr;
 853   auto finish_sequence = [&]() {
 854     LineTable::AppendLineEntryToSequence(
 855         line_seq_up.get(), *next_addr, /*line=*/0, /*column=*/0,
 856         /*file_idx=*/0, /*is_start_of_statement=*/false,
 857         /*is_start_of_basic_block=*/false, /*is_prologue_end=*/false,
 858         /*is_epilogue_begin=*/false, /*is_terminal_entry=*/true);
 859     sequences.push_back(std::move(line_seq_up));
 860     line_seq_up = LineTable::CreateLineSequenceContainer();
 861   };
 862
 863   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
 864       End(*m_objfile_sp);
 865   assert(Record::classify(*It) == Record::Func);
 866   for (++It; It != End; ++It) {
 867     // Skip INLINE records
 868     if (Record::classify(*It) == Record::Inline)
 869       continue;
 870
 871     auto record = LineRecord::parse(*It);
 872     if (!record)
 873       break;
 874
 875     record->Address += base;
 876
 877     if (next_addr && *next_addr != record->Address) {
 878       // Discontiguous entries. Finish off the previous sequence and reset.
 879       finish_sequence();
 880     }
 881     LineTable::AppendLineEntryToSequence(
 882         line_seq_up.get(), record->Address, record->LineNum, /*column=*/0,
 883         map[record->FileNum], /*is_start_of_statement=*/true,
 884         /*is_start_of_basic_block=*/false, /*is_prologue_end=*/false,
 885         /*is_epilogue_begin=*/false, /*is_terminal_entry=*/false);
 886     next_addr = record->Address + record->Size;
 887   }
 888   if (next_addr)
 889     finish_sequence();
 890   data.line_table_up = std::make_unique<LineTable>(&cu, std::move(sequences));
 891   data.support_files = map.translate(cu.GetPrimaryFile(), *m_files);
 892 }
 893
 894 void SymbolFileBreakpad::ParseUnwindData() {
 895   if (m_unwind_data)
 896     return;
 897   m_unwind_data.emplace();
 898
 899   Log *log = GetLog(LLDBLog::Symbols);
 900   addr_t base = GetBaseFileAddress();
 901   if (base == LLDB_INVALID_ADDRESS) {
 902     LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address "
 903                   "of object file.");
 904   }
 905
 906   for (LineIterator It(*m_objfile_sp, Record::StackCFI), End(*m_objfile_sp);
 907        It != End; ++It) {
 908     if (auto record = StackCFIRecord::parse(*It)) {
 909       if (record->Size)
 910         m_unwind_data->cfi.Append(UnwindMap::Entry(
 911             base + record->Address, *record->Size, It.GetBookmark()));
 912     } else
 913       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
 914   }
 915   m_unwind_data->cfi.Sort();
 916
 917   for (LineIterator It(*m_objfile_sp, Record::StackWin), End(*m_objfile_sp);
 918        It != End; ++It) {
 919     if (auto record = StackWinRecord::parse(*It)) {
 920       m_unwind_data->win.Append(UnwindMap::Entry(
 921           base + record->RVA, record->CodeSize, It.GetBookmark()));
 922     } else
 923       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
 924   }
 925   m_unwind_data->win.Sort();
 926 }
 927
 928 uint64_t SymbolFileBreakpad::GetDebugInfoSize() {
 929   // Breakpad files are all debug info.
 930   return m_objfile_sp->GetByteSize();
 931 }