LLDB  mainline
Function.cpp
Go to the documentation of this file.
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/Disassembler.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ModuleList.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Host/Host.h"
17 #include "lldb/Symbol/LineTable.h"
18 #include "lldb/Symbol/SymbolFile.h"
19 #include "lldb/Target/Language.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Utility/LLDBLog.h"
22 #include "lldb/Utility/Log.h"
23 #include "llvm/Support/Casting.h"
24 
25 using namespace lldb;
26 using namespace lldb_private;
27 
28 // Basic function information is contained in the FunctionInfo class. It is
29 // designed to contain the name, linkage name, and declaration location.
30 FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)
31  : m_name(name), m_declaration(decl_ptr) {}
32 
34  : m_name(name), m_declaration(decl_ptr) {}
35 
36 FunctionInfo::~FunctionInfo() = default;
37 
38 void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
39  if (m_name)
40  *s << ", name = \"" << m_name << "\"";
41  m_declaration.Dump(s, show_fullpaths);
42 }
43 
45  int result = ConstString::Compare(a.GetName(), b.GetName());
46  if (result)
47  return result;
48 
50 }
51 
53 
55  return m_declaration;
56 }
57 
59 
60 size_t FunctionInfo::MemorySize() const {
62 }
63 
65  llvm::StringRef mangled,
66  const Declaration *decl_ptr,
67  const Declaration *call_decl_ptr)
68  : FunctionInfo(name, decl_ptr), m_mangled(mangled),
69  m_call_decl(call_decl_ptr) {}
70 
72  const Mangled &mangled,
73  const Declaration *decl_ptr,
74  const Declaration *call_decl_ptr)
75  : FunctionInfo(name, decl_ptr), m_mangled(mangled),
76  m_call_decl(call_decl_ptr) {}
77 
79 
80 void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
81  FunctionInfo::Dump(s, show_fullpaths);
82  if (m_mangled)
83  m_mangled.Dump(s);
84 }
85 
87  // s->Indent("[inlined] ");
88  s->Indent();
89  if (m_mangled)
90  s->PutCString(m_mangled.GetName().AsCString());
91  else
93 }
94 
96  if (m_mangled)
97  return m_mangled.GetName();
98  return m_name;
99 }
100 
102  if (m_mangled)
103  return m_mangled.GetDisplayDemangledName();
104  return m_name;
105 }
106 
108 
110  return m_call_decl;
111 }
112 
114 
115 const Mangled &InlineFunctionInfo::GetMangled() const { return m_mangled; }
116 
118  return FunctionInfo::MemorySize() + m_mangled.MemorySize();
119 }
120 
121 /// @name Call site related structures
122 /// @{
123 
125  Function &caller, Target &target) {
126  Log *log = GetLog(LLDBLog::Step);
127 
128  const Address &caller_start_addr = caller.GetAddressRange().GetBaseAddress();
129 
130  ModuleSP caller_module_sp = caller_start_addr.GetModule();
131  if (!caller_module_sp) {
132  LLDB_LOG(log, "GetLoadAddress: cannot get Module for caller");
133  return LLDB_INVALID_ADDRESS;
134  }
135 
136  SectionList *section_list = caller_module_sp->GetSectionList();
137  if (!section_list) {
138  LLDB_LOG(log, "GetLoadAddress: cannot get SectionList for Module");
139  return LLDB_INVALID_ADDRESS;
140  }
141 
142  Address the_addr = Address(unresolved_pc, section_list);
143  lldb::addr_t load_addr = the_addr.GetLoadAddress(&target);
144  return load_addr;
145 }
146 
148  Target &target) const {
149  return GetLoadAddress(GetUnresolvedReturnPCAddress(), caller, target);
150 }
151 
153  if (resolved)
154  return;
155 
156  Log *log = GetLog(LLDBLog::Step);
157  LLDB_LOG(log, "DirectCallEdge: Lazily parsing the call graph for {0}",
158  lazy_callee.symbol_name);
159 
160  auto resolve_lazy_callee = [&]() -> Function * {
161  ConstString callee_name{lazy_callee.symbol_name};
162  SymbolContextList sc_list;
163  images.FindFunctionSymbols(callee_name, eFunctionNameTypeAuto, sc_list);
164  size_t num_matches = sc_list.GetSize();
165  if (num_matches == 0 || !sc_list[0].symbol) {
166  LLDB_LOG(log,
167  "DirectCallEdge: Found no symbols for {0}, cannot resolve it",
168  callee_name);
169  return nullptr;
170  }
171  Address callee_addr = sc_list[0].symbol->GetAddress();
172  if (!callee_addr.IsValid()) {
173  LLDB_LOG(log, "DirectCallEdge: Invalid symbol address");
174  return nullptr;
175  }
176  Function *f = callee_addr.CalculateSymbolContextFunction();
177  if (!f) {
178  LLDB_LOG(log, "DirectCallEdge: Could not find complete function");
179  return nullptr;
180  }
181  return f;
182  };
183  lazy_callee.def = resolve_lazy_callee();
184  resolved = true;
185 }
186 
189  assert(resolved && "Did not resolve lazy callee");
190  return lazy_callee.def;
191 }
192 
194  ExecutionContext &exe_ctx) {
195  Log *log = GetLog(LLDBLog::Step);
196  Status error;
197  Value callee_addr_val;
198  if (!call_target.Evaluate(&exe_ctx, exe_ctx.GetRegisterContext(),
199  /*loclist_base_load_addr=*/LLDB_INVALID_ADDRESS,
200  /*initial_value_ptr=*/nullptr,
201  /*object_address_ptr=*/nullptr, callee_addr_val,
202  &error)) {
203  LLDB_LOGF(log, "IndirectCallEdge: Could not evaluate expression: %s",
204  error.AsCString());
205  return nullptr;
206  }
207 
208  addr_t raw_addr = callee_addr_val.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
209  if (raw_addr == LLDB_INVALID_ADDRESS) {
210  LLDB_LOG(log, "IndirectCallEdge: Could not extract address from scalar");
211  return nullptr;
212  }
213 
214  Address callee_addr;
215  if (!exe_ctx.GetTargetPtr()->ResolveLoadAddress(raw_addr, callee_addr)) {
216  LLDB_LOG(log, "IndirectCallEdge: Could not resolve callee's load address");
217  return nullptr;
218  }
219 
220  Function *f = callee_addr.CalculateSymbolContextFunction();
221  if (!f) {
222  LLDB_LOG(log, "IndirectCallEdge: Could not find complete function");
223  return nullptr;
224  }
225 
226  return f;
227 }
228 
229 /// @}
230 
231 //
233  lldb::user_id_t type_uid, const Mangled &mangled, Type *type,
234  const AddressRange &range)
235  : UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),
236  m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range),
237  m_frame_base(), m_flags(), m_prologue_byte_size(0) {
238  m_block.SetParentScope(this);
239  assert(comp_unit != nullptr);
240 }
241 
242 Function::~Function() = default;
243 
245  uint32_t &line_no) {
246  line_no = 0;
247  source_file.Clear();
248 
249  if (m_comp_unit == nullptr)
250  return;
251 
252  // Initialize m_type if it hasn't been initialized already
253  GetType();
254 
255  if (m_type != nullptr && m_type->GetDeclaration().GetLine() != 0) {
256  source_file = m_type->GetDeclaration().GetFile();
257  line_no = m_type->GetDeclaration().GetLine();
258  } else {
259  LineTable *line_table = m_comp_unit->GetLineTable();
260  if (line_table == nullptr)
261  return;
262 
263  LineEntry line_entry;
264  if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(),
265  line_entry, nullptr)) {
266  line_no = line_entry.line;
267  source_file = line_entry.file;
268  }
269  }
270 }
271 
272 void Function::GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no) {
273  line_no = 0;
274  source_file.Clear();
275 
276  // The -1 is kind of cheesy, but I want to get the last line entry for the
277  // given function, not the first entry of the next.
278  Address scratch_addr(GetAddressRange().GetBaseAddress());
279  scratch_addr.SetOffset(scratch_addr.GetOffset() +
280  GetAddressRange().GetByteSize() - 1);
281 
282  LineTable *line_table = m_comp_unit->GetLineTable();
283  if (line_table == nullptr)
284  return;
285 
286  LineEntry line_entry;
287  if (line_table->FindLineEntryByAddress(scratch_addr, line_entry, nullptr)) {
288  line_no = line_entry.line;
289  source_file = line_entry.file;
290  }
291 }
292 
293 llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetCallEdges() {
294  std::lock_guard<std::mutex> guard(m_call_edges_lock);
295 
297  return m_call_edges;
298 
299  Log *log = GetLog(LLDBLog::Step);
300  LLDB_LOG(log, "GetCallEdges: Attempting to parse call site info for {0}",
301  GetDisplayName());
302 
303  m_call_edges_resolved = true;
304 
305  // Find the SymbolFile which provided this function's definition.
306  Block &block = GetBlock(/*can_create*/true);
307  SymbolFile *sym_file = block.GetSymbolFile();
308  if (!sym_file)
309  return llvm::None;
310 
311  // Lazily read call site information from the SymbolFile.
313 
314  // Sort the call edges to speed up return_pc lookups.
315  llvm::sort(m_call_edges, [](const std::unique_ptr<CallEdge> &LHS,
316  const std::unique_ptr<CallEdge> &RHS) {
317  return LHS->GetSortKey() < RHS->GetSortKey();
318  });
319 
320  return m_call_edges;
321 }
322 
323 llvm::ArrayRef<std::unique_ptr<CallEdge>> Function::GetTailCallingEdges() {
324  // Tail calling edges are sorted at the end of the list. Find them by dropping
325  // all non-tail-calls.
326  return GetCallEdges().drop_until(
327  [](const std::unique_ptr<CallEdge> &edge) { return edge->IsTailCall(); });
328 }
329 
331  Target &target) {
332  auto edges = GetCallEdges();
333  auto edge_it =
334  llvm::partition_point(edges, [&](const std::unique_ptr<CallEdge> &edge) {
335  return std::make_pair(edge->IsTailCall(),
336  edge->GetReturnPCAddress(*this, target)) <
337  std::make_pair(false, return_pc);
338  });
339  if (edge_it == edges.end() ||
340  edge_it->get()->GetReturnPCAddress(*this, target) != return_pc)
341  return nullptr;
342  return edge_it->get();
343 }
344 
345 Block &Function::GetBlock(bool can_create) {
346  if (!m_block.BlockInfoHasBeenParsed() && can_create) {
347  ModuleSP module_sp = CalculateSymbolContextModule();
348  if (module_sp) {
349  module_sp->GetSymbolFile()->ParseBlocksRecursive(*this);
350  } else {
352  "error: unable to find module "
353  "shared pointer for function '%s' "
354  "in %s\n",
355  GetName().GetCString(),
356  m_comp_unit->GetPrimaryFile().GetPath().c_str());
357  }
359  }
360  return m_block;
361 }
362 
364 
365 const CompileUnit *Function::GetCompileUnit() const { return m_comp_unit; }
366 
368  Target *target) {
369  ConstString name = GetName();
370  ConstString mangled = m_mangled.GetMangledName();
371 
372  *s << "id = " << (const UserID &)*this;
373  if (name)
374  s->AsRawOstream() << ", name = \"" << name << '"';
375  if (mangled)
376  s->AsRawOstream() << ", mangled = \"" << mangled << '"';
377  *s << ", range = ";
378  Address::DumpStyle fallback_style;
379  if (level == eDescriptionLevelVerbose)
381  else
382  fallback_style = Address::DumpStyleFileAddress;
384  fallback_style);
385 }
386 
387 void Function::Dump(Stream *s, bool show_context) const {
388  s->Printf("%p: ", static_cast<const void *>(this));
389  s->Indent();
390  *s << "Function" << static_cast<const UserID &>(*this);
391 
392  m_mangled.Dump(s);
393 
394  if (m_type)
395  s->Printf(", type = %p", static_cast<void *>(m_type));
396  else if (m_type_uid != LLDB_INVALID_UID)
397  s->Printf(", type_uid = 0x%8.8" PRIx64, m_type_uid);
398 
399  s->EOL();
400  // Dump the root object
403  show_context);
404 }
405 
407  sc->function = this;
409 }
410 
412  SectionSP section_sp(m_range.GetBaseAddress().GetSection());
413  if (section_sp)
414  return section_sp->GetModule();
415 
416  return this->GetCompileUnit()->GetModule();
417 }
418 
420  return this->GetCompileUnit();
421 }
422 
424 
425 lldb::DisassemblerSP Function::GetInstructions(const ExecutionContext &exe_ctx,
426  const char *flavor,
427  bool prefer_file_cache) {
428  ModuleSP module_sp(GetAddressRange().GetBaseAddress().GetModule());
429  if (module_sp && exe_ctx.HasTargetScope()) {
430  return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
431  flavor, exe_ctx.GetTargetRef(),
432  GetAddressRange(), !prefer_file_cache);
433  }
434  return lldb::DisassemblerSP();
435 }
436 
438  const char *flavor, Stream &strm,
439  bool prefer_file_cache) {
440  lldb::DisassemblerSP disassembler_sp =
441  GetInstructions(exe_ctx, flavor, prefer_file_cache);
442  if (disassembler_sp) {
443  const bool show_address = true;
444  const bool show_bytes = false;
445  disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes,
446  &exe_ctx);
447  return true;
448  }
449  return false;
450 }
451 
452 // Symbol *
453 // Function::CalculateSymbolContextSymbol ()
454 //{
455 // return // TODO: find the symbol for the function???
456 //}
457 
460  s->Printf(", Function{0x%8.8" PRIx64 "}", GetID());
461 }
462 
463 size_t Function::MemorySize() const {
464  size_t mem_size = sizeof(Function) + m_block.MemorySize();
465  return mem_size;
466 }
467 
469  bool result = false;
470 
471  // Currently optimization is only indicted by the vendor extension
472  // DW_AT_APPLE_optimized which is set on a compile unit level.
473  if (m_comp_unit) {
474  result = m_comp_unit->GetIsOptimized();
475  }
476  return result;
477 }
478 
480  bool result = false;
481 
482  if (Language *language = Language::FindPlugin(GetLanguage()))
483  result = language->IsTopLevelFunction(*this);
484 
485  return result;
486 }
487 
489  return m_mangled.GetDisplayDemangledName();
490 }
491 
493  ModuleSP module_sp = CalculateSymbolContextModule();
494 
495  if (module_sp) {
496  if (SymbolFile *sym_file = module_sp->GetSymbolFile())
497  return sym_file->GetDeclContextForUID(GetID());
498  }
499  return CompilerDeclContext();
500 }
501 
503  if (m_type == nullptr) {
504  SymbolContext sc;
505 
507 
508  if (!sc.module_sp)
509  return nullptr;
510 
511  SymbolFile *sym_file = sc.module_sp->GetSymbolFile();
512 
513  if (sym_file == nullptr)
514  return nullptr;
515 
516  m_type = sym_file->ResolveTypeUID(m_type_uid);
517  }
518  return m_type;
519 }
520 
521 const Type *Function::GetType() const { return m_type; }
522 
524  Type *function_type = GetType();
525  if (function_type)
526  return function_type->GetFullCompilerType();
527  return CompilerType();
528 }
529 
531  if (m_prologue_byte_size == 0 &&
534  LineTable *line_table = m_comp_unit->GetLineTable();
535  uint32_t prologue_end_line_idx = 0;
536 
537  if (line_table) {
538  LineEntry first_line_entry;
539  uint32_t first_line_entry_idx = UINT32_MAX;
540  if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(),
541  first_line_entry,
542  &first_line_entry_idx)) {
543  // Make sure the first line entry isn't already the end of the prologue
544  addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS;
545  addr_t line_zero_end_file_addr = LLDB_INVALID_ADDRESS;
546 
547  if (first_line_entry.is_prologue_end) {
548  prologue_end_file_addr =
549  first_line_entry.range.GetBaseAddress().GetFileAddress();
550  prologue_end_line_idx = first_line_entry_idx;
551  } else {
552  // Check the first few instructions and look for one that has
553  // is_prologue_end set to true.
554  const uint32_t last_line_entry_idx = first_line_entry_idx + 6;
555  for (uint32_t idx = first_line_entry_idx + 1;
556  idx < last_line_entry_idx; ++idx) {
557  LineEntry line_entry;
558  if (line_table->GetLineEntryAtIndex(idx, line_entry)) {
559  if (line_entry.is_prologue_end) {
560  prologue_end_file_addr =
561  line_entry.range.GetBaseAddress().GetFileAddress();
562  prologue_end_line_idx = idx;
563  break;
564  }
565  }
566  }
567  }
568 
569  // If we didn't find the end of the prologue in the line tables, then
570  // just use the end address of the first line table entry
571  if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {
572  // Check the first few instructions and look for one that has a line
573  // number that's different than the first entry.
574  uint32_t last_line_entry_idx = first_line_entry_idx + 6;
575  for (uint32_t idx = first_line_entry_idx + 1;
576  idx < last_line_entry_idx; ++idx) {
577  LineEntry line_entry;
578  if (line_table->GetLineEntryAtIndex(idx, line_entry)) {
579  if (line_entry.line != first_line_entry.line) {
580  prologue_end_file_addr =
581  line_entry.range.GetBaseAddress().GetFileAddress();
582  prologue_end_line_idx = idx;
583  break;
584  }
585  }
586  }
587 
588  if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) {
589  prologue_end_file_addr =
590  first_line_entry.range.GetBaseAddress().GetFileAddress() +
591  first_line_entry.range.GetByteSize();
592  prologue_end_line_idx = first_line_entry_idx;
593  }
594  }
595 
596  const addr_t func_start_file_addr =
598  const addr_t func_end_file_addr =
599  func_start_file_addr + m_range.GetByteSize();
600 
601  // Now calculate the offset to pass the subsequent line 0 entries.
602  uint32_t first_non_zero_line = prologue_end_line_idx;
603  while (true) {
604  LineEntry line_entry;
605  if (line_table->GetLineEntryAtIndex(first_non_zero_line,
606  line_entry)) {
607  if (line_entry.line != 0)
608  break;
609  }
610  if (line_entry.range.GetBaseAddress().GetFileAddress() >=
611  func_end_file_addr)
612  break;
613 
614  first_non_zero_line++;
615  }
616 
617  if (first_non_zero_line > prologue_end_line_idx) {
618  LineEntry first_non_zero_entry;
619  if (line_table->GetLineEntryAtIndex(first_non_zero_line,
620  first_non_zero_entry)) {
621  line_zero_end_file_addr =
622  first_non_zero_entry.range.GetBaseAddress().GetFileAddress();
623  }
624  }
625 
626  // Verify that this prologue end file address in the function's address
627  // range just to be sure
628  if (func_start_file_addr < prologue_end_file_addr &&
629  prologue_end_file_addr < func_end_file_addr) {
630  m_prologue_byte_size = prologue_end_file_addr - func_start_file_addr;
631  }
632 
633  if (prologue_end_file_addr < line_zero_end_file_addr &&
634  line_zero_end_file_addr < func_end_file_addr) {
636  line_zero_end_file_addr - prologue_end_file_addr;
637  }
638  }
639  }
640  }
641 
642  return m_prologue_byte_size;
643 }
644 
646  lldb::LanguageType lang = m_mangled.GuessLanguage();
647  if (lang != lldb::eLanguageTypeUnknown)
648  return lang;
649 
650  if (m_comp_unit)
651  return m_comp_unit->GetLanguage();
652 
654 }
655 
657  return m_mangled.GetName();
658 }
659 
661  return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
662 }
lldb_private::ConstString::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: ConstString.h:397
lldb_private::LineTable::FindLineEntryByAddress
bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry, uint32_t *index_ptr=nullptr)
Find a line entry that contains the section offset address so_addr.
Definition: LineTable.cpp:188
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::Function::GetTailCallingEdges
llvm::ArrayRef< std::unique_ptr< CallEdge > > GetTailCallingEdges()
Get the outgoing tail-calling edges from this function.
Definition: Function.cpp:323
lldb_private::FunctionInfo::m_name
ConstString m_name
Function method name (not a mangled name).
Definition: Function.h:117
lldb_private::SymbolFile
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:45
lldb_private::Function::m_call_edges_resolved
bool m_call_edges_resolved
Whether call site info has been parsed.
Definition: Function.h:674
lldb_private::FunctionInfo::MemorySize
virtual size_t MemorySize() const
Get the memory cost of this object.
Definition: Function.cpp:60
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::SymbolFile::ParseCallEdgesInFunction
virtual std::vector< std::unique_ptr< CallEdge > > ParseCallEdgesInFunction(UserID func_id)
Definition: SymbolFile.h:282
lldb_private::Function::m_prologue_byte_size
uint32_t m_prologue_byte_size
Compute the prologue size once and cache it.
Definition: Function.h:667
lldb_private::LineEntry::file
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
lldb_private::Function::CalculateSymbolContextModule
lldb::ModuleSP CalculateSymbolContextModule() override
Definition: Function.cpp:411
lldb_private::ExecutionContext::HasTargetScope
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
Definition: ExecutionContext.cpp:379
lldb_private::Function::~Function
~Function() override
Destructor.
lldb_private::Block::SetBlockInfoHasBeenParsed
void SetBlockInfoHasBeenParsed(bool b, bool set_children)
Definition: Block.cpp:486
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
lldb_private::Function::m_range
AddressRange m_range
The function address range that covers the widest range needed to contain all blocks.
Definition: Function.h:658
CompileUnit.h
lldb_private::Address::CalculateSymbolContextFunction
Function * CalculateSymbolContextFunction() const
Definition: Address.cpp:865
lldb_private::Function::GetAddressRange
const AddressRange & GetAddressRange()
Definition: Function.h:457
lldb_private::Function::m_call_edges_lock
std::mutex m_call_edges_lock
Exclusive lock that controls read/write access to m_call_edges and m_call_edges_resolved.
Definition: Function.h:671
lldb_private::InlineFunctionInfo::Dump
void Dump(Stream *s, bool show_fullpaths) const
Dump a description of this object to a Stream.
Definition: Function.cpp:80
lldb_private::Value
Definition: Value.h:38
lldb_private::DirectCallEdge::GetCallee
Function * GetCallee(ModuleList &images, ExecutionContext &exe_ctx) override
Get the callee's definition.
Definition: Function.cpp:187
Host.h
lldb_private::ConstString::Compare
static int Compare(ConstString lhs, ConstString rhs, const bool case_sensitive=true)
Compare two string objects.
Definition: ConstString.cpp:258
lldb_private::Block::SetParentScope
void SetParentScope(SymbolContextScope *parent_scope)
Definition: Block.h:320
lldb_private::Address::DumpStyleFileAddress
@ DumpStyleFileAddress
Display as the file address (if any).
Definition: Address.h:84
lldb_private::UserID
Definition: UserID.h:31
lldb_private::Function::m_type
Type * m_type
The function prototype type for this function that includes the function info (FunctionInfo),...
Definition: Function.h:647
lldb_private::Function::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: Function.cpp:406
LLDB_INVALID_UID
#define LLDB_INVALID_UID
Definition: lldb-defines.h:80
lldb_private::LineEntry::is_prologue_end
uint16_t is_prologue_end
Indicates this entry is one (of possibly many) where execution should be suspended for an entry break...
Definition: LineEntry.h:155
lldb_private::Function::GetDisplayName
ConstString GetDisplayName() const
Definition: Function.cpp:488
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:270
lldb_private::AddressRange::GetByteSize
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:221
lldb_private::LineTable::GetLineEntryAtIndex
bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry)
Get the line entry from the line table at index idx.
Definition: LineTable.cpp:179
lldb_private::InlineFunctionInfo::m_mangled
Mangled m_mangled
Mangled inlined function name (can be empty if there is no mangled information).
Definition: Function.h:244
Module.h
lldb_private::FunctionInfo::~FunctionInfo
virtual ~FunctionInfo()
Destructor.
lldb_private::InlineFunctionInfo::GetCallSite
Declaration & GetCallSite()
Get accessor for the call site declaration information.
Definition: Function.cpp:107
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::Block::GetSymbolFile
SymbolFile * GetSymbolFile()
Get the symbol file which contains debug info for this block's symbol context module.
Definition: Block.cpp:474
lldb_private::Declaration::GetFile
FileSpec & GetFile()
Get accessor for file specification.
Definition: Declaration.h:107
lldb_private::Function::m_block
Block m_block
All lexical blocks contained in this function.
Definition: Function.h:654
lldb_private::SectionList
Definition: Section.h:34
Disassembler.h
lldb_private::Function::GetNameNoArguments
ConstString GetNameNoArguments() const
Definition: Function.cpp:660
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
Language.h
lldb_private::CallEdge::GetUnresolvedReturnPCAddress
lldb::addr_t GetUnresolvedReturnPCAddress() const
Like GetReturnPCAddress, but returns an unresolved file address.
Definition: Function.h:319
lldb_private::Function::GetInstructions
lldb::DisassemblerSP GetInstructions(const ExecutionContext &exe_ctx, const char *flavor, bool force_live_memory=false)
Definition: Function.cpp:425
lldb_private::Block::BlockInfoHasBeenParsed
bool BlockInfoHasBeenParsed() const
Definition: Block.h:335
lldb_private::Target::ResolveLoadAddress
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
Definition: Target.cpp:2893
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:464
Section.h
lldb_private::CompileUnit
Definition: CompileUnit.h:38
lldb_private::Function::DumpSymbolContext
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: Function.cpp:458
Target.h
lldb_private::Value::GetScalar
const Scalar & GetScalar() const
Definition: Value.h:112
lldb_private::FunctionInfo::Compare
static int Compare(const FunctionInfo &lhs, const FunctionInfo &rhs)
Compare two function information objects.
Definition: Function.cpp:44
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::Declaration::Dump
void Dump(Stream *s, bool show_fullpaths) const
Dump a description of this object to a Stream.
Definition: Declaration.cpp:14
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::LineTable
Definition: LineTable.h:40
lldb_private::Function
Definition: Function.h:409
lldb_private::ExecutionContext::GetRegisterContext
RegisterContext * GetRegisterContext() const
Definition: ExecutionContext.cpp:190
lldb_private::Disassembler::DisassembleRange
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, Target &target, const AddressRange &disasm_range, bool force_live_memory=false)
Definition: Disassembler.cpp:122
ModuleList.h
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
lldb_private::Function::GetCompileUnit
CompileUnit * GetCompileUnit()
Get accessor for the compile unit that owns this function.
Definition: Function.cpp:363
lldb_private::SymbolFile::ResolveTypeUID
virtual Type * ResolveTypeUID(lldb::user_id_t type_uid)=0
lldb_private::Address::DumpStyleLoadAddress
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:96
lldb_private::Function::GetName
ConstString GetName() const
Definition: Function.cpp:656
lldb_private::ModuleList
Definition: ModuleList.h:81
lldb_private::Scalar::ULongLong
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:334
Log.h
lldb_private::Function::GetBlock
Block & GetBlock(bool can_create)
Get accessor for the block list.
Definition: Function.cpp:345
lldb_private::Function::m_mangled
Mangled m_mangled
The mangled function name if any.
Definition: Function.h:651
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
lldb_private::Declaration::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: Declaration.cpp:56
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
lldb_private::InlineFunctionInfo::GetMangled
Mangled & GetMangled()
Get accessor for the mangled name object.
Definition: Function.cpp:113
lldb_private::InlineFunctionInfo::InlineFunctionInfo
InlineFunctionInfo(const char *name, llvm::StringRef mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr)
Construct with the function method name, mangled name, and optional declaration information.
Definition: Function.cpp:64
lldb_private::SymbolContextList::GetSize
uint32_t GetSize() const
Get accessor for a symbol context list size.
Definition: SymbolContext.cpp:1279
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::InlineFunctionInfo::m_call_decl
Declaration m_call_decl
Definition: Function.h:246
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::Function::Function
Function(CompileUnit *comp_unit, lldb::user_id_t func_uid, lldb::user_id_t func_type_uid, const Mangled &mangled, Type *func_type, const AddressRange &range)
Construct with a compile unit, function UID, function type UID, optional mangled name,...
Definition: Function.cpp:232
lldb_private::Host::SystemLog
static void SystemLog(SystemLogType type, const char *format,...) __attribute__((format(printf
Definition: common/Host.cpp:230
lldb_private::Type::GetDeclaration
const lldb_private::Declaration & GetDeclaration() const
Definition: Type.cpp:470
lldb_private::Block::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: Block.cpp:376
lldb_private::Function::GetDisassembly
bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor, Stream &strm, bool force_live_memory=false)
Definition: Function.cpp:437
lldb_private::CallEdge
Definition: Function.h:267
lldb_private::InlineFunctionInfo::GetName
ConstString GetName() const
Definition: Function.cpp:95
lldb_private::CompileUnit::GetIsOptimized
bool GetIsOptimized()
Get whether compiler optimizations were enabled for this compile unit.
Definition: CompileUnit.cpp:354
lldb_private::Function::GetIsOptimized
bool GetIsOptimized()
Get whether compiler optimizations were enabled for this function.
Definition: Function.cpp:468
lldb_private::CompileUnit::GetPrimaryFile
const FileSpec & GetPrimaryFile() const
Return the primary source file associated with this compile unit.
Definition: CompileUnit.h:227
lldb_private::Address::GetSection
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:429
lldb_private::CompileUnit::GetLineTable
LineTable * GetLineTable()
Get the line table for the compile unit.
Definition: CompileUnit.cpp:161
lldb_private::CompileUnit::GetLanguage
lldb::LanguageType GetLanguage()
Definition: CompileUnit.cpp:150
lldb_private::InlineFunctionInfo::DumpStopContext
void DumpStopContext(Stream *s) const
Definition: Function.cpp:86
CompilerType.h
lldb_private::LLDBLog::Step
@ Step
lldb_private::Address::DumpStyleModuleWithFileAddress
@ DumpStyleModuleWithFileAddress
Display as the file address with the module name prepended (if any).
Definition: Address.h:90
lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition: CompilerDeclContext.h:30
lldb_private::Language::FindPlugin
static Language * FindPlugin(lldb::LanguageType language)
Definition: Language.cpp:53
lldb_private::Function::GetCallEdgeForReturnAddress
CallEdge * GetCallEdgeForReturnAddress(lldb::addr_t return_pc, Target &target)
Get the outgoing call edge from this function which has the given return address return_pc,...
Definition: Function.cpp:330
lldb_private::LineEntry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::FunctionInfo::GetDeclaration
Declaration & GetDeclaration()
Get accessor for the declaration information.
Definition: Function.cpp:52
lldb_private::Function::GetStartLineSourceInfo
void GetStartLineSourceInfo(FileSpec &source_file, uint32_t &line_no)
Find the file and line number of the source location of the start of the function.
Definition: Function.cpp:244
lldb_private::FileSpec::Clear
void Clear()
Clears the object state.
Definition: FileSpec.cpp:259
lldb_private::Function::CalculateSymbolContextFunction
Function * CalculateSymbolContextFunction() override
Definition: Function.cpp:423
lldb_private::Declaration::GetLine
uint32_t GetLine() const
Get accessor for the declaration line number.
Definition: Declaration.h:120
lldb_private::InlineFunctionInfo::GetDisplayName
ConstString GetDisplayName() const
Definition: Function.cpp:101
lldb_private::Status
Definition: Status.h:44
lldb_private::InlineFunctionInfo::~InlineFunctionInfo
~InlineFunctionInfo() override
Destructor.
lldb_private::Block
Definition: Block.h:41
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
uint32_t
lldb_private::AddressRange::Dump
bool Dump(Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style=Address::DumpStyleInvalid) const
Dump a description of this object to a Stream.
Definition: AddressRange.cpp:148
lldb_private::Language
Definition: Language.h:29
lldb_private::Function::flagsCalculatedPrologueSize
@ flagsCalculatedPrologueSize
Whether we already tried to calculate the prologue size.
Definition: Function.h:636
lldb_private::FunctionInfo
Definition: Function.h:31
lldb_private::Address
Definition: Address.h:59
lldb_private::CompileUnit::DumpSymbolContext
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: CompileUnit.cpp:48
lldb_private::DirectCallEdge::lazy_callee
union lldb_private::DirectCallEdge::@25 lazy_callee
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb_private::Function::GetPrologueByteSize
uint32_t GetPrologueByteSize()
Get the size of the prologue instructions for this function.
Definition: Function.cpp:530
lldb_private::Type
Definition: Type.h:66
LineTable.h
lldb_private::CallEdge::GetReturnPCAddress
lldb::addr_t GetReturnPCAddress(Function &caller, Target &target) const
Get the load PC address of the instruction which executes after the call returns.
Definition: Function.cpp:147
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::Function::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: Function.cpp:463
lldb_private::LineEntry::range
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:139
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
lldb_private::Function::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target)
Definition: Function.cpp:367
lldb_private::Function::m_comp_unit
CompileUnit * m_comp_unit
The compile unit that owns this function.
Definition: Function.h:640
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
lldb_private::FunctionInfo::GetName
ConstString GetName() const
Get accessor for the method name.
Definition: Function.cpp:58
lldb_private::FunctionInfo::m_declaration
Declaration m_declaration
Information describing where this function information was defined.
Definition: Function.h:120
lldb_private::Address::SetOffset
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:438
lldb_private::Function::m_call_edges
std::vector< std::unique_ptr< CallEdge > > m_call_edges
Outgoing call edges.
Definition: Function.h:677
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:263
lldb_private::Function::CalculateSymbolContextCompileUnit
CompileUnit * CalculateSymbolContextCompileUnit() override
Definition: Function.cpp:419
lldb_private::InlineFunctionInfo::MemorySize
size_t MemorySize() const override
Get the memory cost of this object.
Definition: Function.cpp:117
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
Function.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::Function::GetType
Type * GetType()
Get accessor for the type that describes the function return value type, and parameter types.
Definition: Function.cpp:502
lldb_private::Function::IsTopLevelFunction
bool IsTopLevelFunction()
Get whether this function represents a 'top-level' function.
Definition: Function.cpp:479
lldb_private::ExecutionContext::GetTargetRef
Target & GetTargetRef() const
Returns a reference to the target object.
Definition: ExecutionContext.cpp:224
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::eDescriptionLevelVerbose
@ eDescriptionLevelVerbose
Definition: lldb-enumerations.h:210
lldb_private::Function::GetCallEdges
llvm::ArrayRef< std::unique_ptr< CallEdge > > GetCallEdges()
Get the outgoing call edges from this function, sorted by their return PC addresses (in increasing or...
Definition: Function.cpp:293
lldb_private::IndirectCallEdge::call_target
DWARFExpression call_target
Definition: Function.h:386
lldb_private::DirectCallEdge::resolved
bool resolved
Whether or not an attempt was made to find the callee's definition.
Definition: Function.h:363
lldb_private::Function::GetCompilerType
CompilerType GetCompilerType()
Definition: Function.cpp:523
lldb_private::Address::DumpStyle
DumpStyle
Dump styles allow the Address::Dump(Stream *,DumpStyle) const function to display Address contents in...
Definition: Address.h:63
lldb_private::CompileUnit::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: CompileUnit.cpp:39
lldb_private::Flags::Set
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
lldb_private::Host::eSystemLogError
@ eSystemLogError
Definition: Host.h:89
lldb_private::ModuleList::FindFunctionSymbols
void FindFunctionSymbols(ConstString name, lldb::FunctionNameType name_type_mask, SymbolContextList &sc_list)
Definition: ModuleList.cpp:446
lldb_private::Address::GetModule
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:283
lldb_private::Log
Definition: Log.h:48
lldb_private::IndirectCallEdge::GetCallee
Function * GetCallee(ModuleList &images, ExecutionContext &exe_ctx) override
Get the callee's definition.
Definition: Function.cpp:193
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::Function::GetEndLineSourceInfo
void GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no)
Find the file and line number of the source location of the end of the function.
Definition: Function.cpp:272
lldb_private::DirectCallEdge::ParseSymbolFileAndResolve
void ParseSymbolFileAndResolve(ModuleList &images)
Definition: Function.cpp:152
lldb_private::DWARFExpression::Evaluate
bool Evaluate(ExecutionContextScope *exe_scope, lldb::addr_t func_load_addr, const Value *initial_value_ptr, const Value *object_address_ptr, Value &result, Status *error_ptr) const
Wrapper for the static evaluate function that accepts an ExecutionContextScope instead of an Executio...
Definition: DWARFExpression.cpp:842
lldb_private::CallEdge::GetLoadAddress
static lldb::addr_t GetLoadAddress(lldb::addr_t unresolved_pc, Function &caller, Target &target)
Helper that finds the load address of unresolved_pc, a file address which refers to an instruction wi...
Definition: Function.cpp:124
lldb_private::Function::Dump
void Dump(Stream *s, bool show_context) const
Dump a description of this object to a Stream.
Definition: Function.cpp:387
lldb_private::Function::GetDeclContext
CompilerDeclContext GetDeclContext()
Get the DeclContext for this function, if available.
Definition: Function.cpp:492
lldb_private::Declaration::Compare
static int Compare(const Declaration &lhs, const Declaration &rhs)
Compare two declaration objects.
Definition: Declaration.cpp:58
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:235
lldb_private::FunctionInfo::FunctionInfo
FunctionInfo(const char *name, const Declaration *decl_ptr)
Construct with the function method name and optional declaration information.
Definition: Function.cpp:30
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:347
lldb_private::Declaration
Definition: Declaration.h:24
lldb_private::Function::m_flags
Flags m_flags
Definition: Function.h:664
lldb
Definition: SBAddress.h:15
lldb_private::Function::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Function.cpp:645
lldb_private::Flags::IsClear
bool IsClear(ValueType bit) const
Test a single flag bit to see if it is clear (zero).
Definition: Flags.h:111
lldb_private::Type::GetFullCompilerType
CompilerType GetFullCompilerType()
Definition: Type.cpp:645
LLDBLog.h
SymbolFile.h
lldb_private::LineEntry
Definition: LineEntry.h:20
lldb_private::ExecutionContext::GetTargetPtr
Target * GetTargetPtr() const
Returns a pointer to the target object.
Definition: ExecutionContext.cpp:198
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::FunctionInfo::Dump
void Dump(Stream *s, bool show_fullpaths) const
Dump a description of this object to a Stream.
Definition: Function.cpp:38
lldb_private::Block::Dump
void Dump(Stream *s, lldb::addr_t base_addr, int32_t depth, bool show_context) const
Dump the block contents.
Definition: Block.cpp:59
lldb_private::Function::m_type_uid
lldb::user_id_t m_type_uid
The user ID of for the prototype Type for this function.
Definition: Function.h:643