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-exception
6//
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 is
30// 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(lhs: a.GetName(), rhs: b.GetName());
47 if (result)
48 return result;
49
50 return Declaration::Compare(lhs: a.m_declaration, rhs: 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(cstr: m_mangled.GetName().AsCString());
92 else
93 s->PutCString(cstr: 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 structures
123/// @{
124
125CallEdge::~CallEdge() = default;
126
127CallEdge::CallEdge(AddrType caller_address_type, lldb::addr_t caller_address,
128 bool is_tail_call, CallSiteParameterArray &&parameters)
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(mask: 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: &target);
152 return load_addr;
153}
154
155lldb::addr_t CallEdge::GetReturnPCAddress(Function &caller,
156 Target &target) const {
157 return GetLoadAddress(unresolved_pc: GetUnresolvedReturnPCAddress(), caller, target);
158}
159
160void DirectCallEdge::ParseSymbolFileAndResolve(ModuleList &images) {
161 if (resolved)
162 return;
163
164 Log *log = GetLog(mask: 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(name: callee_name, name_type_mask: 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 &&parameters)
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 &&parameters)
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(mask: LLDBLog::Step);
222 Status error;
223 llvm::Expected<Value> callee_addr_val = call_target.Evaluate(
224 exe_ctx: &exe_ctx, reg_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(load_addr: raw_addr, so_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 range: Block::Range(range.GetBaseAddress().GetFileAddress() - base_file_addr,
269 range.GetByteSize()));
270 m_block.FinalizeRanges();
271}
272
273Function::~Function() = default;
274
275void Function::GetStartLineSourceInfo(SupportFileSP &source_file_sp,
276 uint32_t &line_no) {
277 line_no = 0;
278 source_file_sp.reset();
279
280 if (m_comp_unit == nullptr)
281 return;
282
283 // Initialize m_type if it hasn't been initialized already
284 GetType();
285
286 if (m_type != nullptr && m_type->GetDeclaration().GetLine() != 0) {
287 source_file_sp =
288 std::make_shared<SupportFile>(args: 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(so_addr: GetAddress(), line_entry, index_ptr: nullptr)) {
297 line_no = line_entry.line;
298 source_file_sp = line_entry.file_sp;
299 }
300 }
301}
302
303llvm::Expected<std::pair<SupportFileSP, Function::SourceRange>>
304Function::GetSourceInfo() {
305 SupportFileSP source_file_sp;
306 uint32_t start_line;
307 GetStartLineSourceInfo(source_file_sp, line_no&: start_line);
308 LineTable *line_table = m_comp_unit->GetLineTable();
309 if (start_line == 0 || !line_table) {
310 return llvm::createStringError(S: llvm::formatv(
311 Fmt: "Could not find line information for function \"{0}\".", Vals: 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, line_entry&: entry) &&
321 source_file_sp->Equal(other: *entry.file_sp,
322 equality: SupportFile::eEqualFileSpecAndChecksumIfSet))
323 end_line = std::max(a: end_line, b: entry.line);
324 }
325 }
326 return std::make_pair(x: std::move(source_file_sp),
327 y: 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(mask: 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 std::nullopt;
347
348 // Lazily read call site information from the SymbolFile.
349 m_call_edges = sym_file->ParseCallEdgesInFunction(func_id: GetID());
350
351 // Sort the call edges to speed up return_pc lookups.
352 llvm::sort(C&: m_call_edges, Comp: [](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 dropping
362 // all non-tail-calls.
363 return GetCallEdges().drop_until(
364 Pred: [](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(Range&: edges, P: [&](const std::unique_ptr<CallEdge> &edge) {
372 return std::make_pair(x: edge->IsTailCall(),
373 y: edge->GetReturnPCAddress(caller&: *this, target)) <
374 std::make_pair(x: false, y&: return_pc);
375 });
376 if (edge_it == edges.end() ||
377 edge_it->get()->GetReturnPCAddress(caller&: *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(func&: *this);
387 } else {
388 Debugger::ReportError(message: llvm::formatv(
389 Fmt: "unable to find module shared pointer for function '{0}' in {1}",
390 Vals: GetName().GetCString(), Vals: m_comp_unit->GetPrimaryFile().GetPath()));
391 }
392 m_block.SetBlockInfoHasBeenParsed(b: true, set_children: 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(c: decl_context, os&: *s, each_fn: [&](auto &ctx) { ctx.Dump(*s); });
418 *s << "}";
419 }
420 *s << ", range" << (m_block.GetNumRanges() > 1 ? "s" : "") << " = ";
421 Address::DumpStyle fallback_style =
422 level == eDescriptionLevelVerbose
423 ? Address::DumpStyleModuleWithFileAddress
424 : Address::DumpStyleFileAddress;
425 for (unsigned idx = 0; idx < m_block.GetNumRanges(); ++idx) {
426 AddressRange range;
427 m_block.GetRangeAtIndex(range_idx: idx, range);
428 range.Dump(s, target, style: Address::DumpStyleLoadAddress, fallback_style);
429 }
430}
431
432void Function::Dump(Stream *s, bool show_context) const {
433 s->Printf(format: "%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(format: ", type = %p", static_cast<void *>(m_type));
441 else if (m_type_uid != LLDB_INVALID_UID)
442 s->Printf(format: ", type_uid = 0x%8.8" PRIx64, m_type_uid);
443
444 s->EOL();
445 // Dump the root object
446 if (m_block.BlockInfoHasBeenParsed())
447 m_block.Dump(s, base_addr: 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 arch: module_sp->GetArchitecture(), plugin_name: nullptr, flavor: nullptr, cpu: nullptr, features: flavor,
475 target&: exe_ctx.GetTargetRef(), disasm_ranges: GetAddressRanges(), force_live_memory: !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 s: &strm, show_address, show_bytes, show_control_flow_kind, exe_ctx: &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(format: ", 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 extension
516 // 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(language: GetLanguage()))
527 result = language->IsTopLevelFunction(function&: *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(uid: 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(uid: GetID());
547 return {};
548}
549
550Type *Function::GetType() {
551 if (m_type == nullptr) {
552 SymbolContext sc;
553
554 CalculateSymbolContext(sc: &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(type_uid: 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(bit: 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(so_addr: GetAddress(), line_entry&: first_line_entry,
589 index_ptr: &first_line_entry_idx)) {
590 // Make sure the first line entry isn't already the end of the prologue
591 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 has
600 // 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, then
617 // just use the end address of the first line table entry
618 if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {
619 // Check the first few instructions and look for one that has a line
620 // 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(addr: m_address, range&: entry_range);
645
646 // Deliberately not starting at entry_range.GetBaseAddress() because the
647 // 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(idx: 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(idx: first_non_zero_line,
672 line_entry&: 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 just
679 // to be sure
680 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(preference: Mangled::ePreferDemangledWithoutArguments);
714}
715

source code of lldb/source/Symbol/Function.cpp