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/SymbolVendor.h" 19 #include "lldb/Symbol/TypeMap.h" 20 #include "lldb/Utility/Log.h" 21 #include "lldb/Utility/StreamString.h" 22 #include "llvm/ADT/StringExtras.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 using namespace lldb_private::breakpad; 27 28 char SymbolFileBreakpad::ID; 29 30 class SymbolFileBreakpad::LineIterator { 31 public: 32 // begin iterator for sections of given type 33 LineIterator(ObjectFile &obj, Record::Kind section_type) 34 : m_obj(&obj), m_section_type(toString(section_type)), 35 m_next_section_idx(0), m_next_line(llvm::StringRef::npos) { 36 ++*this; 37 } 38 39 // An iterator starting at the position given by the bookmark. 40 LineIterator(ObjectFile &obj, Record::Kind section_type, Bookmark bookmark); 41 42 // end iterator 43 explicit LineIterator(ObjectFile &obj) 44 : m_obj(&obj), 45 m_next_section_idx(m_obj->GetSectionList()->GetNumSections(0)), 46 m_current_line(llvm::StringRef::npos), 47 m_next_line(llvm::StringRef::npos) {} 48 49 friend bool operator!=(const LineIterator &lhs, const LineIterator &rhs) { 50 assert(lhs.m_obj == rhs.m_obj); 51 if (lhs.m_next_section_idx != rhs.m_next_section_idx) 52 return true; 53 if (lhs.m_current_line != rhs.m_current_line) 54 return true; 55 assert(lhs.m_next_line == rhs.m_next_line); 56 return false; 57 } 58 59 const LineIterator &operator++(); 60 llvm::StringRef operator*() const { 61 return m_section_text.slice(m_current_line, m_next_line); 62 } 63 64 Bookmark GetBookmark() const { 65 return Bookmark{m_next_section_idx, m_current_line}; 66 } 67 68 private: 69 ObjectFile *m_obj; 70 ConstString m_section_type; 71 uint32_t m_next_section_idx; 72 llvm::StringRef m_section_text; 73 size_t m_current_line; 74 size_t m_next_line; 75 76 void FindNextLine() { 77 m_next_line = m_section_text.find('\n', m_current_line); 78 if (m_next_line != llvm::StringRef::npos) { 79 ++m_next_line; 80 if (m_next_line >= m_section_text.size()) 81 m_next_line = llvm::StringRef::npos; 82 } 83 } 84 }; 85 86 SymbolFileBreakpad::LineIterator::LineIterator(ObjectFile &obj, 87 Record::Kind section_type, 88 Bookmark bookmark) 89 : m_obj(&obj), m_section_type(toString(section_type)), 90 m_next_section_idx(bookmark.section), m_current_line(bookmark.offset) { 91 Section § = 92 *obj.GetSectionList()->GetSectionAtIndex(m_next_section_idx - 1); 93 assert(sect.GetName() == m_section_type); 94 95 DataExtractor data; 96 obj.ReadSectionData(§, data); 97 m_section_text = toStringRef(data.GetData()); 98 99 assert(m_current_line < m_section_text.size()); 100 FindNextLine(); 101 } 102 103 const SymbolFileBreakpad::LineIterator & 104 SymbolFileBreakpad::LineIterator::operator++() { 105 const SectionList &list = *m_obj->GetSectionList(); 106 size_t num_sections = list.GetNumSections(0); 107 while (m_next_line != llvm::StringRef::npos || 108 m_next_section_idx < num_sections) { 109 if (m_next_line != llvm::StringRef::npos) { 110 m_current_line = m_next_line; 111 FindNextLine(); 112 return *this; 113 } 114 115 Section § = *list.GetSectionAtIndex(m_next_section_idx++); 116 if (sect.GetName() != m_section_type) 117 continue; 118 DataExtractor data; 119 m_obj->ReadSectionData(§, data); 120 m_section_text = toStringRef(data.GetData()); 121 m_next_line = 0; 122 } 123 // We've reached the end. 124 m_current_line = m_next_line; 125 return *this; 126 } 127 128 llvm::iterator_range<SymbolFileBreakpad::LineIterator> 129 SymbolFileBreakpad::lines(Record::Kind section_type) { 130 return llvm::make_range(LineIterator(*m_objfile_sp, section_type), 131 LineIterator(*m_objfile_sp)); 132 } 133 134 namespace { 135 // A helper class for constructing the list of support files for a given compile 136 // unit. 137 class SupportFileMap { 138 public: 139 // Given a breakpad file ID, return a file ID to be used in the support files 140 // for this compile unit. 141 size_t operator[](size_t file) { 142 return m_map.try_emplace(file, m_map.size() + 1).first->second; 143 } 144 145 // Construct a FileSpecList containing only the support files relevant for 146 // this compile unit (in the correct order). 147 FileSpecList translate(const FileSpec &cu_spec, 148 llvm::ArrayRef<FileSpec> all_files); 149 150 private: 151 llvm::DenseMap<size_t, size_t> m_map; 152 }; 153 } // namespace 154 155 FileSpecList SupportFileMap::translate(const FileSpec &cu_spec, 156 llvm::ArrayRef<FileSpec> all_files) { 157 std::vector<FileSpec> result; 158 result.resize(m_map.size() + 1); 159 result[0] = cu_spec; 160 for (const auto &KV : m_map) { 161 if (KV.first < all_files.size()) 162 result[KV.second] = all_files[KV.first]; 163 } 164 return FileSpecList(std::move(result)); 165 } 166 167 void SymbolFileBreakpad::Initialize() { 168 PluginManager::RegisterPlugin(GetPluginNameStatic(), 169 GetPluginDescriptionStatic(), CreateInstance, 170 DebuggerInitialize); 171 } 172 173 void SymbolFileBreakpad::Terminate() { 174 PluginManager::UnregisterPlugin(CreateInstance); 175 } 176 177 ConstString SymbolFileBreakpad::GetPluginNameStatic() { 178 static ConstString g_name("breakpad"); 179 return g_name; 180 } 181 182 uint32_t SymbolFileBreakpad::CalculateAbilities() { 183 if (!m_objfile_sp || !llvm::isa<ObjectFileBreakpad>(*m_objfile_sp)) 184 return 0; 185 186 return CompileUnits | Functions | LineTables; 187 } 188 189 uint32_t SymbolFileBreakpad::CalculateNumCompileUnits() { 190 ParseCUData(); 191 return m_cu_data->GetSize(); 192 } 193 194 CompUnitSP SymbolFileBreakpad::ParseCompileUnitAtIndex(uint32_t index) { 195 if (index >= m_cu_data->GetSize()) 196 return nullptr; 197 198 CompUnitData &data = m_cu_data->GetEntryRef(index).data; 199 200 ParseFileRecords(); 201 202 FileSpec spec; 203 204 // The FileSpec of the compile unit will be the file corresponding to the 205 // first LINE record. 206 LineIterator It(*m_objfile_sp, Record::Func, data.bookmark), 207 End(*m_objfile_sp); 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_objfile_sp->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 void SymbolFileBreakpad::FindFunctions( 295 ConstString name, const CompilerDeclContext *parent_decl_ctx, 296 FunctionNameType name_type_mask, bool include_inlines, 297 SymbolContextList &sc_list) { 298 // TODO 299 } 300 301 void SymbolFileBreakpad::FindFunctions(const RegularExpression ®ex, 302 bool include_inlines, 303 SymbolContextList &sc_list) { 304 // TODO 305 } 306 307 void SymbolFileBreakpad::FindTypes( 308 ConstString name, const CompilerDeclContext *parent_decl_ctx, 309 uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files, 310 TypeMap &types) {} 311 312 void SymbolFileBreakpad::FindTypes( 313 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages, 314 llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {} 315 316 void SymbolFileBreakpad::AddSymbols(Symtab &symtab) { 317 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); 318 Module &module = *m_objfile_sp->GetModule(); 319 addr_t base = GetBaseFileAddress(); 320 if (base == LLDB_INVALID_ADDRESS) { 321 LLDB_LOG(log, "Unable to fetch the base address of object file. Skipping " 322 "symtab population."); 323 return; 324 } 325 326 const SectionList &list = *module.GetSectionList(); 327 llvm::DenseMap<addr_t, Symbol> symbols; 328 auto add_symbol = [&](addr_t address, llvm::Optional<addr_t> size, 329 llvm::StringRef name) { 330 address += base; 331 SectionSP section_sp = list.FindSectionContainingFileAddress(address); 332 if (!section_sp) { 333 LLDB_LOG(log, 334 "Ignoring symbol {0}, whose address ({1}) is outside of the " 335 "object file. Mismatched symbol file?", 336 name, address); 337 return; 338 } 339 symbols.try_emplace( 340 address, /*symID*/ 0, Mangled(name), eSymbolTypeCode, 341 /*is_global*/ true, /*is_debug*/ false, 342 /*is_trampoline*/ false, /*is_artificial*/ false, 343 AddressRange(section_sp, address - section_sp->GetFileAddress(), 344 size.getValueOr(0)), 345 size.hasValue(), /*contains_linker_annotations*/ false, /*flags*/ 0); 346 }; 347 348 for (llvm::StringRef line : lines(Record::Func)) { 349 if (auto record = FuncRecord::parse(line)) 350 add_symbol(record->Address, record->Size, record->Name); 351 } 352 353 for (llvm::StringRef line : lines(Record::Public)) { 354 if (auto record = PublicRecord::parse(line)) 355 add_symbol(record->Address, llvm::None, record->Name); 356 else 357 LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line); 358 } 359 360 for (auto &KV : symbols) 361 symtab.AddSymbol(std::move(KV.second)); 362 symtab.CalculateSymbolSizes(); 363 } 364 365 llvm::Expected<lldb::addr_t> 366 SymbolFileBreakpad::GetParameterStackSize(Symbol &symbol) { 367 ParseUnwindData(); 368 if (auto *entry = m_unwind_data->win.FindEntryThatContains( 369 symbol.GetAddress().GetFileAddress())) { 370 auto record = StackWinRecord::parse( 371 *LineIterator(*m_objfile_sp, Record::StackWin, entry->data)); 372 assert(record.hasValue()); 373 return record->ParameterSize; 374 } 375 return llvm::createStringError(llvm::inconvertibleErrorCode(), 376 "Parameter size unknown."); 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 llvm::ArrayRef<uint8_t> SymbolFileBreakpad::SaveAsDWARF(postfix::Node &node) { 426 ArchSpec arch = m_objfile_sp->GetArchitecture(); 427 StreamString dwarf(Stream::eBinary, arch.GetAddressByteSize(), 428 arch.GetByteOrder()); 429 ToDWARF(node, dwarf); 430 uint8_t *saved = m_allocator.Allocate<uint8_t>(dwarf.GetSize()); 431 std::memcpy(saved, dwarf.GetData(), dwarf.GetSize()); 432 return {saved, dwarf.GetSize()}; 433 } 434 435 bool SymbolFileBreakpad::ParseCFIUnwindRow(llvm::StringRef unwind_rules, 436 const RegisterInfoResolver &resolver, 437 UnwindPlan::Row &row) { 438 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); 439 440 llvm::BumpPtrAllocator node_alloc; 441 while (auto rule = GetRule(unwind_rules)) { 442 node_alloc.Reset(); 443 llvm::StringRef lhs = rule->first; 444 postfix::Node *rhs = postfix::ParseOneExpression(rule->second, node_alloc); 445 if (!rhs) { 446 LLDB_LOG(log, "Could not parse `{0}` as unwind rhs.", rule->second); 447 return false; 448 } 449 450 bool success = postfix::ResolveSymbols( 451 rhs, [&](postfix::SymbolNode &symbol) -> postfix::Node * { 452 llvm::StringRef name = symbol.GetName(); 453 if (name == ".cfa" && lhs != ".cfa") 454 return postfix::MakeNode<postfix::InitialValueNode>(node_alloc); 455 456 if (const RegisterInfo *info = ResolveRegister(resolver, name)) { 457 return postfix::MakeNode<postfix::RegisterNode>( 458 node_alloc, info->kinds[eRegisterKindLLDB]); 459 } 460 return nullptr; 461 }); 462 463 if (!success) { 464 LLDB_LOG(log, "Resolving symbols in `{0}` failed.", rule->second); 465 return false; 466 } 467 468 llvm::ArrayRef<uint8_t> saved = SaveAsDWARF(*rhs); 469 if (lhs == ".cfa") { 470 row.GetCFAValue().SetIsDWARFExpression(saved.data(), saved.size()); 471 } else if (const RegisterInfo *info = ResolveRegisterOrRA(resolver, lhs)) { 472 UnwindPlan::Row::RegisterLocation loc; 473 loc.SetIsDWARFExpression(saved.data(), saved.size()); 474 row.SetRegisterInfo(info->kinds[eRegisterKindLLDB], loc); 475 } else 476 LLDB_LOG(log, "Invalid register `{0}` in unwind rule.", lhs); 477 } 478 if (unwind_rules.empty()) 479 return true; 480 481 LLDB_LOG(log, "Could not parse `{0}` as an unwind rule.", unwind_rules); 482 return false; 483 } 484 485 UnwindPlanSP 486 SymbolFileBreakpad::GetUnwindPlan(const Address &address, 487 const RegisterInfoResolver &resolver) { 488 ParseUnwindData(); 489 if (auto *entry = 490 m_unwind_data->cfi.FindEntryThatContains(address.GetFileAddress())) 491 return ParseCFIUnwindPlan(entry->data, resolver); 492 if (auto *entry = 493 m_unwind_data->win.FindEntryThatContains(address.GetFileAddress())) 494 return ParseWinUnwindPlan(entry->data, resolver); 495 return nullptr; 496 } 497 498 UnwindPlanSP 499 SymbolFileBreakpad::ParseCFIUnwindPlan(const Bookmark &bookmark, 500 const RegisterInfoResolver &resolver) { 501 addr_t base = GetBaseFileAddress(); 502 if (base == LLDB_INVALID_ADDRESS) 503 return nullptr; 504 505 LineIterator It(*m_objfile_sp, Record::StackCFI, bookmark), 506 End(*m_objfile_sp); 507 llvm::Optional<StackCFIRecord> init_record = StackCFIRecord::parse(*It); 508 assert(init_record.hasValue() && init_record->Size.hasValue() && 509 "Record already parsed successfully in ParseUnwindData!"); 510 511 auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB); 512 plan_sp->SetSourceName("breakpad STACK CFI"); 513 plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo); 514 plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo); 515 plan_sp->SetSourcedFromCompiler(eLazyBoolYes); 516 plan_sp->SetPlanValidAddressRange( 517 AddressRange(base + init_record->Address, *init_record->Size, 518 m_objfile_sp->GetModule()->GetSectionList())); 519 520 auto row_sp = std::make_shared<UnwindPlan::Row>(); 521 row_sp->SetOffset(0); 522 if (!ParseCFIUnwindRow(init_record->UnwindRules, resolver, *row_sp)) 523 return nullptr; 524 plan_sp->AppendRow(row_sp); 525 for (++It; It != End; ++It) { 526 llvm::Optional<StackCFIRecord> record = StackCFIRecord::parse(*It); 527 if (!record.hasValue()) 528 return nullptr; 529 if (record->Size.hasValue()) 530 break; 531 532 row_sp = std::make_shared<UnwindPlan::Row>(*row_sp); 533 row_sp->SetOffset(record->Address - init_record->Address); 534 if (!ParseCFIUnwindRow(record->UnwindRules, resolver, *row_sp)) 535 return nullptr; 536 plan_sp->AppendRow(row_sp); 537 } 538 return plan_sp; 539 } 540 541 UnwindPlanSP 542 SymbolFileBreakpad::ParseWinUnwindPlan(const Bookmark &bookmark, 543 const RegisterInfoResolver &resolver) { 544 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); 545 addr_t base = GetBaseFileAddress(); 546 if (base == LLDB_INVALID_ADDRESS) 547 return nullptr; 548 549 LineIterator It(*m_objfile_sp, Record::StackWin, bookmark); 550 llvm::Optional<StackWinRecord> record = StackWinRecord::parse(*It); 551 assert(record.hasValue() && 552 "Record already parsed successfully in ParseUnwindData!"); 553 554 auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB); 555 plan_sp->SetSourceName("breakpad STACK WIN"); 556 plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo); 557 plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo); 558 plan_sp->SetSourcedFromCompiler(eLazyBoolYes); 559 plan_sp->SetPlanValidAddressRange( 560 AddressRange(base + record->RVA, record->CodeSize, 561 m_objfile_sp->GetModule()->GetSectionList())); 562 563 auto row_sp = std::make_shared<UnwindPlan::Row>(); 564 row_sp->SetOffset(0); 565 566 llvm::BumpPtrAllocator node_alloc; 567 std::vector<std::pair<llvm::StringRef, postfix::Node *>> program = 568 postfix::ParseFPOProgram(record->ProgramString, node_alloc); 569 570 if (program.empty()) { 571 LLDB_LOG(log, "Invalid unwind rule: {0}.", record->ProgramString); 572 return nullptr; 573 } 574 auto it = program.begin(); 575 const auto &symbol_resolver = 576 [&](postfix::SymbolNode &symbol) -> postfix::Node * { 577 llvm::StringRef name = symbol.GetName(); 578 for (const auto &rule : llvm::make_range(program.begin(), it)) { 579 if (rule.first == name) 580 return rule.second; 581 } 582 if (const RegisterInfo *info = ResolveRegister(resolver, name)) 583 return postfix::MakeNode<postfix::RegisterNode>( 584 node_alloc, info->kinds[eRegisterKindLLDB]); 585 return nullptr; 586 }; 587 588 // We assume the first value will be the CFA. It is usually called T0, but 589 // clang will use T1, if it needs to realign the stack. 590 auto *symbol = llvm::dyn_cast<postfix::SymbolNode>(it->second); 591 if (symbol && symbol->GetName() == ".raSearch") { 592 row_sp->GetCFAValue().SetRaSearch(record->LocalSize + 593 record->SavedRegisterSize); 594 } else { 595 if (!postfix::ResolveSymbols(it->second, symbol_resolver)) { 596 LLDB_LOG(log, "Resolving symbols in `{0}` failed.", 597 record->ProgramString); 598 return nullptr; 599 } 600 llvm::ArrayRef<uint8_t> saved = SaveAsDWARF(*it->second); 601 row_sp->GetCFAValue().SetIsDWARFExpression(saved.data(), saved.size()); 602 } 603 604 // Replace the node value with InitialValueNode, so that subsequent 605 // expressions refer to the CFA value instead of recomputing the whole 606 // expression. 607 it->second = postfix::MakeNode<postfix::InitialValueNode>(node_alloc); 608 609 610 // Now process the rest of the assignments. 611 for (++it; it != program.end(); ++it) { 612 const RegisterInfo *info = ResolveRegister(resolver, it->first); 613 // It is not an error if the resolution fails because the program may 614 // contain temporary variables. 615 if (!info) 616 continue; 617 if (!postfix::ResolveSymbols(it->second, symbol_resolver)) { 618 LLDB_LOG(log, "Resolving symbols in `{0}` failed.", 619 record->ProgramString); 620 return nullptr; 621 } 622 623 llvm::ArrayRef<uint8_t> saved = SaveAsDWARF(*it->second); 624 UnwindPlan::Row::RegisterLocation loc; 625 loc.SetIsDWARFExpression(saved.data(), saved.size()); 626 row_sp->SetRegisterInfo(info->kinds[eRegisterKindLLDB], loc); 627 } 628 629 plan_sp->AppendRow(row_sp); 630 return plan_sp; 631 } 632 633 addr_t SymbolFileBreakpad::GetBaseFileAddress() { 634 return m_objfile_sp->GetModule() 635 ->GetObjectFile() 636 ->GetBaseAddress() 637 .GetFileAddress(); 638 } 639 640 // Parse out all the FILE records from the breakpad file. These will be needed 641 // when constructing the support file lists for individual compile units. 642 void SymbolFileBreakpad::ParseFileRecords() { 643 if (m_files) 644 return; 645 m_files.emplace(); 646 647 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); 648 for (llvm::StringRef line : lines(Record::File)) { 649 auto record = FileRecord::parse(line); 650 if (!record) { 651 LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", line); 652 continue; 653 } 654 655 if (record->Number >= m_files->size()) 656 m_files->resize(record->Number + 1); 657 FileSpec::Style style = FileSpec::GuessPathStyle(record->Name) 658 .getValueOr(FileSpec::Style::native); 659 (*m_files)[record->Number] = FileSpec(record->Name, style); 660 } 661 } 662 663 void SymbolFileBreakpad::ParseCUData() { 664 if (m_cu_data) 665 return; 666 667 m_cu_data.emplace(); 668 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); 669 addr_t base = GetBaseFileAddress(); 670 if (base == LLDB_INVALID_ADDRESS) { 671 LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address " 672 "of object file."); 673 } 674 675 // We shall create one compile unit for each FUNC record. So, count the number 676 // of FUNC records, and store them in m_cu_data, together with their ranges. 677 for (LineIterator It(*m_objfile_sp, Record::Func), End(*m_objfile_sp); 678 It != End; ++It) { 679 if (auto record = FuncRecord::parse(*It)) { 680 m_cu_data->Append(CompUnitMap::Entry(base + record->Address, record->Size, 681 CompUnitData(It.GetBookmark()))); 682 } else 683 LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It); 684 } 685 m_cu_data->Sort(); 686 } 687 688 // Construct the list of support files and line table entries for the given 689 // compile unit. 690 void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu, 691 CompUnitData &data) { 692 addr_t base = GetBaseFileAddress(); 693 assert(base != LLDB_INVALID_ADDRESS && 694 "How did we create compile units without a base address?"); 695 696 SupportFileMap map; 697 data.line_table_up = std::make_unique<LineTable>(&cu); 698 std::unique_ptr<LineSequence> line_seq_up( 699 data.line_table_up->CreateLineSequenceContainer()); 700 llvm::Optional<addr_t> next_addr; 701 auto finish_sequence = [&]() { 702 data.line_table_up->AppendLineEntryToSequence( 703 line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0, 704 /*file_idx*/ 0, /*is_start_of_statement*/ false, 705 /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false, 706 /*is_epilogue_begin*/ false, /*is_terminal_entry*/ true); 707 data.line_table_up->InsertSequence(line_seq_up.get()); 708 line_seq_up->Clear(); 709 }; 710 711 LineIterator It(*m_objfile_sp, Record::Func, data.bookmark), 712 End(*m_objfile_sp); 713 assert(Record::classify(*It) == Record::Func); 714 for (++It; It != End; ++It) { 715 auto record = LineRecord::parse(*It); 716 if (!record) 717 break; 718 719 record->Address += base; 720 721 if (next_addr && *next_addr != record->Address) { 722 // Discontiguous entries. Finish off the previous sequence and reset. 723 finish_sequence(); 724 } 725 data.line_table_up->AppendLineEntryToSequence( 726 line_seq_up.get(), record->Address, record->LineNum, /*column*/ 0, 727 map[record->FileNum], /*is_start_of_statement*/ true, 728 /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false, 729 /*is_epilogue_begin*/ false, /*is_terminal_entry*/ false); 730 next_addr = record->Address + record->Size; 731 } 732 if (next_addr) 733 finish_sequence(); 734 data.support_files = map.translate(cu.GetPrimaryFile(), *m_files); 735 } 736 737 void SymbolFileBreakpad::ParseUnwindData() { 738 if (m_unwind_data) 739 return; 740 m_unwind_data.emplace(); 741 742 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); 743 addr_t base = GetBaseFileAddress(); 744 if (base == LLDB_INVALID_ADDRESS) { 745 LLDB_LOG(log, "SymbolFile parsing failed: Unable to fetch the base address " 746 "of object file."); 747 } 748 749 for (LineIterator It(*m_objfile_sp, Record::StackCFI), End(*m_objfile_sp); 750 It != End; ++It) { 751 if (auto record = StackCFIRecord::parse(*It)) { 752 if (record->Size) 753 m_unwind_data->cfi.Append(UnwindMap::Entry( 754 base + record->Address, *record->Size, It.GetBookmark())); 755 } else 756 LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It); 757 } 758 m_unwind_data->cfi.Sort(); 759 760 for (LineIterator It(*m_objfile_sp, Record::StackWin), End(*m_objfile_sp); 761 It != End; ++It) { 762 if (auto record = StackWinRecord::parse(*It)) { 763 m_unwind_data->win.Append(UnwindMap::Entry( 764 base + record->RVA, record->CodeSize, It.GetBookmark())); 765 } else 766 LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It); 767 } 768 m_unwind_data->win.Sort(); 769 } 770