source/Symbol/Function.cpp

   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