715 lines · cpp
1//===-- Function.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-exception6//7//===----------------------------------------------------------------------===//8 9#include "lldb/Symbol/Function.h"10#include "lldb/Core/Debugger.h"11#include "lldb/Core/Disassembler.h"12#include "lldb/Core/Module.h"13#include "lldb/Core/ModuleList.h"14#include "lldb/Core/Section.h"15#include "lldb/Host/Host.h"16#include "lldb/Symbol/CompileUnit.h"17#include "lldb/Symbol/CompilerType.h"18#include "lldb/Symbol/LineTable.h"19#include "lldb/Symbol/SymbolFile.h"20#include "lldb/Target/Language.h"21#include "lldb/Target/Target.h"22#include "lldb/Utility/LLDBLog.h"23#include "lldb/Utility/Log.h"24#include "llvm/Support/Casting.h"25 26using namespace lldb;27using namespace lldb_private;28 29// Basic function information is contained in the FunctionInfo class. It is30// designed to contain the name, linkage name, and declaration location.31FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)32 : m_name(name), m_declaration(decl_ptr) {}33 34FunctionInfo::FunctionInfo(ConstString name, const Declaration *decl_ptr)35 : m_name(name), m_declaration(decl_ptr) {}36 37FunctionInfo::~FunctionInfo() = default;38 39void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const {40 if (m_name)41 *s << ", name = \"" << m_name << "\"";42 m_declaration.Dump(s, show_fullpaths);43}44 45int FunctionInfo::Compare(const FunctionInfo &a, const FunctionInfo &b) {46 int result = ConstString::Compare(a.GetName(), b.GetName());47 if (result)48 return result;49 50 return Declaration::Compare(a.m_declaration, b.m_declaration);51}52 53Declaration &FunctionInfo::GetDeclaration() { return m_declaration; }54 55const Declaration &FunctionInfo::GetDeclaration() const {56 return m_declaration;57}58 59ConstString FunctionInfo::GetName() const { return m_name; }60 61size_t FunctionInfo::MemorySize() const {62 return m_name.MemorySize() + m_declaration.MemorySize();63}64 65InlineFunctionInfo::InlineFunctionInfo(const char *name,66 llvm::StringRef mangled,67 const Declaration *decl_ptr,68 const Declaration *call_decl_ptr)69 : FunctionInfo(name, decl_ptr), m_mangled(mangled),70 m_call_decl(call_decl_ptr) {}71 72InlineFunctionInfo::InlineFunctionInfo(ConstString name,73 const Mangled &mangled,74 const Declaration *decl_ptr,75 const Declaration *call_decl_ptr)76 : FunctionInfo(name, decl_ptr), m_mangled(mangled),77 m_call_decl(call_decl_ptr) {}78 79InlineFunctionInfo::~InlineFunctionInfo() = default;80 81void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {82 FunctionInfo::Dump(s, show_fullpaths);83 if (m_mangled)84 m_mangled.Dump(s);85}86 87void InlineFunctionInfo::DumpStopContext(Stream *s) const {88 // s->Indent("[inlined] ");89 s->Indent();90 if (m_mangled)91 s->PutCString(m_mangled.GetName().AsCString());92 else93 s->PutCString(m_name.AsCString());94}95 96ConstString InlineFunctionInfo::GetName() const {97 if (m_mangled)98 return m_mangled.GetName();99 return m_name;100}101 102ConstString InlineFunctionInfo::GetDisplayName() const {103 if (m_mangled)104 return m_mangled.GetDisplayDemangledName();105 return m_name;106}107 108Declaration &InlineFunctionInfo::GetCallSite() { return m_call_decl; }109 110const Declaration &InlineFunctionInfo::GetCallSite() const {111 return m_call_decl;112}113 114Mangled &InlineFunctionInfo::GetMangled() { return m_mangled; }115 116const Mangled &InlineFunctionInfo::GetMangled() const { return m_mangled; }117 118size_t InlineFunctionInfo::MemorySize() const {119 return FunctionInfo::MemorySize() + m_mangled.MemorySize();120}121 122/// @name Call site related structures123/// @{124 125CallEdge::~CallEdge() = default;126 127CallEdge::CallEdge(AddrType caller_address_type, lldb::addr_t caller_address,128 bool is_tail_call, CallSiteParameterArray &¶meters)129 : caller_address(caller_address), caller_address_type(caller_address_type),130 is_tail_call(is_tail_call), parameters(std::move(parameters)) {}131 132lldb::addr_t CallEdge::GetLoadAddress(lldb::addr_t unresolved_pc,133 Function &caller, Target &target) {134 Log *log = GetLog(LLDBLog::Step);135 136 const Address &caller_start_addr = caller.GetAddress();137 138 ModuleSP caller_module_sp = caller_start_addr.GetModule();139 if (!caller_module_sp) {140 LLDB_LOG(log, "GetLoadAddress: cannot get Module for caller");141 return LLDB_INVALID_ADDRESS;142 }143 144 SectionList *section_list = caller_module_sp->GetSectionList();145 if (!section_list) {146 LLDB_LOG(log, "GetLoadAddress: cannot get SectionList for Module");147 return LLDB_INVALID_ADDRESS;148 }149 150 Address the_addr = Address(unresolved_pc, section_list);151 lldb::addr_t load_addr = the_addr.GetLoadAddress(&target);152 return load_addr;153}154 155lldb::addr_t CallEdge::GetReturnPCAddress(Function &caller,156 Target &target) const {157 return GetLoadAddress(GetUnresolvedReturnPCAddress(), caller, target);158}159 160void DirectCallEdge::ParseSymbolFileAndResolve(ModuleList &images) {161 if (resolved)162 return;163 164 Log *log = GetLog(LLDBLog::Step);165 LLDB_LOG(log, "DirectCallEdge: Lazily parsing the call graph for {0}",166 lazy_callee.symbol_name);167 168 auto resolve_lazy_callee = [&]() -> Function * {169 ConstString callee_name{lazy_callee.symbol_name};170 SymbolContextList sc_list;171 images.FindFunctionSymbols(callee_name, eFunctionNameTypeAuto, sc_list);172 size_t num_matches = sc_list.GetSize();173 if (num_matches == 0 || !sc_list[0].symbol) {174 LLDB_LOG(log,175 "DirectCallEdge: Found no symbols for {0}, cannot resolve it",176 callee_name);177 return nullptr;178 }179 Address callee_addr = sc_list[0].symbol->GetAddress();180 if (!callee_addr.IsValid()) {181 LLDB_LOG(log, "DirectCallEdge: Invalid symbol address");182 return nullptr;183 }184 Function *f = callee_addr.CalculateSymbolContextFunction();185 if (!f) {186 LLDB_LOG(log, "DirectCallEdge: Could not find complete function");187 return nullptr;188 }189 return f;190 };191 lazy_callee.def = resolve_lazy_callee();192 resolved = true;193}194 195DirectCallEdge::DirectCallEdge(const char *symbol_name,196 AddrType caller_address_type,197 lldb::addr_t caller_address, bool is_tail_call,198 CallSiteParameterArray &¶meters)199 : CallEdge(caller_address_type, caller_address, is_tail_call,200 std::move(parameters)) {201 lazy_callee.symbol_name = symbol_name;202}203 204Function *DirectCallEdge::GetCallee(ModuleList &images, ExecutionContext &) {205 ParseSymbolFileAndResolve(images);206 assert(resolved && "Did not resolve lazy callee");207 return lazy_callee.def;208}209 210IndirectCallEdge::IndirectCallEdge(DWARFExpressionList call_target,211 AddrType caller_address_type,212 lldb::addr_t caller_address,213 bool is_tail_call,214 CallSiteParameterArray &¶meters)215 : CallEdge(caller_address_type, caller_address, is_tail_call,216 std::move(parameters)),217 call_target(std::move(call_target)) {}218 219Function *IndirectCallEdge::GetCallee(ModuleList &images,220 ExecutionContext &exe_ctx) {221 Log *log = GetLog(LLDBLog::Step);222 Status error;223 llvm::Expected<Value> callee_addr_val = call_target.Evaluate(224 &exe_ctx, exe_ctx.GetRegisterContext(), LLDB_INVALID_ADDRESS,225 /*initial_value_ptr=*/nullptr,226 /*object_address_ptr=*/nullptr);227 if (!callee_addr_val) {228 LLDB_LOG_ERROR(log, callee_addr_val.takeError(),229 "IndirectCallEdge: Could not evaluate expression: {0}");230 return nullptr;231 }232 233 addr_t raw_addr =234 callee_addr_val->GetScalar().ULongLong(LLDB_INVALID_ADDRESS);235 if (raw_addr == LLDB_INVALID_ADDRESS) {236 LLDB_LOG(log, "IndirectCallEdge: Could not extract address from scalar");237 return nullptr;238 }239 240 Address callee_addr;241 if (!exe_ctx.GetTargetPtr()->ResolveLoadAddress(raw_addr, callee_addr)) {242 LLDB_LOG(log, "IndirectCallEdge: Could not resolve callee's load address");243 return nullptr;244 }245 246 Function *f = callee_addr.CalculateSymbolContextFunction();247 if (!f) {248 LLDB_LOG(log, "IndirectCallEdge: Could not find complete function");249 return nullptr;250 }251 252 return f;253}254 255/// @}256 257//258Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,259 lldb::user_id_t type_uid, const Mangled &mangled, Type *type,260 Address address, AddressRanges ranges)261 : UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),262 m_type(type), m_mangled(mangled), m_block(*this, func_uid),263 m_address(std::move(address)), m_prologue_byte_size(0) {264 assert(comp_unit != nullptr);265 lldb::addr_t base_file_addr = m_address.GetFileAddress();266 for (const AddressRange &range : ranges)267 m_block.AddRange(268 Block::Range(range.GetBaseAddress().GetFileAddress() - base_file_addr,269 range.GetByteSize()));270 m_block.FinalizeRanges();271}272 273Function::~Function() = default;274 275void Function::GetStartLineSourceInfo(SupportFileNSP &source_file_sp,276 uint32_t &line_no) {277 line_no = 0;278 source_file_sp = std::make_shared<SupportFile>();279 280 if (m_comp_unit == nullptr)281 return;282 283 // Initialize m_type if it hasn't been initialized already284 GetType();285 286 if (m_type != nullptr && m_type->GetDeclaration().GetLine() != 0) {287 source_file_sp =288 std::make_shared<SupportFile>(m_type->GetDeclaration().GetFile());289 line_no = m_type->GetDeclaration().GetLine();290 } else {291 LineTable *line_table = m_comp_unit->GetLineTable();292 if (line_table == nullptr)293 return;294 295 LineEntry line_entry;296 if (line_table->FindLineEntryByAddress(GetAddress(), line_entry, nullptr)) {297 line_no = line_entry.line;298 source_file_sp = line_entry.file_sp;299 }300 }301}302 303llvm::Expected<std::pair<SupportFileNSP, Function::SourceRange>>304Function::GetSourceInfo() {305 SupportFileNSP source_file_sp = std::make_shared<SupportFile>();306 uint32_t start_line;307 GetStartLineSourceInfo(source_file_sp, start_line);308 LineTable *line_table = m_comp_unit->GetLineTable();309 if (start_line == 0 || !line_table) {310 return llvm::createStringError(llvm::formatv(311 "Could not find line information for function \"{0}\".", GetName()));312 }313 314 uint32_t end_line = start_line;315 for (const AddressRange &range : GetAddressRanges()) {316 for (auto [idx, end] = line_table->GetLineEntryIndexRange(range); idx < end;317 ++idx) {318 LineEntry entry;319 // Ignore entries belonging to inlined functions or #included files.320 if (line_table->GetLineEntryAtIndex(idx, entry) &&321 source_file_sp->Equal(*entry.file_sp,322 SupportFile::eEqualFileSpecAndChecksumIfSet))323 end_line = std::max(end_line, entry.line);324 }325 }326 return std::make_pair(std::move(source_file_sp),327 SourceRange(start_line, end_line - start_line));328}329 330llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetCallEdges() {331 std::lock_guard<std::mutex> guard(m_call_edges_lock);332 333 if (m_call_edges_resolved)334 return m_call_edges;335 336 Log *log = GetLog(LLDBLog::Step);337 LLDB_LOG(log, "GetCallEdges: Attempting to parse call site info for {0}",338 GetDisplayName());339 340 m_call_edges_resolved = true;341 342 // Find the SymbolFile which provided this function's definition.343 Block &block = GetBlock(/*can_create*/true);344 SymbolFile *sym_file = block.GetSymbolFile();345 if (!sym_file)346 return {};347 348 // Lazily read call site information from the SymbolFile.349 m_call_edges = sym_file->ParseCallEdgesInFunction(GetID());350 351 // Sort the call edges to speed up return_pc lookups.352 llvm::sort(m_call_edges, [](const std::unique_ptr<CallEdge> &LHS,353 const std::unique_ptr<CallEdge> &RHS) {354 return LHS->GetSortKey() < RHS->GetSortKey();355 });356 357 return m_call_edges;358}359 360llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetTailCallingEdges() {361 // Tail calling edges are sorted at the end of the list. Find them by dropping362 // all non-tail-calls.363 return GetCallEdges().drop_until(364 [](const std::unique_ptr<CallEdge> &edge) { return edge->IsTailCall(); });365}366 367CallEdge *Function::GetCallEdgeForReturnAddress(addr_t return_pc,368 Target &target) {369 auto edges = GetCallEdges();370 auto edge_it =371 llvm::partition_point(edges, [&](const std::unique_ptr<CallEdge> &edge) {372 return std::make_pair(edge->IsTailCall(),373 edge->GetReturnPCAddress(*this, target)) <374 std::make_pair(false, return_pc);375 });376 if (edge_it == edges.end() ||377 edge_it->get()->GetReturnPCAddress(*this, target) != return_pc)378 return nullptr;379 return edge_it->get();380}381 382Block &Function::GetBlock(bool can_create) {383 if (!m_block.BlockInfoHasBeenParsed() && can_create) {384 ModuleSP module_sp = CalculateSymbolContextModule();385 if (module_sp) {386 module_sp->GetSymbolFile()->ParseBlocksRecursive(*this);387 } else {388 Debugger::ReportError(llvm::formatv(389 "unable to find module shared pointer for function '{0}' in {1}",390 GetName().GetCString(), m_comp_unit->GetPrimaryFile().GetPath()));391 }392 m_block.SetBlockInfoHasBeenParsed(true, true);393 }394 return m_block;395}396 397CompileUnit *Function::GetCompileUnit() { return m_comp_unit; }398 399const CompileUnit *Function::GetCompileUnit() const { return m_comp_unit; }400 401void Function::GetDescription(Stream *s, lldb::DescriptionLevel level,402 Target *target) {403 ConstString name = GetName();404 ConstString mangled = m_mangled.GetMangledName();405 406 *s << "id = " << (const UserID &)*this;407 if (name)408 s->AsRawOstream() << ", name = \"" << name << '"';409 if (mangled)410 s->AsRawOstream() << ", mangled = \"" << mangled << '"';411 if (level == eDescriptionLevelVerbose) {412 *s << ", decl_context = {";413 auto decl_context = GetCompilerContext();414 // Drop the function itself from the context chain.415 if (decl_context.size())416 decl_context.pop_back();417 llvm::interleaveComma(decl_context, *s, [&](auto &ctx) { ctx.Dump(*s); });418 *s << "}";419 }420 *s << ", range" << (m_block.GetNumRanges() > 1 ? "s" : "") << " = ";421 Address::DumpStyle fallback_style =422 level == eDescriptionLevelVerbose423 ? Address::DumpStyleModuleWithFileAddress424 : Address::DumpStyleFileAddress;425 for (unsigned idx = 0; idx < m_block.GetNumRanges(); ++idx) {426 AddressRange range;427 m_block.GetRangeAtIndex(idx, range);428 range.Dump(s, target, Address::DumpStyleLoadAddress, fallback_style);429 }430}431 432void Function::Dump(Stream *s, bool show_context) const {433 s->Printf("%p: ", static_cast<const void *>(this));434 s->Indent();435 *s << "Function" << static_cast<const UserID &>(*this);436 437 m_mangled.Dump(s);438 439 if (m_type)440 s->Printf(", type = %p", static_cast<void *>(m_type));441 else if (m_type_uid != LLDB_INVALID_UID)442 s->Printf(", type_uid = 0x%8.8" PRIx64, m_type_uid);443 444 s->EOL();445 // Dump the root object446 if (m_block.BlockInfoHasBeenParsed())447 m_block.Dump(s, m_address.GetFileAddress(), INT_MAX, show_context);448}449 450void Function::CalculateSymbolContext(SymbolContext *sc) {451 sc->function = this;452 m_comp_unit->CalculateSymbolContext(sc);453}454 455ModuleSP Function::CalculateSymbolContextModule() {456 if (SectionSP section_sp = m_address.GetSection())457 return section_sp->GetModule();458 459 return this->GetCompileUnit()->GetModule();460}461 462CompileUnit *Function::CalculateSymbolContextCompileUnit() {463 return this->GetCompileUnit();464}465 466Function *Function::CalculateSymbolContextFunction() { return this; }467 468lldb::DisassemblerSP Function::GetInstructions(const ExecutionContext &exe_ctx,469 const char *flavor,470 bool prefer_file_cache) {471 ModuleSP module_sp = GetAddress().GetModule();472 if (module_sp && exe_ctx.HasTargetScope()) {473 return Disassembler::DisassembleRange(474 module_sp->GetArchitecture(), nullptr, nullptr, nullptr, flavor,475 exe_ctx.GetTargetRef(), GetAddressRanges(), !prefer_file_cache);476 }477 return lldb::DisassemblerSP();478}479 480bool Function::GetDisassembly(const ExecutionContext &exe_ctx,481 const char *flavor, Stream &strm,482 bool prefer_file_cache) {483 lldb::DisassemblerSP disassembler_sp =484 GetInstructions(exe_ctx, flavor, prefer_file_cache);485 if (disassembler_sp) {486 const bool show_address = true;487 const bool show_bytes = false;488 const bool show_control_flow_kind = false;489 disassembler_sp->GetInstructionList().Dump(490 &strm, show_address, show_bytes, show_control_flow_kind, &exe_ctx);491 return true;492 }493 return false;494}495 496// Symbol *497// Function::CalculateSymbolContextSymbol ()498//{499// return // TODO: find the symbol for the function???500//}501 502void Function::DumpSymbolContext(Stream *s) {503 m_comp_unit->DumpSymbolContext(s);504 s->Printf(", Function{0x%8.8" PRIx64 "}", GetID());505}506 507size_t Function::MemorySize() const {508 size_t mem_size = sizeof(Function) + m_block.MemorySize();509 return mem_size;510}511 512bool Function::GetIsOptimized() {513 bool result = false;514 515 // Currently optimization is only indicted by the vendor extension516 // DW_AT_APPLE_optimized which is set on a compile unit level.517 if (m_comp_unit) {518 result = m_comp_unit->GetIsOptimized();519 }520 return result;521}522 523bool Function::IsTopLevelFunction() {524 bool result = false;525 526 if (Language *language = Language::FindPlugin(GetLanguage()))527 result = language->IsTopLevelFunction(*this);528 529 return result;530}531 532ConstString Function::GetDisplayName() const {533 return m_mangled.GetDisplayDemangledName();534}535 536CompilerDeclContext Function::GetDeclContext() {537 if (ModuleSP module_sp = CalculateSymbolContextModule())538 if (SymbolFile *sym_file = module_sp->GetSymbolFile())539 return sym_file->GetDeclContextForUID(GetID());540 return {};541}542 543std::vector<CompilerContext> Function::GetCompilerContext() {544 if (ModuleSP module_sp = CalculateSymbolContextModule())545 if (SymbolFile *sym_file = module_sp->GetSymbolFile())546 return sym_file->GetCompilerContextForUID(GetID());547 return {};548}549 550Type *Function::GetType() {551 if (m_type == nullptr) {552 SymbolContext sc;553 554 CalculateSymbolContext(&sc);555 556 if (!sc.module_sp)557 return nullptr;558 559 SymbolFile *sym_file = sc.module_sp->GetSymbolFile();560 561 if (sym_file == nullptr)562 return nullptr;563 564 m_type = sym_file->ResolveTypeUID(m_type_uid);565 }566 return m_type;567}568 569const Type *Function::GetType() const { return m_type; }570 571CompilerType Function::GetCompilerType() {572 Type *function_type = GetType();573 if (function_type)574 return function_type->GetFullCompilerType();575 return CompilerType();576}577 578uint32_t Function::GetPrologueByteSize() {579 if (m_prologue_byte_size == 0 &&580 m_flags.IsClear(flagsCalculatedPrologueSize)) {581 m_flags.Set(flagsCalculatedPrologueSize);582 LineTable *line_table = m_comp_unit->GetLineTable();583 uint32_t prologue_end_line_idx = 0;584 585 if (line_table) {586 LineEntry first_line_entry;587 uint32_t first_line_entry_idx = UINT32_MAX;588 if (line_table->FindLineEntryByAddress(GetAddress(), first_line_entry,589 &first_line_entry_idx)) {590 // Make sure the first line entry isn't already the end of the prologue591 addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS;592 addr_t line_zero_end_file_addr = LLDB_INVALID_ADDRESS;593 594 if (first_line_entry.is_prologue_end) {595 prologue_end_file_addr =596 first_line_entry.range.GetBaseAddress().GetFileAddress();597 prologue_end_line_idx = first_line_entry_idx;598 } else {599 // Check the first few instructions and look for one that has600 // is_prologue_end set to true.601 const uint32_t last_line_entry_idx = first_line_entry_idx + 6;602 for (uint32_t idx = first_line_entry_idx + 1;603 idx < last_line_entry_idx; ++idx) {604 LineEntry line_entry;605 if (line_table->GetLineEntryAtIndex(idx, line_entry)) {606 if (line_entry.is_prologue_end) {607 prologue_end_file_addr =608 line_entry.range.GetBaseAddress().GetFileAddress();609 prologue_end_line_idx = idx;610 break;611 }612 }613 }614 }615 616 // If we didn't find the end of the prologue in the line tables, then617 // just use the end address of the first line table entry618 if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {619 // Check the first few instructions and look for one that has a line620 // number that's different than the first entry.621 uint32_t last_line_entry_idx = first_line_entry_idx + 6;622 for (uint32_t idx = first_line_entry_idx + 1;623 idx < last_line_entry_idx; ++idx) {624 LineEntry line_entry;625 if (line_table->GetLineEntryAtIndex(idx, line_entry)) {626 if (line_entry.line != first_line_entry.line) {627 prologue_end_file_addr =628 line_entry.range.GetBaseAddress().GetFileAddress();629 prologue_end_line_idx = idx;630 break;631 }632 }633 }634 635 if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {636 prologue_end_file_addr =637 first_line_entry.range.GetBaseAddress().GetFileAddress() +638 first_line_entry.range.GetByteSize();639 prologue_end_line_idx = first_line_entry_idx;640 }641 }642 643 AddressRange entry_range;644 m_block.GetRangeContainingAddress(m_address, entry_range);645 646 // Deliberately not starting at entry_range.GetBaseAddress() because the647 // function entry point need not be the first address in the range.648 const addr_t func_start_file_addr = m_address.GetFileAddress();649 const addr_t range_end_file_addr =650 entry_range.GetBaseAddress().GetFileAddress() +651 entry_range.GetByteSize();652 653 // Now calculate the offset to pass the subsequent line 0 entries.654 uint32_t first_non_zero_line = prologue_end_line_idx;655 while (true) {656 LineEntry line_entry;657 if (line_table->GetLineEntryAtIndex(first_non_zero_line,658 line_entry)) {659 if (line_entry.line != 0)660 break;661 }662 if (line_entry.range.GetBaseAddress().GetFileAddress() >=663 range_end_file_addr)664 break;665 666 first_non_zero_line++;667 }668 669 if (first_non_zero_line > prologue_end_line_idx) {670 LineEntry first_non_zero_entry;671 if (line_table->GetLineEntryAtIndex(first_non_zero_line,672 first_non_zero_entry)) {673 line_zero_end_file_addr =674 first_non_zero_entry.range.GetBaseAddress().GetFileAddress();675 }676 }677 678 // Verify that this prologue end file address inside the function just679 // to be sure680 if (func_start_file_addr < prologue_end_file_addr &&681 prologue_end_file_addr < range_end_file_addr) {682 m_prologue_byte_size = prologue_end_file_addr - func_start_file_addr;683 }684 685 if (prologue_end_file_addr < line_zero_end_file_addr &&686 line_zero_end_file_addr < range_end_file_addr) {687 m_prologue_byte_size +=688 line_zero_end_file_addr - prologue_end_file_addr;689 }690 }691 }692 }693 694 return m_prologue_byte_size;695}696 697lldb::LanguageType Function::GetLanguage() const {698 lldb::LanguageType lang = m_mangled.GuessLanguage();699 if (lang != lldb::eLanguageTypeUnknown)700 return lang;701 702 if (m_comp_unit)703 return m_comp_unit->GetLanguage();704 705 return lldb::eLanguageTypeUnknown;706}707 708ConstString Function::GetName() const {709 return m_mangled.GetName();710}711 712ConstString Function::GetNameNoArguments() const {713 return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);714}715