1 //===-- Function.cpp --------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Symbol/Function.h" 11 #include "lldb/Core/Disassembler.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Core/Section.h" 14 #include "lldb/Host/Host.h" 15 #include "lldb/Symbol/ClangASTType.h" 16 #include "lldb/Symbol/CompileUnit.h" 17 #include "lldb/Symbol/LineTable.h" 18 #include "lldb/Symbol/SymbolFile.h" 19 #include "lldb/Symbol/SymbolVendor.h" 20 #include "llvm/Support/Casting.h" 21 22 using namespace lldb; 23 using namespace lldb_private; 24 25 //---------------------------------------------------------------------- 26 // Basic function information is contained in the FunctionInfo class. 27 // It is designed to contain the name, linkage name, and declaration 28 // location. 29 //---------------------------------------------------------------------- 30 FunctionInfo::FunctionInfo (const char *name, const Declaration *decl_ptr) : 31 m_name(name), 32 m_declaration(decl_ptr) 33 { 34 } 35 36 37 FunctionInfo::FunctionInfo (const ConstString& name, const Declaration *decl_ptr) : 38 m_name(name), 39 m_declaration(decl_ptr) 40 { 41 } 42 43 44 FunctionInfo::~FunctionInfo() 45 { 46 } 47 48 void 49 FunctionInfo::Dump(Stream *s, bool show_fullpaths) const 50 { 51 if (m_name) 52 *s << ", name = \"" << m_name << "\""; 53 m_declaration.Dump(s, show_fullpaths); 54 } 55 56 57 int 58 FunctionInfo::Compare(const FunctionInfo& a, const FunctionInfo& b) 59 { 60 int result = ConstString::Compare(a.GetName(), b.GetName()); 61 if (result) 62 return result; 63 64 return Declaration::Compare(a.m_declaration, b.m_declaration); 65 } 66 67 68 Declaration& 69 FunctionInfo::GetDeclaration() 70 { 71 return m_declaration; 72 } 73 74 const Declaration& 75 FunctionInfo::GetDeclaration() const 76 { 77 return m_declaration; 78 } 79 80 const ConstString& 81 FunctionInfo::GetName() const 82 { 83 return m_name; 84 } 85 86 size_t 87 FunctionInfo::MemorySize() const 88 { 89 return m_name.MemorySize() + m_declaration.MemorySize(); 90 } 91 92 93 InlineFunctionInfo::InlineFunctionInfo 94 ( 95 const char *name, 96 const char *mangled, 97 const Declaration *decl_ptr, 98 const Declaration *call_decl_ptr 99 ) : 100 FunctionInfo(name, decl_ptr), 101 m_mangled(ConstString(mangled), true), 102 m_call_decl (call_decl_ptr) 103 { 104 } 105 106 InlineFunctionInfo::InlineFunctionInfo 107 ( 108 const ConstString& name, 109 const Mangled &mangled, 110 const Declaration *decl_ptr, 111 const Declaration *call_decl_ptr 112 ) : 113 FunctionInfo(name, decl_ptr), 114 m_mangled(mangled), 115 m_call_decl (call_decl_ptr) 116 { 117 } 118 119 InlineFunctionInfo::~InlineFunctionInfo() 120 { 121 } 122 123 int 124 InlineFunctionInfo::Compare(const InlineFunctionInfo& a, const InlineFunctionInfo& b) 125 { 126 127 int result = FunctionInfo::Compare(a, b); 128 if (result) 129 return result; 130 // only compare the mangled names if both have them 131 return Mangled::Compare(a.m_mangled, a.m_mangled); 132 } 133 134 void 135 InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const 136 { 137 FunctionInfo::Dump(s, show_fullpaths); 138 if (m_mangled) 139 m_mangled.Dump(s); 140 } 141 142 void 143 InlineFunctionInfo::DumpStopContext (Stream *s) const 144 { 145 // s->Indent("[inlined] "); 146 s->Indent(); 147 if (m_mangled) 148 s->PutCString (m_mangled.GetName().AsCString()); 149 else 150 s->PutCString (m_name.AsCString()); 151 } 152 153 154 const ConstString & 155 InlineFunctionInfo::GetName () const 156 { 157 if (m_mangled) 158 return m_mangled.GetName(); 159 return m_name; 160 } 161 162 163 Declaration & 164 InlineFunctionInfo::GetCallSite () 165 { 166 return m_call_decl; 167 } 168 169 const Declaration & 170 InlineFunctionInfo::GetCallSite () const 171 { 172 return m_call_decl; 173 } 174 175 176 Mangled& 177 InlineFunctionInfo::GetMangled() 178 { 179 return m_mangled; 180 } 181 182 const Mangled& 183 InlineFunctionInfo::GetMangled() const 184 { 185 return m_mangled; 186 } 187 188 size_t 189 InlineFunctionInfo::MemorySize() const 190 { 191 return FunctionInfo::MemorySize() + m_mangled.MemorySize(); 192 } 193 194 //---------------------------------------------------------------------- 195 // 196 //---------------------------------------------------------------------- 197 Function::Function 198 ( 199 CompileUnit *comp_unit, 200 lldb::user_id_t func_uid, 201 lldb::user_id_t type_uid, 202 const Mangled &mangled, 203 Type * type, 204 const AddressRange& range 205 ) : 206 UserID (func_uid), 207 m_comp_unit (comp_unit), 208 m_type_uid (type_uid), 209 m_type (type), 210 m_mangled (mangled), 211 m_block (func_uid), 212 m_range (range), 213 m_frame_base (), 214 m_flags (), 215 m_prologue_byte_size (0) 216 { 217 m_block.SetParentScope(this); 218 assert(comp_unit != nullptr); 219 } 220 221 Function::Function 222 ( 223 CompileUnit *comp_unit, 224 lldb::user_id_t func_uid, 225 lldb::user_id_t type_uid, 226 const char *mangled, 227 Type *type, 228 const AddressRange &range 229 ) : 230 UserID (func_uid), 231 m_comp_unit (comp_unit), 232 m_type_uid (type_uid), 233 m_type (type), 234 m_mangled (ConstString(mangled), true), 235 m_block (func_uid), 236 m_range (range), 237 m_frame_base (), 238 m_flags (), 239 m_prologue_byte_size (0) 240 { 241 m_block.SetParentScope(this); 242 assert(comp_unit != nullptr); 243 } 244 245 246 Function::~Function() 247 { 248 } 249 250 void 251 Function::GetStartLineSourceInfo (FileSpec &source_file, uint32_t &line_no) 252 { 253 line_no = 0; 254 source_file.Clear(); 255 256 if (m_comp_unit == nullptr) 257 return; 258 259 if (m_type != nullptr && m_type->GetDeclaration().GetLine() != 0) 260 { 261 source_file = m_type->GetDeclaration().GetFile(); 262 line_no = m_type->GetDeclaration().GetLine(); 263 } 264 else 265 { 266 LineTable *line_table = m_comp_unit->GetLineTable(); 267 if (line_table == nullptr) 268 return; 269 270 LineEntry line_entry; 271 if (line_table->FindLineEntryByAddress (GetAddressRange().GetBaseAddress(), line_entry, nullptr)) 272 { 273 line_no = line_entry.line; 274 source_file = line_entry.file; 275 } 276 } 277 } 278 279 void 280 Function::GetEndLineSourceInfo (FileSpec &source_file, uint32_t &line_no) 281 { 282 line_no = 0; 283 source_file.Clear(); 284 285 // The -1 is kind of cheesy, but I want to get the last line entry for the given function, not the 286 // first entry of the next. 287 Address scratch_addr(GetAddressRange().GetBaseAddress()); 288 scratch_addr.SetOffset (scratch_addr.GetOffset() + GetAddressRange().GetByteSize() - 1); 289 290 LineTable *line_table = m_comp_unit->GetLineTable(); 291 if (line_table == nullptr) 292 return; 293 294 LineEntry line_entry; 295 if (line_table->FindLineEntryByAddress (scratch_addr, line_entry, nullptr)) 296 { 297 line_no = line_entry.line; 298 source_file = line_entry.file; 299 } 300 } 301 302 Block & 303 Function::GetBlock (bool can_create) 304 { 305 if (!m_block.BlockInfoHasBeenParsed() && can_create) 306 { 307 SymbolContext sc; 308 CalculateSymbolContext(&sc); 309 if (sc.module_sp) 310 { 311 sc.module_sp->GetSymbolVendor()->ParseFunctionBlocks(sc); 312 } 313 else 314 { 315 Host::SystemLog (Host::eSystemLogError, 316 "error: unable to find module shared pointer for function '%s' in %s\n", 317 GetName().GetCString(), 318 m_comp_unit->GetPath().c_str()); 319 } 320 m_block.SetBlockInfoHasBeenParsed (true, true); 321 } 322 return m_block; 323 } 324 325 CompileUnit* 326 Function::GetCompileUnit() 327 { 328 return m_comp_unit; 329 } 330 331 const CompileUnit* 332 Function::GetCompileUnit() const 333 { 334 return m_comp_unit; 335 } 336 337 338 void 339 Function::GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) 340 { 341 Type* func_type = GetType(); 342 const char *name = func_type ? func_type->GetName().AsCString() : "<unknown>"; 343 344 *s << "id = " << (const UserID&)*this << ", name = \"" << name << "\", range = "; 345 346 Address::DumpStyle fallback_style; 347 if (level == eDescriptionLevelVerbose) 348 fallback_style = Address::DumpStyleModuleWithFileAddress; 349 else 350 fallback_style = Address::DumpStyleFileAddress; 351 GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, fallback_style); 352 } 353 354 void 355 Function::Dump(Stream *s, bool show_context) const 356 { 357 s->Printf("%p: ", static_cast<const void*>(this)); 358 s->Indent(); 359 *s << "Function" << static_cast<const UserID&>(*this); 360 361 m_mangled.Dump(s); 362 363 if (m_type) 364 s->Printf(", type = %p", static_cast<void*>(m_type)); 365 else if (m_type_uid != LLDB_INVALID_UID) 366 s->Printf(", type_uid = 0x%8.8" PRIx64, m_type_uid); 367 368 s->EOL(); 369 // Dump the root object 370 if (m_block.BlockInfoHasBeenParsed ()) 371 m_block.Dump(s, m_range.GetBaseAddress().GetFileAddress(), INT_MAX, show_context); 372 } 373 374 375 void 376 Function::CalculateSymbolContext(SymbolContext* sc) 377 { 378 sc->function = this; 379 m_comp_unit->CalculateSymbolContext(sc); 380 } 381 382 ModuleSP 383 Function::CalculateSymbolContextModule () 384 { 385 SectionSP section_sp (m_range.GetBaseAddress().GetSection()); 386 if (section_sp) 387 return section_sp->GetModule(); 388 389 return this->GetCompileUnit()->GetModule(); 390 } 391 392 CompileUnit * 393 Function::CalculateSymbolContextCompileUnit () 394 { 395 return this->GetCompileUnit(); 396 } 397 398 Function * 399 Function::CalculateSymbolContextFunction () 400 { 401 return this; 402 } 403 404 lldb::DisassemblerSP 405 Function::GetInstructions (const ExecutionContext &exe_ctx, 406 const char *flavor, 407 bool prefer_file_cache) 408 { 409 ModuleSP module_sp (GetAddressRange().GetBaseAddress().GetModule()); 410 if (module_sp) 411 { 412 const bool prefer_file_cache = false; 413 return Disassembler::DisassembleRange (module_sp->GetArchitecture(), 414 nullptr, 415 flavor, 416 exe_ctx, 417 GetAddressRange(), 418 prefer_file_cache); 419 } 420 return lldb::DisassemblerSP(); 421 } 422 423 bool 424 Function::GetDisassembly (const ExecutionContext &exe_ctx, 425 const char *flavor, 426 bool prefer_file_cache, 427 Stream &strm) 428 { 429 lldb::DisassemblerSP disassembler_sp = GetInstructions (exe_ctx, flavor, prefer_file_cache); 430 if (disassembler_sp) 431 { 432 const bool show_address = true; 433 const bool show_bytes = false; 434 disassembler_sp->GetInstructionList().Dump (&strm, show_address, show_bytes, &exe_ctx); 435 return true; 436 } 437 return false; 438 } 439 440 441 //Symbol * 442 //Function::CalculateSymbolContextSymbol () 443 //{ 444 // return // TODO: find the symbol for the function??? 445 //} 446 447 448 void 449 Function::DumpSymbolContext(Stream *s) 450 { 451 m_comp_unit->DumpSymbolContext(s); 452 s->Printf(", Function{0x%8.8" PRIx64 "}", GetID()); 453 } 454 455 size_t 456 Function::MemorySize () const 457 { 458 size_t mem_size = sizeof(Function) + m_block.MemorySize(); 459 return mem_size; 460 } 461 462 clang::DeclContext * 463 Function::GetClangDeclContext() 464 { 465 SymbolContext sc; 466 467 CalculateSymbolContext (&sc); 468 469 if (!sc.module_sp) 470 return nullptr; 471 472 SymbolVendor *sym_vendor = sc.module_sp->GetSymbolVendor(); 473 474 if (!sym_vendor) 475 return nullptr; 476 477 SymbolFile *sym_file = sym_vendor->GetSymbolFile(); 478 479 if (!sym_file) 480 return nullptr; 481 482 return sym_file->GetClangDeclContextForTypeUID (sc, m_uid); 483 } 484 485 Type* 486 Function::GetType() 487 { 488 if (m_type == nullptr) 489 { 490 SymbolContext sc; 491 492 CalculateSymbolContext (&sc); 493 494 if (!sc.module_sp) 495 return nullptr; 496 497 SymbolVendor *sym_vendor = sc.module_sp->GetSymbolVendor(); 498 499 if (sym_vendor == nullptr) 500 return nullptr; 501 502 SymbolFile *sym_file = sym_vendor->GetSymbolFile(); 503 504 if (sym_file == nullptr) 505 return nullptr; 506 507 m_type = sym_file->ResolveTypeUID(m_type_uid); 508 } 509 return m_type; 510 } 511 512 const Type* 513 Function::GetType() const 514 { 515 return m_type; 516 } 517 518 ClangASTType 519 Function::GetClangType() 520 { 521 Type *function_type = GetType(); 522 if (function_type) 523 return function_type->GetClangFullType(); 524 return ClangASTType(); 525 } 526 527 uint32_t 528 Function::GetPrologueByteSize () 529 { 530 if (m_prologue_byte_size == 0 && m_flags.IsClear(flagsCalculatedPrologueSize)) 531 { 532 m_flags.Set(flagsCalculatedPrologueSize); 533 LineTable* line_table = m_comp_unit->GetLineTable (); 534 if (line_table) 535 { 536 LineEntry first_line_entry; 537 uint32_t first_line_entry_idx = UINT32_MAX; 538 if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(), first_line_entry, &first_line_entry_idx)) 539 { 540 // Make sure the first line entry isn't already the end of the prologue 541 addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS; 542 if (first_line_entry.is_prologue_end) 543 { 544 prologue_end_file_addr = first_line_entry.range.GetBaseAddress().GetFileAddress(); 545 } 546 else 547 { 548 // Check the first few instructions and look for one that has 549 // is_prologue_end set to true. 550 const uint32_t last_line_entry_idx = first_line_entry_idx + 6; 551 for (uint32_t idx = first_line_entry_idx + 1; idx < last_line_entry_idx; ++idx) 552 { 553 LineEntry line_entry; 554 if (line_table->GetLineEntryAtIndex (idx, line_entry)) 555 { 556 if (line_entry.is_prologue_end) 557 { 558 prologue_end_file_addr = line_entry.range.GetBaseAddress().GetFileAddress(); 559 break; 560 } 561 } 562 } 563 } 564 565 // If we didn't find the end of the prologue in the line tables, 566 // then just use the end address of the first line table entry 567 if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) 568 { 569 // Check the first few instructions and look for one that has 570 // a line number that's different than the first entry. 571 const uint32_t last_line_entry_idx = first_line_entry_idx + 6; 572 for (uint32_t idx = first_line_entry_idx + 1; idx < last_line_entry_idx; ++idx) 573 { 574 LineEntry line_entry; 575 if (line_table->GetLineEntryAtIndex (idx, line_entry)) 576 { 577 if (line_entry.line != first_line_entry.line) 578 { 579 prologue_end_file_addr = line_entry.range.GetBaseAddress().GetFileAddress(); 580 break; 581 } 582 } 583 } 584 585 if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) 586 { 587 prologue_end_file_addr = first_line_entry.range.GetBaseAddress().GetFileAddress() + first_line_entry.range.GetByteSize(); 588 } 589 } 590 const addr_t func_start_file_addr = m_range.GetBaseAddress().GetFileAddress(); 591 const addr_t func_end_file_addr = func_start_file_addr + m_range.GetByteSize(); 592 593 // Verify that this prologue end file address in the function's 594 // address range just to be sure 595 if (func_start_file_addr < prologue_end_file_addr && prologue_end_file_addr < func_end_file_addr) 596 { 597 m_prologue_byte_size = prologue_end_file_addr - func_start_file_addr; 598 } 599 } 600 } 601 } 602 return m_prologue_byte_size; 603 } 604 605 606 607