LLDB mainline
SymbolFileOnDemand.cpp
Go to the documentation of this file.
1//===-- SymbolFileOnDemand.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
10
11#include "lldb/Core/Module.h"
13
14#include <memory>
15#include <optional>
16
17using namespace lldb;
18using namespace lldb_private;
19
21
23 std::unique_ptr<SymbolFile> &&symbol_file)
24 : m_sym_file_impl(std::move(symbol_file)) {}
25
27
29 // Explicitly allow ability checking to pass though.
30 // This should be a cheap operation.
31 return m_sym_file_impl->CalculateAbilities();
32}
33
34std::recursive_mutex &SymbolFileOnDemand::GetModuleMutex() const {
35 return m_sym_file_impl->GetModuleMutex();
36}
37
40 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
41 __FUNCTION__);
42 return;
43 }
44 return m_sym_file_impl->InitializeObject();
45}
46
49 Log *log = GetLog();
50 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
51 if (log) {
52 lldb::LanguageType langType = m_sym_file_impl->ParseLanguage(comp_unit);
53 if (langType != eLanguageTypeUnknown)
54 LLDB_LOG(log, "Language {0} would return if hydrated.", langType);
55 }
57 }
58 return m_sym_file_impl->ParseLanguage(comp_unit);
59}
60
63 Log *log = GetLog();
64 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
65 XcodeSDK defaultValue{};
66 if (log) {
67 XcodeSDK sdk = m_sym_file_impl->ParseXcodeSDK(comp_unit);
68 if (!(sdk == defaultValue))
69 LLDB_LOG(log, "SDK {0} would return if hydrated.", sdk.GetString());
70 }
71 return defaultValue;
72 }
73 return m_sym_file_impl->ParseXcodeSDK(comp_unit);
74}
75
78 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
79 __FUNCTION__);
80 return 0;
81 }
82 return m_sym_file_impl->ParseFunctions(comp_unit);
83}
84
87 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
88 __FUNCTION__);
89 return false;
90 }
91 return m_sym_file_impl->ParseLineTable(comp_unit);
92}
93
96 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
97 __FUNCTION__);
98 return false;
99 }
100 return m_sym_file_impl->ParseDebugMacros(comp_unit);
101}
102
104 CompileUnit &comp_unit,
105 llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
106 llvm::function_ref<bool(Module &)> lambda) {
108 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
109 __FUNCTION__);
110 // Return false to not early exit.
111 return false;
112 }
113 return m_sym_file_impl->ForEachExternalModule(comp_unit, visited_symbol_files,
114 lambda);
115}
116
118 SupportFileList &support_files) {
120 "[{0}] {1} is not skipped: explicitly allowed to support breakpoint",
121 GetSymbolFileName(), __FUNCTION__);
122 // Explicitly allow this API through to support source line breakpoint.
123 return m_sym_file_impl->ParseSupportFiles(comp_unit, support_files);
124}
125
128 Log *log = GetLog();
129 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
130 if (log) {
131 bool optimized = m_sym_file_impl->ParseIsOptimized(comp_unit);
132 if (optimized) {
133 LLDB_LOG(log, "Would return optimized if hydrated.");
134 }
135 }
136 return false;
137 }
138 return m_sym_file_impl->ParseIsOptimized(comp_unit);
139}
140
143 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
144 __FUNCTION__);
145 return 0;
146 }
147 return m_sym_file_impl->ParseTypes(comp_unit);
148}
149
152 std::vector<SourceModule> &imported_modules) {
154 Log *log = GetLog();
155 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
156 if (log) {
157 std::vector<SourceModule> tmp_imported_modules;
158 bool succeed =
159 m_sym_file_impl->ParseImportedModules(sc, tmp_imported_modules);
160 if (succeed)
161 LLDB_LOG(log, "{0} imported modules would be parsed if hydrated.",
162 tmp_imported_modules.size());
163 }
164 return false;
165 }
166 return m_sym_file_impl->ParseImportedModules(sc, imported_modules);
167}
168
171 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
172 __FUNCTION__);
173 return 0;
174 }
175 return m_sym_file_impl->ParseBlocksRecursive(func);
176}
177
180 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
181 __FUNCTION__);
182 return 0;
183 }
184 return m_sym_file_impl->ParseVariablesForContext(sc);
185}
186
189 Log *log = GetLog();
190 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
191 if (log) {
192 Type *resolved_type = m_sym_file_impl->ResolveTypeUID(type_uid);
193 if (resolved_type)
194 LLDB_LOG(log, "Type would be parsed for {0} if hydrated.", type_uid);
195 }
196 return nullptr;
197 }
198 return m_sym_file_impl->ResolveTypeUID(type_uid);
199}
200
201std::optional<SymbolFile::ArrayInfo>
203 lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
205 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
206 __FUNCTION__);
207 return std::nullopt;
208 }
209 return m_sym_file_impl->GetDynamicArrayInfoForUID(type_uid, exe_ctx);
210}
211
214 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
215 __FUNCTION__);
216 return false;
217 }
218 return m_sym_file_impl->CompleteType(compiler_type);
219}
220
223 Log *log = GetLog();
224 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
225 if (log) {
226 CompilerDecl parsed_decl = m_sym_file_impl->GetDeclForUID(type_uid);
227 if (parsed_decl != CompilerDecl()) {
228 LLDB_LOG(log, "CompilerDecl {0} would be parsed for {1} if hydrated.",
229 parsed_decl.GetName(), type_uid);
230 }
231 }
232 return CompilerDecl();
233 }
234 return m_sym_file_impl->GetDeclForUID(type_uid);
235}
236
240 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
241 __FUNCTION__);
242 return CompilerDeclContext();
243 }
244 return m_sym_file_impl->GetDeclContextForUID(type_uid);
245}
246
250 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
251 __FUNCTION__);
252 return CompilerDeclContext();
253 }
254 return m_sym_file_impl->GetDeclContextContainingUID(type_uid);
255}
256
259 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
260 __FUNCTION__);
261 return;
262 }
263 return m_sym_file_impl->ParseDeclsForContext(decl_ctx);
264}
265
266uint32_t
268 SymbolContextItem resolve_scope,
269 SymbolContext &sc) {
271 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
272 __FUNCTION__);
273 return 0;
274 }
275 return m_sym_file_impl->ResolveSymbolContext(so_addr, resolve_scope, sc);
276}
277
280 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
281 __FUNCTION__);
282 return Status();
283 }
284 return m_sym_file_impl->CalculateFrameVariableError(frame);
285}
286
288 const SourceLocationSpec &src_location_spec,
289 SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
291 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
292 __FUNCTION__);
293 return 0;
294 }
295 return m_sym_file_impl->ResolveSymbolContext(src_location_spec, resolve_scope,
296 sc_list);
297}
298
301 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
302 __FUNCTION__);
303 return;
304 }
305 return m_sym_file_impl->Dump(s);
306}
307
310 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
311 __FUNCTION__);
312 return;
313 }
314 return m_sym_file_impl->DumpClangAST(s);
315}
316
318 uint32_t max_matches,
319 VariableList &variables) {
321 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
322 __FUNCTION__);
323 return;
324 }
325 return m_sym_file_impl->FindGlobalVariables(regex, max_matches, variables);
326}
327
329 ConstString name, const CompilerDeclContext &parent_decl_ctx,
330 uint32_t max_matches, VariableList &variables) {
332 Log *log = GetLog();
333 Symtab *symtab = GetSymtab();
334 if (!symtab) {
335 LLDB_LOG(log, "[{0}] {1} is skipped - fail to get symtab",
336 GetSymbolFileName(), __FUNCTION__);
337 return;
338 }
341 if (!sym) {
342 LLDB_LOG(log, "[{0}] {1} is skipped - fail to find match in symtab",
343 GetSymbolFileName(), __FUNCTION__);
344 return;
345 }
346 LLDB_LOG(log, "[{0}] {1} is NOT skipped - found match in symtab",
347 GetSymbolFileName(), __FUNCTION__);
348
349 // Found match in symbol table hydrate debug info and
350 // allow the FindGlobalVariables to go through.
352 }
353 return m_sym_file_impl->FindGlobalVariables(name, parent_decl_ctx,
354 max_matches, variables);
355}
356
358 bool include_inlines,
359 SymbolContextList &sc_list) {
361 Log *log = GetLog();
362 Symtab *symtab = GetSymtab();
363 if (!symtab) {
364 LLDB_LOG(log, "[{0}] {1} is skipped - fail to get symtab",
365 GetSymbolFileName(), __FUNCTION__);
366 return;
367 }
368 std::vector<uint32_t> symbol_indexes;
371 symbol_indexes);
372 if (symbol_indexes.empty()) {
373 LLDB_LOG(log, "[{0}] {1} is skipped - fail to find match in symtab",
374 GetSymbolFileName(), __FUNCTION__);
375 return;
376 }
377 LLDB_LOG(log, "[{0}] {1} is NOT skipped - found match in symtab",
378 GetSymbolFileName(), __FUNCTION__);
379
380 // Found match in symbol table hydrate debug info and
381 // allow the FindFucntions to go through.
383 }
384 return m_sym_file_impl->FindFunctions(regex, include_inlines, sc_list);
385}
386
388 const Module::LookupInfo &lookup_info,
389 const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
390 SymbolContextList &sc_list) {
391 ConstString name = lookup_info.GetLookupName();
392 FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
394 Log *log = GetLog();
395
396 Symtab *symtab = GetSymtab();
397 if (!symtab) {
398 LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to get symtab",
399 GetSymbolFileName(), __FUNCTION__, name);
400 return;
401 }
402
403 SymbolContextList sc_list_helper;
404 symtab->FindFunctionSymbols(name, name_type_mask, sc_list_helper);
405 if (sc_list_helper.GetSize() == 0) {
406 LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to find match in symtab",
407 GetSymbolFileName(), __FUNCTION__, name);
408 return;
409 }
410 LLDB_LOG(log, "[{0}] {1}({2}) is NOT skipped - found match in symtab",
411 GetSymbolFileName(), __FUNCTION__, name);
412
413 // Found match in symbol table hydrate debug info and
414 // allow the FindFucntions to go through.
416 }
417 return m_sym_file_impl->FindFunctions(lookup_info, parent_decl_ctx,
418 include_inlines, sc_list);
419}
420
422 const std::string &scope_qualified_name,
423 std::vector<ConstString> &mangled_names) {
425 Log *log = GetLog();
426 LLDB_LOG(log, "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
427 __FUNCTION__, scope_qualified_name);
428 return;
429 }
430 return m_sym_file_impl->GetMangledNamesForFunction(scope_qualified_name,
431 mangled_names);
432}
433
435 TypeResults &results) {
437 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
438 __FUNCTION__);
439 return;
440 }
441 return m_sym_file_impl->FindTypes(match, results);
442}
443
445 TypeClass type_mask, TypeList &type_list) {
447 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
448 __FUNCTION__);
449 return;
450 }
451 return m_sym_file_impl->GetTypes(sc_scope, type_mask, type_list);
452}
453
454llvm::Expected<lldb::TypeSystemSP>
457 Log *log = GetLog();
458 LLDB_LOG(log, "[{0}] {1} is skipped for language type {2}",
459 GetSymbolFileName(), __FUNCTION__, language);
460 return llvm::make_error<llvm::StringError>(
461 "GetTypeSystemForLanguage is skipped by SymbolFileOnDemand",
462 llvm::inconvertibleErrorCode());
463 }
464 return m_sym_file_impl->GetTypeSystemForLanguage(language);
465}
466
469 const CompilerDeclContext &parent_decl_ctx,
470 bool only_root_namespaces) {
472 LLDB_LOG(GetLog(), "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
473 __FUNCTION__, name);
474 return SymbolFile::FindNamespace(name, parent_decl_ctx,
475 only_root_namespaces);
476 }
477 return m_sym_file_impl->FindNamespace(name, parent_decl_ctx,
478 only_root_namespaces);
479}
480
481std::vector<std::unique_ptr<lldb_private::CallEdge>>
484 Log *log = GetLog();
485 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
486 if (log) {
487 std::vector<std::unique_ptr<lldb_private::CallEdge>> call_edges =
488 m_sym_file_impl->ParseCallEdgesInFunction(func_id);
489 if (call_edges.size() > 0) {
490 LLDB_LOG(log, "{0} call edges would be parsed for {1} if hydrated.",
491 call_edges.size(), func_id.GetID());
492 }
493 }
494 return {};
495 }
496 return m_sym_file_impl->ParseCallEdgesInFunction(func_id);
497}
498
501 const RegisterInfoResolver &resolver) {
503 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
504 __FUNCTION__);
505 return nullptr;
506 }
507 return m_sym_file_impl->GetUnwindPlan(address, resolver);
508}
509
510llvm::Expected<lldb::addr_t>
513 Log *log = GetLog();
514 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
515 if (log) {
516 llvm::Expected<lldb::addr_t> stack_size =
517 m_sym_file_impl->GetParameterStackSize(symbol);
518 if (stack_size) {
519 LLDB_LOG(log, "{0} stack size would return for symbol {1} if hydrated.",
520 *stack_size, symbol.GetName());
521 }
522 }
524 }
525 return m_sym_file_impl->GetParameterStackSize(symbol);
526}
527
529 m_preload_symbols = true;
531 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
532 __FUNCTION__);
533 return;
534 }
535 return m_sym_file_impl->PreloadSymbols();
536}
537
538uint64_t SymbolFileOnDemand::GetDebugInfoSize(bool load_all_debug_info) {
539 // Always return the real debug info size.
540 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
541 __FUNCTION__);
542 return m_sym_file_impl->GetDebugInfoSize(load_all_debug_info);
543}
544
546 // Always return the real parse time.
547 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
548 __FUNCTION__);
549 return m_sym_file_impl->GetDebugInfoParseTime();
550}
551
553 // Always return the real index time.
554 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
555 __FUNCTION__);
556 return m_sym_file_impl->GetDebugInfoIndexTime();
557}
558
561 return;
562 LLDB_LOG(GetLog(), "[{0}] Hydrate debug info", GetSymbolFileName());
567}
568
570 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration",
571 GetSymbolFileName(), __FUNCTION__);
572 return m_sym_file_impl->GetNumCompileUnits();
573}
574
576 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration",
577 GetSymbolFileName(), __FUNCTION__);
578 return m_sym_file_impl->GetCompileUnitAtIndex(idx);
579}
580
583 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
584 __FUNCTION__);
585 return 0;
586 }
587 return m_sym_file_impl->GetAbilities();
588}
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:342
A section + offset based address class.
Definition: Address.h:62
A class that describes a compilation unit.
Definition: CompileUnit.h:41
Represents a generic declaration context in a program.
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
ConstString GetName() const
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
A class that describes a function.
Definition: Function.h:399
A class that encapsulates name lookup information.
Definition: Module.h:904
lldb::FunctionNameType GetNameTypeMask() const
Definition: Module.h:919
ConstString GetLookupName() const
Definition: Module.h:915
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
"lldb/Core/SourceLocationSpec.h" A source location specifier class.
This base class provides an interface to stack frames.
Definition: StackFrame.h:42
std::chrono::duration< double > Duration
Definition: Statistics.h:31
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
A list of support files for a CompileUnit.
Definition: FileSpecList.h:23
Defines a list of symbol context objects.
uint32_t GetSize() const
Get accessor for a symbol context list size.
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
uint32_t GetAbilities() override
Get a mask of what this symbol file supports for the object file that it was constructed with.
void FindTypes(const lldb_private::TypeQuery &query, lldb_private::TypeResults &results) override
Find types using a type-matching object that contains all search parameters.
void GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector< lldb_private::ConstString > &mangled_names) override
size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override
size_t ParseBlocksRecursive(lldb_private::Function &func) override
bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override
std::optional< ArrayInfo > GetDynamicArrayInfoForUID(lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) override
If type_uid points to an array type, return its characteristics.
bool ParseImportedModules(const lldb_private::SymbolContext &sc, std::vector< lldb_private::SourceModule > &imported_modules) override
lldb_private::Type * ResolveTypeUID(lldb::user_id_t type_uid) override
uint64_t GetDebugInfoSize(bool load_all_debug_info=false) override
Metrics gathering functions.
uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr, lldb::SymbolContextItem resolve_scope, lldb_private::SymbolContext &sc) override
void DumpClangAST(lldb_private::Stream &s) override
lldb::UnwindPlanSP GetUnwindPlan(const Address &address, const RegisterInfoResolver &resolver) override
SymbolFileOnDemand(std::unique_ptr< SymbolFile > &&symbol_file)
void FindGlobalVariables(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, lldb_private::VariableList &variables) override
lldb_private::CompilerDeclContext FindNamespace(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, bool only_root_namespaces) override
Finds a namespace of name name and whose parent context is parent_decl_ctx.
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language) override
std::recursive_mutex & GetModuleMutex() const override
Symbols file subclasses should override this to return the Module that owns the TypeSystem that this ...
llvm::Expected< lldb::addr_t > GetParameterStackSize(Symbol &symbol) override
Return the number of stack bytes taken up by the parameters to this function.
lldb_private::XcodeSDK ParseXcodeSDK(lldb_private::CompileUnit &comp_unit) override
Return the Xcode SDK comp_unit was compiled against.
bool CompleteType(lldb_private::CompilerType &compiler_type) override
bool ForEachExternalModule(lldb_private::CompileUnit &, llvm::DenseSet< lldb_private::SymbolFile * > &, llvm::function_ref< bool(lldb_private::Module &)>) override
lldb_private::StatsDuration::Duration GetDebugInfoParseTime() override
Return the time taken to parse the debug information.
lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override
void Dump(lldb_private::Stream &s) override
void SetLoadDebugInfoEnabled() override
Specify debug info should be loaded.
std::unique_ptr< SymbolFile > m_sym_file_impl
bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit, lldb_private::SupportFileList &support_files) override
bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override
lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override
void GetTypes(lldb_private::SymbolContextScope *sc_scope, lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override
size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override
lldb_private::CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) override
lldb_private::CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) override
std::vector< std::unique_ptr< lldb_private::CallEdge > > ParseCallEdgesInFunction(UserID func_id) override
lldb_private::StatsDuration::Duration GetDebugInfoIndexTime() override
Return the time it took to index the debug information in the object file.
void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info, const lldb_private::CompilerDeclContext &parent_decl_ctx, bool include_inlines, lldb_private::SymbolContextList &sc_list) override
bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override
size_t ParseVariablesForContext(const lldb_private::SymbolContext &sc) override
static char ID
LLVM RTTI support.
void ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override
lldb_private::Status CalculateFrameVariableError(lldb_private::StackFrame &frame) override
Subclasses will override this function to for GetFrameVariableError().
lldb::LanguageType ParseLanguage(lldb_private::CompileUnit &comp_unit) override
void InitializeObject() override
Initialize the SymbolFile object.
virtual llvm::Expected< lldb::addr_t > GetParameterStackSize(Symbol &symbol)
Return the number of stack bytes taken up by the parameters to this function.
Definition: SymbolFile.h:375
virtual CompilerDeclContext FindNamespace(ConstString name, const CompilerDeclContext &parent_decl_ctx, bool only_root_namespaces=false)
Finds a namespace of name name and whose parent context is parent_decl_ctx.
Definition: SymbolFile.h:341
ConstString GetName() const
Definition: Symbol.cpp:552
Symbol * FindFirstSymbolWithNameAndType(ConstString name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
Definition: Symtab.cpp:873
void FindFunctionSymbols(ConstString name, uint32_t name_type_mask, SymbolContextList &sc_list)
Definition: Symtab.cpp:1101
uint32_t AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex, lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:757
A class that contains all state required for type lookups.
Definition: Type.h:96
This class tracks the state and results of a TypeQuery.
Definition: Type.h:304
An abstraction for Xcode-style SDKs that works like ArchSpec.
Definition: XcodeSDK.h:24
llvm::StringRef GetString() const
Definition: XcodeSDK.cpp:143
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
Definition: lldb-forward.h:471
uint64_t user_id_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::CompileUnit > CompUnitSP
Definition: lldb-forward.h:327
A mix in class that contains a generic user ID.
Definition: UserID.h:31
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47