| //===-- Function.cpp ------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Symbol/Function.h" |
| #include "lldb/Core/Disassembler.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/ModuleList.h" |
| #include "lldb/Core/Section.h" |
| #include "lldb/Host/Host.h" |
| #include "lldb/Symbol/CompileUnit.h" |
| #include "lldb/Symbol/CompilerType.h" |
| #include "lldb/Symbol/LineTable.h" |
| #include "lldb/Symbol/SymbolFile.h" |
| #include "lldb/Target/Language.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Utility/Log.h" |
| #include "llvm/Support/Casting.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| // Basic function information is contained in the FunctionInfo class. It is |
| // designed to contain the name, linkage name, and declaration location. |
| FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr) |
| : m_name(name), m_declaration(decl_ptr) {} |
| |
| FunctionInfo::FunctionInfo(ConstString name, const Declaration *decl_ptr) |
| : m_name(name), m_declaration(decl_ptr) {} |
| |
| FunctionInfo::~FunctionInfo() = default; |
| |
| void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const { |
| if (m_name) |
| *s << ", name = \"" << m_name << "\""; |
| m_declaration.Dump(s, show_fullpaths); |
| } |
| |
| int FunctionInfo::Compare(const FunctionInfo &a, const FunctionInfo &b) { |
| int result = ConstString::Compare(a.GetName(), b.GetName()); |
| if (result) |
| return result; |
| |
| return Declaration::Compare(a.m_declaration, b.m_declaration); |
| } |
| |
| Declaration &FunctionInfo::GetDeclaration() { return m_declaration; } |
| |
| const Declaration &FunctionInfo::GetDeclaration() const { |
| return m_declaration; |
| } |
| |
| ConstString FunctionInfo::GetName() const { return m_name; } |
| |
| size_t FunctionInfo::MemorySize() const { |
| return m_name.MemorySize() + m_declaration.MemorySize(); |
| } |
| |
| InlineFunctionInfo::InlineFunctionInfo(const char *name, |
| llvm::StringRef mangled, |
| const Declaration *decl_ptr, |
| const Declaration *call_decl_ptr) |
| : FunctionInfo(name, decl_ptr), m_mangled(mangled), |
| m_call_decl(call_decl_ptr) {} |
| |
| InlineFunctionInfo::InlineFunctionInfo(ConstString name, |
| const Mangled &mangled, |
| const Declaration *decl_ptr, |
| const Declaration *call_decl_ptr) |
| : FunctionInfo(name, decl_ptr), m_mangled(mangled), |
| m_call_decl(call_decl_ptr) {} |
| |
| InlineFunctionInfo::~InlineFunctionInfo() = default; |
| |
| void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const { |
| FunctionInfo::Dump(s, show_fullpaths); |
| if (m_mangled) |
| m_mangled.Dump(s); |
| } |
| |
| void InlineFunctionInfo::DumpStopContext(Stream *s) const { |
| // s->Indent("[inlined] "); |
| s->Indent(); |
| if (m_mangled) |
| s->PutCString(m_mangled.GetName().AsCString()); |
| else |
| s->PutCString(m_name.AsCString()); |
| } |
| |
| ConstString InlineFunctionInfo::GetName() const { |
| if (m_mangled) |
| return m_mangled.GetName(); |
| return m_name; |
| } |
| |
| ConstString InlineFunctionInfo::GetDisplayName() const { |
| if (m_mangled) |
| return m_mangled.GetDisplayDemangledName(); |
| return m_name; |
| } |
| |
| Declaration &InlineFunctionInfo::GetCallSite() { return m_call_decl; } |
| |
| const Declaration &InlineFunctionInfo::GetCallSite() const { |
| return m_call_decl; |
| } |
| |
| Mangled &InlineFunctionInfo::GetMangled() { return m_mangled; } |
| |
| const Mangled &InlineFunctionInfo::GetMangled() const { return m_mangled; } |
| |
| size_t InlineFunctionInfo::MemorySize() const { |
| return FunctionInfo::MemorySize() + m_mangled.MemorySize(); |
| } |
| |
| /// @name Call site related structures |
| /// @{ |
| |
| lldb::addr_t CallEdge::GetLoadAddress(lldb::addr_t unresolved_pc, |
| Function &caller, Target &target) { |
| Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); |
| |
| const Address &caller_start_addr = caller.GetAddressRange().GetBaseAddress(); |
| |
| ModuleSP caller_module_sp = caller_start_addr.GetModule(); |
| if (!caller_module_sp) { |
| LLDB_LOG(log, "GetLoadAddress: cannot get Module for caller"); |
| return LLDB_INVALID_ADDRESS; |
| } |
| |
| SectionList *section_list = caller_module_sp->GetSectionList(); |
| if (!section_list) { |
| LLDB_LOG(log, "GetLoadAddress: cannot get SectionList for Module"); |
| return LLDB_INVALID_ADDRESS; |
| } |
| |
| Address the_addr = Address(unresolved_pc, section_list); |
| lldb::addr_t load_addr = the_addr.GetLoadAddress(&target); |
| return load_addr; |
| } |
| |
| lldb::addr_t CallEdge::GetReturnPCAddress(Function &caller, |
| Target &target) const { |
| return GetLoadAddress(GetUnresolvedReturnPCAddress(), caller, target); |
| } |
| |
| void DirectCallEdge::ParseSymbolFileAndResolve(ModuleList &images) { |
| if (resolved) |
| return; |
| |
| Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); |
| LLDB_LOG(log, "DirectCallEdge: Lazily parsing the call graph for {0}", |
| lazy_callee.symbol_name); |
| |
| auto resolve_lazy_callee = [&]() -> Function * { |
| ConstString callee_name{lazy_callee.symbol_name}; |
| SymbolContextList sc_list; |
| images.FindFunctionSymbols(callee_name, eFunctionNameTypeAuto, sc_list); |
| size_t num_matches = sc_list.GetSize(); |
| if (num_matches == 0 || !sc_list[0].symbol) { |
| LLDB_LOG(log, |
| "DirectCallEdge: Found no symbols for {0}, cannot resolve it", |
| callee_name); |
| return nullptr; |
| } |
| Address callee_addr = sc_list[0].symbol->GetAddress(); |
| if (!callee_addr.IsValid()) { |
| LLDB_LOG(log, "DirectCallEdge: Invalid symbol address"); |
| return nullptr; |
| } |
| Function *f = callee_addr.CalculateSymbolContextFunction(); |
| if (!f) { |
| LLDB_LOG(log, "DirectCallEdge: Could not find complete function"); |
| return nullptr; |
| } |
| return f; |
| }; |
| lazy_callee.def = resolve_lazy_callee(); |
| resolved = true; |
| } |
| |
| Function *DirectCallEdge::GetCallee(ModuleList &images, ExecutionContext &) { |
| ParseSymbolFileAndResolve(images); |
| assert(resolved && "Did not resolve lazy callee"); |
| return lazy_callee.def; |
| } |
| |
| Function *IndirectCallEdge::GetCallee(ModuleList &images, |
| ExecutionContext &exe_ctx) { |
| Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); |
| Status error; |
| Value callee_addr_val; |
| if (!call_target.Evaluate(&exe_ctx, exe_ctx.GetRegisterContext(), |
| /*loclist_base_addr=*/LLDB_INVALID_ADDRESS, |
| /*initial_value_ptr=*/nullptr, |
| /*object_address_ptr=*/nullptr, callee_addr_val, |
| &error)) { |
| LLDB_LOGF(log, "IndirectCallEdge: Could not evaluate expression: %s", |
| error.AsCString()); |
| return nullptr; |
| } |
| |
| addr_t raw_addr = callee_addr_val.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); |
| if (raw_addr == LLDB_INVALID_ADDRESS) { |
| LLDB_LOG(log, "IndirectCallEdge: Could not extract address from scalar"); |
| return nullptr; |
| } |
| |
| Address callee_addr; |
| if (!exe_ctx.GetTargetPtr()->ResolveLoadAddress(raw_addr, callee_addr)) { |
| LLDB_LOG(log, "IndirectCallEdge: Could not resolve callee's load address"); |
| return nullptr; |
| } |
| |
| Function *f = callee_addr.CalculateSymbolContextFunction(); |
| if (!f) { |
| LLDB_LOG(log, "IndirectCallEdge: Could not find complete function"); |
| return nullptr; |
| } |
| |
| return f; |
| } |
| |
| /// @} |
| |
| // |
| Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid, |
| lldb::user_id_t type_uid, const Mangled &mangled, Type *type, |
| const AddressRange &range) |
| : UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid), |
| m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range), |
| m_frame_base(), m_flags(), m_prologue_byte_size(0) { |
| m_block.SetParentScope(this); |
| assert(comp_unit != nullptr); |
| } |
| |
| Function::~Function() = default; |
| |
| void Function::GetStartLineSourceInfo(FileSpec &source_file, |
| uint32_t &line_no) { |
| line_no = 0; |
| source_file.Clear(); |
| |
| if (m_comp_unit == nullptr) |
| return; |
| |
| // Initialize m_type if it hasn't been initialized already |
| GetType(); |
| |
| if (m_type != nullptr && m_type->GetDeclaration().GetLine() != 0) { |
| source_file = m_type->GetDeclaration().GetFile(); |
| line_no = m_type->GetDeclaration().GetLine(); |
| } else { |
| LineTable *line_table = m_comp_unit->GetLineTable(); |
| if (line_table == nullptr) |
| return; |
| |
| LineEntry line_entry; |
| if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(), |
| line_entry, nullptr)) { |
| line_no = line_entry.line; |
| source_file = line_entry.file; |
| } |
| } |
| } |
| |
| void Function::GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no) { |
| line_no = 0; |
| source_file.Clear(); |
| |
| // The -1 is kind of cheesy, but I want to get the last line entry for the |
| // given function, not the first entry of the next. |
| Address scratch_addr(GetAddressRange().GetBaseAddress()); |
| scratch_addr.SetOffset(scratch_addr.GetOffset() + |
| GetAddressRange().GetByteSize() - 1); |
| |
| LineTable *line_table = m_comp_unit->GetLineTable(); |
| if (line_table == nullptr) |
| return; |
| |
| LineEntry line_entry; |
| if (line_table->FindLineEntryByAddress(scratch_addr, line_entry, nullptr)) { |
| line_no = line_entry.line; |
| source_file = line_entry.file; |
| } |
| } |
| |
| llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetCallEdges() { |
| std::lock_guard<std::mutex> guard(m_call_edges_lock); |
| |
| if (m_call_edges_resolved) |
| return m_call_edges; |
| |
| Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); |
| LLDB_LOG(log, "GetCallEdges: Attempting to parse call site info for {0}", |
| GetDisplayName()); |
| |
| m_call_edges_resolved = true; |
| |
| // Find the SymbolFile which provided this function's definition. |
| Block &block = GetBlock(/*can_create*/true); |
| SymbolFile *sym_file = block.GetSymbolFile(); |
| if (!sym_file) |
| return llvm::None; |
| |
| // Lazily read call site information from the SymbolFile. |
| m_call_edges = sym_file->ParseCallEdgesInFunction(GetID()); |
| |
| // Sort the call edges to speed up return_pc lookups. |
| llvm::sort(m_call_edges, [](const std::unique_ptr<CallEdge> &LHS, |
| const std::unique_ptr<CallEdge> &RHS) { |
| return LHS->GetSortKey() < RHS->GetSortKey(); |
| }); |
| |
| return m_call_edges; |
| } |
| |
| llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetTailCallingEdges() { |
| // Tail calling edges are sorted at the end of the list. Find them by dropping |
| // all non-tail-calls. |
| return GetCallEdges().drop_until( |
| [](const std::unique_ptr<CallEdge> &edge) { return edge->IsTailCall(); }); |
| } |
| |
| CallEdge *Function::GetCallEdgeForReturnAddress(addr_t return_pc, |
| Target &target) { |
| auto edges = GetCallEdges(); |
| auto edge_it = |
| llvm::partition_point(edges, [&](const std::unique_ptr<CallEdge> &edge) { |
| return std::make_pair(edge->IsTailCall(), |
| edge->GetReturnPCAddress(*this, target)) < |
| std::make_pair(false, return_pc); |
| }); |
| if (edge_it == edges.end() || |
| edge_it->get()->GetReturnPCAddress(*this, target) != return_pc) |
| return nullptr; |
| return edge_it->get(); |
| } |
| |
| Block &Function::GetBlock(bool can_create) { |
| if (!m_block.BlockInfoHasBeenParsed() && can_create) { |
| ModuleSP module_sp = CalculateSymbolContextModule(); |
| if (module_sp) { |
| module_sp->GetSymbolFile()->ParseBlocksRecursive(*this); |
| } else { |
| Host::SystemLog(Host::eSystemLogError, |
| "error: unable to find module " |
| "shared pointer for function '%s' " |
| "in %s\n", |
| GetName().GetCString(), |
| m_comp_unit->GetPrimaryFile().GetPath().c_str()); |
| } |
| m_block.SetBlockInfoHasBeenParsed(true, true); |
| } |
| return m_block; |
| } |
| |
| CompileUnit *Function::GetCompileUnit() { return m_comp_unit; } |
| |
| const CompileUnit *Function::GetCompileUnit() const { return m_comp_unit; } |
| |
| void Function::GetDescription(Stream *s, lldb::DescriptionLevel level, |
| Target *target) { |
| ConstString name = GetName(); |
| ConstString mangled = m_mangled.GetMangledName(); |
| |
| *s << "id = " << (const UserID &)*this; |
| if (name) |
| s->AsRawOstream() << ", name = \"" << name << '"'; |
| if (mangled) |
| s->AsRawOstream() << ", mangled = \"" << mangled << '"'; |
| *s << ", range = "; |
| Address::DumpStyle fallback_style; |
| if (level == eDescriptionLevelVerbose) |
| fallback_style = Address::DumpStyleModuleWithFileAddress; |
| else |
| fallback_style = Address::DumpStyleFileAddress; |
| GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, |
| fallback_style); |
| } |
| |
| void Function::Dump(Stream *s, bool show_context) const { |
| s->Printf("%p: ", static_cast<const void *>(this)); |
| s->Indent(); |
| *s << "Function" << static_cast<const UserID &>(*this); |
| |
| m_mangled.Dump(s); |
| |
| if (m_type) |
| s->Printf(", type = %p", static_cast<void *>(m_type)); |
| else if (m_type_uid != LLDB_INVALID_UID) |
| s->Printf(", type_uid = 0x%8.8" PRIx64, m_type_uid); |
| |
| s->EOL(); |
| // Dump the root object |
| if (m_block.BlockInfoHasBeenParsed()) |
| m_block.Dump(s, m_range.GetBaseAddress().GetFileAddress(), INT_MAX, |
| show_context); |
| } |
| |
| void Function::CalculateSymbolContext(SymbolContext *sc) { |
| sc->function = this; |
| m_comp_unit->CalculateSymbolContext(sc); |
| } |
| |
| ModuleSP Function::CalculateSymbolContextModule() { |
| SectionSP section_sp(m_range.GetBaseAddress().GetSection()); |
| if (section_sp) |
| return section_sp->GetModule(); |
| |
| return this->GetCompileUnit()->GetModule(); |
| } |
| |
| CompileUnit *Function::CalculateSymbolContextCompileUnit() { |
| return this->GetCompileUnit(); |
| } |
| |
| Function *Function::CalculateSymbolContextFunction() { return this; } |
| |
| lldb::DisassemblerSP Function::GetInstructions(const ExecutionContext &exe_ctx, |
| const char *flavor, |
| bool prefer_file_cache) { |
| ModuleSP module_sp(GetAddressRange().GetBaseAddress().GetModule()); |
| if (module_sp && exe_ctx.HasTargetScope()) { |
| return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr, |
| flavor, exe_ctx.GetTargetRef(), |
| GetAddressRange(), !prefer_file_cache); |
| } |
| return lldb::DisassemblerSP(); |
| } |
| |
| bool Function::GetDisassembly(const ExecutionContext &exe_ctx, |
| const char *flavor, Stream &strm, |
| bool prefer_file_cache) { |
| lldb::DisassemblerSP disassembler_sp = |
| GetInstructions(exe_ctx, flavor, prefer_file_cache); |
| if (disassembler_sp) { |
| const bool show_address = true; |
| const bool show_bytes = false; |
| disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes, |
| &exe_ctx); |
| return true; |
| } |
| return false; |
| } |
| |
| // Symbol * |
| // Function::CalculateSymbolContextSymbol () |
| //{ |
| // return // TODO: find the symbol for the function??? |
| //} |
| |
| void Function::DumpSymbolContext(Stream *s) { |
| m_comp_unit->DumpSymbolContext(s); |
| s->Printf(", Function{0x%8.8" PRIx64 "}", GetID()); |
| } |
| |
| size_t Function::MemorySize() const { |
| size_t mem_size = sizeof(Function) + m_block.MemorySize(); |
| return mem_size; |
| } |
| |
| bool Function::GetIsOptimized() { |
| bool result = false; |
| |
| // Currently optimization is only indicted by the vendor extension |
| // DW_AT_APPLE_optimized which is set on a compile unit level. |
| if (m_comp_unit) { |
| result = m_comp_unit->GetIsOptimized(); |
| } |
| return result; |
| } |
| |
| bool Function::IsTopLevelFunction() { |
| bool result = false; |
| |
| if (Language *language = Language::FindPlugin(GetLanguage())) |
| result = language->IsTopLevelFunction(*this); |
| |
| return result; |
| } |
| |
| ConstString Function::GetDisplayName() const { |
| return m_mangled.GetDisplayDemangledName(); |
| } |
| |
| CompilerDeclContext Function::GetDeclContext() { |
| ModuleSP module_sp = CalculateSymbolContextModule(); |
| |
| if (module_sp) { |
| if (SymbolFile *sym_file = module_sp->GetSymbolFile()) |
| return sym_file->GetDeclContextForUID(GetID()); |
| } |
| return CompilerDeclContext(); |
| } |
| |
| Type *Function::GetType() { |
| if (m_type == nullptr) { |
| SymbolContext sc; |
| |
| CalculateSymbolContext(&sc); |
| |
| if (!sc.module_sp) |
| return nullptr; |
| |
| SymbolFile *sym_file = sc.module_sp->GetSymbolFile(); |
| |
| if (sym_file == nullptr) |
| return nullptr; |
| |
| m_type = sym_file->ResolveTypeUID(m_type_uid); |
| } |
| return m_type; |
| } |
| |
| const Type *Function::GetType() const { return m_type; } |
| |
| CompilerType Function::GetCompilerType() { |
| Type *function_type = GetType(); |
| if (function_type) |
| return function_type->GetFullCompilerType(); |
| return CompilerType(); |
| } |
| |
| uint32_t Function::GetPrologueByteSize() { |
| if (m_prologue_byte_size == 0 && |
| m_flags.IsClear(flagsCalculatedPrologueSize)) { |
| m_flags.Set(flagsCalculatedPrologueSize); |
| LineTable *line_table = m_comp_unit->GetLineTable(); |
| uint32_t prologue_end_line_idx = 0; |
| |
| if (line_table) { |
| LineEntry first_line_entry; |
| uint32_t first_line_entry_idx = UINT32_MAX; |
| if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(), |
| first_line_entry, |
| &first_line_entry_idx)) { |
| // Make sure the first line entry isn't already the end of the prologue |
| addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS; |
| addr_t line_zero_end_file_addr = LLDB_INVALID_ADDRESS; |
| |
| if (first_line_entry.is_prologue_end) { |
| prologue_end_file_addr = |
| first_line_entry.range.GetBaseAddress().GetFileAddress(); |
| prologue_end_line_idx = first_line_entry_idx; |
| } else { |
| // Check the first few instructions and look for one that has |
| // is_prologue_end set to true. |
| const uint32_t last_line_entry_idx = first_line_entry_idx + 6; |
| for (uint32_t idx = first_line_entry_idx + 1; |
| idx < last_line_entry_idx; ++idx) { |
| LineEntry line_entry; |
| if (line_table->GetLineEntryAtIndex(idx, line_entry)) { |
| if (line_entry.is_prologue_end) { |
| prologue_end_file_addr = |
| line_entry.range.GetBaseAddress().GetFileAddress(); |
| prologue_end_line_idx = idx; |
| break; |
| } |
| } |
| } |
| } |
| |
| // If we didn't find the end of the prologue in the line tables, then |
| // just use the end address of the first line table entry |
| if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) { |
| // Check the first few instructions and look for one that has a line |
| // number that's different than the first entry. |
| uint32_t last_line_entry_idx = first_line_entry_idx + 6; |
| for (uint32_t idx = first_line_entry_idx + 1; |
| idx < last_line_entry_idx; ++idx) { |
| LineEntry line_entry; |
| if (line_table->GetLineEntryAtIndex(idx, line_entry)) { |
| if (line_entry.line != first_line_entry.line) { |
| prologue_end_file_addr = |
| line_entry.range.GetBaseAddress().GetFileAddress(); |
| prologue_end_line_idx = idx; |
| break; |
| } |
| } |
| } |
| |
| if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) { |
| prologue_end_file_addr = |
| first_line_entry.range.GetBaseAddress().GetFileAddress() + |
| first_line_entry.range.GetByteSize(); |
| prologue_end_line_idx = first_line_entry_idx; |
| } |
| } |
| |
| const addr_t func_start_file_addr = |
| m_range.GetBaseAddress().GetFileAddress(); |
| const addr_t func_end_file_addr = |
| func_start_file_addr + m_range.GetByteSize(); |
| |
| // Now calculate the offset to pass the subsequent line 0 entries. |
| uint32_t first_non_zero_line = prologue_end_line_idx; |
| while (true) { |
| LineEntry line_entry; |
| if (line_table->GetLineEntryAtIndex(first_non_zero_line, |
| line_entry)) { |
| if (line_entry.line != 0) |
| break; |
| } |
| if (line_entry.range.GetBaseAddress().GetFileAddress() >= |
| func_end_file_addr) |
| break; |
| |
| first_non_zero_line++; |
| } |
| |
| if (first_non_zero_line > prologue_end_line_idx) { |
| LineEntry first_non_zero_entry; |
| if (line_table->GetLineEntryAtIndex(first_non_zero_line, |
| first_non_zero_entry)) { |
| line_zero_end_file_addr = |
| first_non_zero_entry.range.GetBaseAddress().GetFileAddress(); |
| } |
| } |
| |
| // Verify that this prologue end file address in the function's address |
| // range just to be sure |
| if (func_start_file_addr < prologue_end_file_addr && |
| prologue_end_file_addr < func_end_file_addr) { |
| m_prologue_byte_size = prologue_end_file_addr - func_start_file_addr; |
| } |
| |
| if (prologue_end_file_addr < line_zero_end_file_addr && |
| line_zero_end_file_addr < func_end_file_addr) { |
| m_prologue_byte_size += |
| line_zero_end_file_addr - prologue_end_file_addr; |
| } |
| } |
| } |
| } |
| |
| return m_prologue_byte_size; |
| } |
| |
| lldb::LanguageType Function::GetLanguage() const { |
| lldb::LanguageType lang = m_mangled.GuessLanguage(); |
| if (lang != lldb::eLanguageTypeUnknown) |
| return lang; |
| |
| if (m_comp_unit) |
| return m_comp_unit->GetLanguage(); |
| |
| return lldb::eLanguageTypeUnknown; |
| } |
| |
| ConstString Function::GetName() const { |
| return m_mangled.GetName(); |
| } |
| |
| ConstString Function::GetNameNoArguments() const { |
| return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments); |
| } |