Bug Summary

File:src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
Warning:line 1173, column 24
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ClangExpressionDeclMap.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/clang/include -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

1//===-- ClangExpressionDeclMap.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 "ClangExpressionDeclMap.h"
10
11#include "ClangASTSource.h"
12#include "ClangModulesDeclVendor.h"
13#include "ClangPersistentVariables.h"
14#include "ClangUtil.h"
15
16#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
17#include "lldb/Core/Address.h"
18#include "lldb/Core/Module.h"
19#include "lldb/Core/ModuleSpec.h"
20#include "lldb/Core/ValueObjectConstResult.h"
21#include "lldb/Core/ValueObjectVariable.h"
22#include "lldb/Expression/DiagnosticManager.h"
23#include "lldb/Expression/Materializer.h"
24#include "lldb/Symbol/CompileUnit.h"
25#include "lldb/Symbol/CompilerDecl.h"
26#include "lldb/Symbol/CompilerDeclContext.h"
27#include "lldb/Symbol/Function.h"
28#include "lldb/Symbol/ObjectFile.h"
29#include "lldb/Symbol/SymbolContext.h"
30#include "lldb/Symbol/SymbolFile.h"
31#include "lldb/Symbol/SymbolVendor.h"
32#include "lldb/Symbol/Type.h"
33#include "lldb/Symbol/TypeList.h"
34#include "lldb/Symbol/Variable.h"
35#include "lldb/Symbol/VariableList.h"
36#include "lldb/Target/ExecutionContext.h"
37#include "lldb/Target/Process.h"
38#include "lldb/Target/RegisterContext.h"
39#include "lldb/Target/StackFrame.h"
40#include "lldb/Target/Target.h"
41#include "lldb/Target/Thread.h"
42#include "lldb/Utility/Endian.h"
43#include "lldb/Utility/Log.h"
44#include "lldb/Utility/RegisterValue.h"
45#include "lldb/Utility/Status.h"
46#include "lldb/lldb-private.h"
47#include "clang/AST/ASTConsumer.h"
48#include "clang/AST/ASTContext.h"
49#include "clang/AST/ASTImporter.h"
50#include "clang/AST/Decl.h"
51#include "clang/AST/DeclarationName.h"
52#include "clang/AST/RecursiveASTVisitor.h"
53
54#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
55#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
56#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
57
58using namespace lldb;
59using namespace lldb_private;
60using namespace clang;
61
62namespace {
63const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
64} // anonymous namespace
65
66ClangExpressionDeclMap::ClangExpressionDeclMap(
67 bool keep_result_in_memory,
68 Materializer::PersistentVariableDelegate *result_delegate,
69 const lldb::TargetSP &target,
70 const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj)
71 : ClangASTSource(target, importer), m_found_entities(), m_struct_members(),
72 m_keep_result_in_memory(keep_result_in_memory),
73 m_result_delegate(result_delegate), m_ctx_obj(ctx_obj), m_parser_vars(),
74 m_struct_vars() {
75 EnableStructVars();
76}
77
78ClangExpressionDeclMap::~ClangExpressionDeclMap() {
79 // Note: The model is now that the parser's AST context and all associated
80 // data does not vanish until the expression has been executed. This means
81 // that valuable lookup data (like namespaces) doesn't vanish, but
82
83 DidParse();
84 DisableStructVars();
85}
86
87bool ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
88 Materializer *materializer) {
89 EnableParserVars();
90 m_parser_vars->m_exe_ctx = exe_ctx;
91
92 Target *target = exe_ctx.GetTargetPtr();
93 if (exe_ctx.GetFramePtr())
94 m_parser_vars->m_sym_ctx =
95 exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
96 else if (exe_ctx.GetThreadPtr() &&
97 exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0))
98 m_parser_vars->m_sym_ctx =
99 exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(
100 lldb::eSymbolContextEverything);
101 else if (exe_ctx.GetProcessPtr()) {
102 m_parser_vars->m_sym_ctx.Clear(true);
103 m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
104 } else if (target) {
105 m_parser_vars->m_sym_ctx.Clear(true);
106 m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
107 }
108
109 if (target) {
110 m_parser_vars->m_persistent_vars = llvm::cast<ClangPersistentVariables>(
111 target->GetPersistentExpressionStateForLanguage(eLanguageTypeC));
112
113 if (!ScratchTypeSystemClang::GetForTarget(*target))
114 return false;
115 }
116
117 m_parser_vars->m_target_info = GetTargetInfo();
118 m_parser_vars->m_materializer = materializer;
119
120 return true;
121}
122
123void ClangExpressionDeclMap::InstallCodeGenerator(
124 clang::ASTConsumer *code_gen) {
125 assert(m_parser_vars)((void)0);
126 m_parser_vars->m_code_gen = code_gen;
127}
128
129void ClangExpressionDeclMap::InstallDiagnosticManager(
130 DiagnosticManager &diag_manager) {
131 assert(m_parser_vars)((void)0);
132 m_parser_vars->m_diagnostics = &diag_manager;
133}
134
135void ClangExpressionDeclMap::DidParse() {
136 if (m_parser_vars && m_parser_vars->m_persistent_vars) {
137 for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
138 entity_index < num_entities; ++entity_index) {
139 ExpressionVariableSP var_sp(
140 m_found_entities.GetVariableAtIndex(entity_index));
141 if (var_sp)
142 llvm::cast<ClangExpressionVariable>(var_sp.get())
143 ->DisableParserVars(GetParserID());
144 }
145
146 for (size_t pvar_index = 0,
147 num_pvars = m_parser_vars->m_persistent_vars->GetSize();
148 pvar_index < num_pvars; ++pvar_index) {
149 ExpressionVariableSP pvar_sp(
150 m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
151 if (ClangExpressionVariable *clang_var =
152 llvm::dyn_cast<ClangExpressionVariable>(pvar_sp.get()))
153 clang_var->DisableParserVars(GetParserID());
154 }
155
156 DisableParserVars();
157 }
158}
159
160// Interface for IRForTarget
161
162ClangExpressionDeclMap::TargetInfo ClangExpressionDeclMap::GetTargetInfo() {
163 assert(m_parser_vars.get())((void)0);
164
165 TargetInfo ret;
166
167 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
168
169 Process *process = exe_ctx.GetProcessPtr();
170 if (process) {
171 ret.byte_order = process->GetByteOrder();
172 ret.address_byte_size = process->GetAddressByteSize();
173 } else {
174 Target *target = exe_ctx.GetTargetPtr();
175 if (target) {
176 ret.byte_order = target->GetArchitecture().GetByteOrder();
177 ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
178 }
179 }
180
181 return ret;
182}
183
184TypeFromUser ClangExpressionDeclMap::DeportType(TypeSystemClang &target,
185 TypeSystemClang &source,
186 TypeFromParser parser_type) {
187 assert(&target == GetScratchContext(*m_target))((void)0);
188 assert((TypeSystem *)&source == parser_type.GetTypeSystem())((void)0);
189 assert(&source.getASTContext() == m_ast_context)((void)0);
190
191 return TypeFromUser(m_ast_importer_sp->DeportType(target, parser_type));
192}
193
194bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
195 ConstString name,
196 TypeFromParser parser_type,
197 bool is_result,
198 bool is_lvalue) {
199 assert(m_parser_vars.get())((void)0);
200
201 TypeSystemClang *ast =
202 llvm::dyn_cast_or_null<TypeSystemClang>(parser_type.GetTypeSystem());
203 if (ast == nullptr)
204 return false;
205
206 // Check if we already declared a persistent variable with the same name.
207 if (lldb::ExpressionVariableSP conflicting_var =
208 m_parser_vars->m_persistent_vars->GetVariable(name)) {
209 std::string msg = llvm::formatv("redefinition of persistent variable '{0}'",
210 name).str();
211 m_parser_vars->m_diagnostics->AddDiagnostic(
212 msg, DiagnosticSeverity::eDiagnosticSeverityError,
213 DiagnosticOrigin::eDiagnosticOriginLLDB);
214 return false;
215 }
216
217 if (m_parser_vars->m_materializer && is_result) {
218 Status err;
219
220 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
221 Target *target = exe_ctx.GetTargetPtr();
222 if (target == nullptr)
223 return false;
224
225 auto *clang_ast_context = GetScratchContext(*target);
226 if (!clang_ast_context)
227 return false;
228
229 TypeFromUser user_type = DeportType(*clang_ast_context, *ast, parser_type);
230
231 uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(
232 user_type, is_lvalue, m_keep_result_in_memory, m_result_delegate, err);
233
234 ClangExpressionVariable *var = new ClangExpressionVariable(
235 exe_ctx.GetBestExecutionContextScope(), name, user_type,
236 m_parser_vars->m_target_info.byte_order,
237 m_parser_vars->m_target_info.address_byte_size);
238
239 m_found_entities.AddNewlyConstructedVariable(var);
240
241 var->EnableParserVars(GetParserID());
242
243 ClangExpressionVariable::ParserVars *parser_vars =
244 var->GetParserVars(GetParserID());
245
246 parser_vars->m_named_decl = decl;
247
248 var->EnableJITVars(GetParserID());
249
250 ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());
251
252 jit_vars->m_offset = offset;
253
254 return true;
255 }
256
257 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
258 ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
259 Target *target = exe_ctx.GetTargetPtr();
260 if (target == nullptr)
261 return false;
262
263 TypeSystemClang *context = GetScratchContext(*target);
264 if (!context)
265 return false;
266
267 TypeFromUser user_type = DeportType(*context, *ast, parser_type);
268
269 if (!user_type.GetOpaqueQualType()) {
270 LLDB_LOG(log, "Persistent variable's type wasn't copied successfully")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Persistent variable's type wasn't copied successfully"
); } while (0)
;
271 return false;
272 }
273
274 if (!m_parser_vars->m_target_info.IsValid())
275 return false;
276
277 if (!m_parser_vars->m_persistent_vars)
278 return false;
279
280 ClangExpressionVariable *var = llvm::cast<ClangExpressionVariable>(
281 m_parser_vars->m_persistent_vars
282 ->CreatePersistentVariable(
283 exe_ctx.GetBestExecutionContextScope(), name, user_type,
284 m_parser_vars->m_target_info.byte_order,
285 m_parser_vars->m_target_info.address_byte_size)
286 .get());
287
288 if (!var)
289 return false;
290
291 var->m_frozen_sp->SetHasCompleteType();
292
293 if (is_result)
294 var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
295 else
296 var->m_flags |=
297 ClangExpressionVariable::EVKeepInTarget; // explicitly-declared
298 // persistent variables should
299 // persist
300
301 if (is_lvalue) {
302 var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
303 } else {
304 var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
305 var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
306 }
307
308 if (m_keep_result_in_memory) {
309 var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
310 }
311
312 LLDB_LOG(log, "Created persistent variable with flags {0:x}", var->m_flags)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Created persistent variable with flags {0:x}", var
->m_flags); } while (0)
;
313
314 var->EnableParserVars(GetParserID());
315
316 ClangExpressionVariable::ParserVars *parser_vars =
317 var->GetParserVars(GetParserID());
318
319 parser_vars->m_named_decl = decl;
320
321 return true;
322}
323
324bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl,
325 ConstString name,
326 llvm::Value *value, size_t size,
327 lldb::offset_t alignment) {
328 assert(m_struct_vars.get())((void)0);
329 assert(m_parser_vars.get())((void)0);
330
331 bool is_persistent_variable = false;
332
333 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
334
335 m_struct_vars->m_struct_laid_out = false;
336
337 if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl,
338 GetParserID()))
339 return true;
340
341 ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(
342 m_found_entities, decl, GetParserID()));
343
344 if (!var && m_parser_vars->m_persistent_vars) {
345 var = ClangExpressionVariable::FindVariableInList(
346 *m_parser_vars->m_persistent_vars, decl, GetParserID());
347 is_persistent_variable = true;
348 }
349
350 if (!var)
351 return false;
352
353 LLDB_LOG(log, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure"
, decl, name, var->GetName()); } while (0)
354 decl, name, var->GetName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure"
, decl, name, var->GetName()); } while (0)
;
355
356 // We know entity->m_parser_vars is valid because we used a parser variable
357 // to find it
358
359 ClangExpressionVariable::ParserVars *parser_vars =
360 llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());
361
362 parser_vars->m_llvm_value = value;
363
364 if (ClangExpressionVariable::JITVars *jit_vars =
365 llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID())) {
366 // We already laid this out; do not touch
367
368 LLDB_LOG(log, "Already placed at {0:x}", jit_vars->m_offset)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Already placed at {0:x}", jit_vars->m_offset)
; } while (0)
;
369 }
370
371 llvm::cast<ClangExpressionVariable>(var)->EnableJITVars(GetParserID());
372
373 ClangExpressionVariable::JITVars *jit_vars =
374 llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID());
375
376 jit_vars->m_alignment = alignment;
377 jit_vars->m_size = size;
378
379 m_struct_members.AddVariable(var->shared_from_this());
380
381 if (m_parser_vars->m_materializer) {
382 uint32_t offset = 0;
383
384 Status err;
385
386 if (is_persistent_variable) {
387 ExpressionVariableSP var_sp(var->shared_from_this());
388 offset = m_parser_vars->m_materializer->AddPersistentVariable(
389 var_sp, nullptr, err);
390 } else {
391 if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
392 offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
393 else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
394 offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
395 else if (parser_vars->m_lldb_var)
396 offset = m_parser_vars->m_materializer->AddVariable(
397 parser_vars->m_lldb_var, err);
398 }
399
400 if (!err.Success())
401 return false;
402
403 LLDB_LOG(log, "Placed at {0:x}", offset)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Placed at {0:x}", offset); } while (0)
;
404
405 jit_vars->m_offset =
406 offset; // TODO DoStructLayout() should not change this.
407 }
408
409 return true;
410}
411
412bool ClangExpressionDeclMap::DoStructLayout() {
413 assert(m_struct_vars.get())((void)0);
414
415 if (m_struct_vars->m_struct_laid_out)
416 return true;
417
418 if (!m_parser_vars->m_materializer)
419 return false;
420
421 m_struct_vars->m_struct_alignment =
422 m_parser_vars->m_materializer->GetStructAlignment();
423 m_struct_vars->m_struct_size =
424 m_parser_vars->m_materializer->GetStructByteSize();
425 m_struct_vars->m_struct_laid_out = true;
426 return true;
427}
428
429bool ClangExpressionDeclMap::GetStructInfo(uint32_t &num_elements, size_t &size,
430 lldb::offset_t &alignment) {
431 assert(m_struct_vars.get())((void)0);
432
433 if (!m_struct_vars->m_struct_laid_out)
434 return false;
435
436 num_elements = m_struct_members.GetSize();
437 size = m_struct_vars->m_struct_size;
438 alignment = m_struct_vars->m_struct_alignment;
439
440 return true;
441}
442
443bool ClangExpressionDeclMap::GetStructElement(const NamedDecl *&decl,
444 llvm::Value *&value,
445 lldb::offset_t &offset,
446 ConstString &name,
447 uint32_t index) {
448 assert(m_struct_vars.get())((void)0);
449
450 if (!m_struct_vars->m_struct_laid_out)
451 return false;
452
453 if (index >= m_struct_members.GetSize())
454 return false;
455
456 ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
457
458 if (!member_sp)
459 return false;
460
461 ClangExpressionVariable::ParserVars *parser_vars =
462 llvm::cast<ClangExpressionVariable>(member_sp.get())
463 ->GetParserVars(GetParserID());
464 ClangExpressionVariable::JITVars *jit_vars =
465 llvm::cast<ClangExpressionVariable>(member_sp.get())
466 ->GetJITVars(GetParserID());
467
468 if (!parser_vars || !jit_vars || !member_sp->GetValueObject())
469 return false;
470
471 decl = parser_vars->m_named_decl;
472 value = parser_vars->m_llvm_value;
473 offset = jit_vars->m_offset;
474 name = member_sp->GetName();
475
476 return true;
477}
478
479bool ClangExpressionDeclMap::GetFunctionInfo(const NamedDecl *decl,
480 uint64_t &ptr) {
481 ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(
482 m_found_entities, decl, GetParserID()));
483
484 if (!entity)
485 return false;
486
487 // We know m_parser_vars is valid since we searched for the variable by its
488 // NamedDecl
489
490 ClangExpressionVariable::ParserVars *parser_vars =
491 entity->GetParserVars(GetParserID());
492
493 ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
494
495 return true;
496}
497
498addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
499 Process *process,
500 ConstString name,
501 lldb::SymbolType symbol_type,
502 lldb_private::Module *module) {
503 SymbolContextList sc_list;
504
505 if (module)
506 module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
507 else
508 target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
509
510 const uint32_t num_matches = sc_list.GetSize();
511 addr_t symbol_load_addr = LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
512
513 for (uint32_t i = 0;
514 i < num_matches &&
515 (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
516 i++) {
517 SymbolContext sym_ctx;
518 sc_list.GetContextAtIndex(i, sym_ctx);
519
520 const Address sym_address = sym_ctx.symbol->GetAddress();
521
522 if (!sym_address.IsValid())
523 continue;
524
525 switch (sym_ctx.symbol->GetType()) {
526 case eSymbolTypeCode:
527 case eSymbolTypeTrampoline:
528 symbol_load_addr = sym_address.GetCallableLoadAddress(&target);
529 break;
530
531 case eSymbolTypeResolver:
532 symbol_load_addr = sym_address.GetCallableLoadAddress(&target, true);
533 break;
534
535 case eSymbolTypeReExported: {
536 ConstString reexport_name = sym_ctx.symbol->GetReExportedSymbolName();
537 if (reexport_name) {
538 ModuleSP reexport_module_sp;
539 ModuleSpec reexport_module_spec;
540 reexport_module_spec.GetPlatformFileSpec() =
541 sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
542 if (reexport_module_spec.GetPlatformFileSpec()) {
543 reexport_module_sp =
544 target.GetImages().FindFirstModule(reexport_module_spec);
545 if (!reexport_module_sp) {
546 reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
547 reexport_module_sp =
548 target.GetImages().FindFirstModule(reexport_module_spec);
549 }
550 }
551 symbol_load_addr = GetSymbolAddress(
552 target, process, sym_ctx.symbol->GetReExportedSymbolName(),
553 symbol_type, reexport_module_sp.get());
554 }
555 } break;
556
557 case eSymbolTypeData:
558 case eSymbolTypeRuntime:
559 case eSymbolTypeVariable:
560 case eSymbolTypeLocal:
561 case eSymbolTypeParam:
562 case eSymbolTypeInvalid:
563 case eSymbolTypeAbsolute:
564 case eSymbolTypeException:
565 case eSymbolTypeSourceFile:
566 case eSymbolTypeHeaderFile:
567 case eSymbolTypeObjectFile:
568 case eSymbolTypeCommonBlock:
569 case eSymbolTypeBlock:
570 case eSymbolTypeVariableType:
571 case eSymbolTypeLineEntry:
572 case eSymbolTypeLineHeader:
573 case eSymbolTypeScopeBegin:
574 case eSymbolTypeScopeEnd:
575 case eSymbolTypeAdditional:
576 case eSymbolTypeCompiler:
577 case eSymbolTypeInstrumentation:
578 case eSymbolTypeUndefined:
579 case eSymbolTypeObjCClass:
580 case eSymbolTypeObjCMetaClass:
581 case eSymbolTypeObjCIVar:
582 symbol_load_addr = sym_address.GetLoadAddress(&target);
583 break;
584 }
585 }
586
587 if (symbol_load_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL && process) {
588 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process);
589
590 if (runtime) {
591 symbol_load_addr = runtime->LookupRuntimeSymbol(name);
592 }
593 }
594
595 return symbol_load_addr;
596}
597
598addr_t ClangExpressionDeclMap::GetSymbolAddress(ConstString name,
599 lldb::SymbolType symbol_type) {
600 assert(m_parser_vars.get())((void)0);
601
602 if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
603 return false;
604
605 return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(),
606 m_parser_vars->m_exe_ctx.GetProcessPtr(), name,
607 symbol_type);
608}
609
610lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
611 Target &target, ModuleSP &module, ConstString name,
612 const CompilerDeclContext &namespace_decl) {
613 VariableList vars;
614
615 if (module && namespace_decl)
616 module->FindGlobalVariables(name, namespace_decl, -1, vars);
617 else
618 target.GetImages().FindGlobalVariables(name, -1, vars);
619
620 if (vars.GetSize() == 0)
621 return VariableSP();
622 return vars.GetVariableAtIndex(0);
623}
624
625TypeSystemClang *ClangExpressionDeclMap::GetTypeSystemClang() {
626 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
627 if (frame == nullptr)
628 return nullptr;
629
630 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
631 lldb::eSymbolContextBlock);
632 if (sym_ctx.block == nullptr)
633 return nullptr;
634
635 CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
636 if (!frame_decl_context)
637 return nullptr;
638
639 return llvm::dyn_cast_or_null<TypeSystemClang>(
640 frame_decl_context.GetTypeSystem());
641}
642
643// Interface for ClangASTSource
644
645void ClangExpressionDeclMap::FindExternalVisibleDecls(
646 NameSearchContext &context) {
647 assert(m_ast_context)((void)0);
648
649 const ConstString name(context.m_decl_name.getAsString().c_str());
650
651 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
652
653 if (log) {
654 if (!context.m_decl_context)
655 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a NULL DeclContext", name); } while (0)
656 "ClangExpressionDeclMap::FindExternalVisibleDecls for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a NULL DeclContext", name); } while (0)
657 "'{0}' in a NULL DeclContext",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a NULL DeclContext", name); } while (0)
658 name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a NULL DeclContext", name); } while (0)
;
659 else if (const NamedDecl *context_named_decl =
660 dyn_cast<NamedDecl>(context.m_decl_context))
661 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
662 "ClangExpressionDeclMap::FindExternalVisibleDecls for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
663 "'{0}' in '{1}'",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
664 name, context_named_decl->getNameAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
;
665 else
666 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
667 "ClangExpressionDeclMap::FindExternalVisibleDecls for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
668 "'{0}' in a '{1}'",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
669 name, context.m_decl_context->getDeclKindName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
"'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
;
670 }
671
672 if (const NamespaceDecl *namespace_context =
673 dyn_cast<NamespaceDecl>(context.m_decl_context)) {
674 if (namespace_context->getName().str() ==
675 std::string(g_lldb_local_vars_namespace_cstr)) {
676 CompilerDeclContext compiler_decl_ctx =
677 m_clang_ast_context->CreateDeclContext(
678 const_cast<clang::DeclContext *>(context.m_decl_context));
679 FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx);
680 return;
681 }
682
683 ClangASTImporter::NamespaceMapSP namespace_map =
684 m_ast_importer_sp->GetNamespaceMap(namespace_context);
685
686 if (!namespace_map)
687 return;
688
689 LLDB_LOGV(log, " CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)",do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)"
, namespace_map.get(), namespace_map->size()); } while (0)
690 namespace_map.get(), namespace_map->size())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)"
, namespace_map.get(), namespace_map->size()); } while (0)
;
691
692 for (ClangASTImporter::NamespaceMapItem &n : *namespace_map) {
693 LLDB_LOG(log, " CEDM::FEVD Searching namespace {0} in module {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Searching namespace {0} in module {1}"
, n.second.GetName(), n.first->GetFileSpec().GetFilename()
); } while (0)
694 n.second.GetName(), n.first->GetFileSpec().GetFilename())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Searching namespace {0} in module {1}"
, n.second.GetName(), n.first->GetFileSpec().GetFilename()
); } while (0)
;
695
696 FindExternalVisibleDecls(context, n.first, n.second);
697 }
698 } else if (isa<TranslationUnitDecl>(context.m_decl_context)) {
699 CompilerDeclContext namespace_decl;
700
701 LLDB_LOG(log, " CEDM::FEVD Searching the root namespace")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Searching the root namespace"); } while
(0)
;
702
703 FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
704 }
705
706 ClangASTSource::FindExternalVisibleDecls(context);
707}
708
709void ClangExpressionDeclMap::MaybeRegisterFunctionBody(
710 FunctionDecl *copied_function_decl) {
711 if (copied_function_decl->getBody() && m_parser_vars->m_code_gen) {
712 clang::DeclGroupRef decl_group_ref(copied_function_decl);
713 m_parser_vars->m_code_gen->HandleTopLevelDecl(decl_group_ref);
714 }
715}
716
717clang::NamedDecl *ClangExpressionDeclMap::GetPersistentDecl(ConstString name) {
718 if (!m_parser_vars)
719 return nullptr;
720 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
721 if (!target)
722 return nullptr;
723
724 ScratchTypeSystemClang::GetForTarget(*target);
725
726 if (!m_parser_vars->m_persistent_vars)
727 return nullptr;
728 return m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
729}
730
731void ClangExpressionDeclMap::SearchPersistenDecls(NameSearchContext &context,
732 const ConstString name) {
733 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
734
735 NamedDecl *persistent_decl = GetPersistentDecl(name);
736
737 if (!persistent_decl)
738 return;
739
740 Decl *parser_persistent_decl = CopyDecl(persistent_decl);
741
742 if (!parser_persistent_decl)
743 return;
744
745 NamedDecl *parser_named_decl = dyn_cast<NamedDecl>(parser_persistent_decl);
746
747 if (!parser_named_decl)
748 return;
749
750 if (clang::FunctionDecl *parser_function_decl =
751 llvm::dyn_cast<clang::FunctionDecl>(parser_named_decl)) {
752 MaybeRegisterFunctionBody(parser_function_decl);
753 }
754
755 LLDB_LOG(log, " CEDM::FEVD Found persistent decl {0}", name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found persistent decl {0}", name); }
while (0)
;
756
757 context.AddNamedDecl(parser_named_decl);
758}
759
760void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
761 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
762
763 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
764 SymbolContext sym_ctx;
765 if (frame != nullptr)
766 sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
767 lldb::eSymbolContextBlock);
768
769 if (m_ctx_obj) {
770 Status status;
771 lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
772 if (!ctx_obj_ptr || status.Fail())
773 return;
774
775 AddContextClassType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));
776
777 m_struct_vars->m_object_pointer_type =
778 TypeFromUser(ctx_obj_ptr->GetCompilerType());
779
780 return;
781 }
782
783 // Clang is looking for the type of "this"
784
785 if (frame == nullptr)
786 return;
787
788 // Find the block that defines the function represented by "sym_ctx"
789 Block *function_block = sym_ctx.GetFunctionBlock();
790
791 if (!function_block)
792 return;
793
794 CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
795
796 if (!function_decl_ctx)
797 return;
798
799 clang::CXXMethodDecl *method_decl =
800 TypeSystemClang::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
801
802 if (method_decl) {
803 clang::CXXRecordDecl *class_decl = method_decl->getParent();
804
805 QualType class_qual_type(class_decl->getTypeForDecl(), 0);
806
807 TypeFromUser class_user_type(class_qual_type.getAsOpaquePtr(),
808 function_decl_ctx.GetTypeSystem());
809
810 LLDB_LOG(log, " CEDM::FEVD Adding type for $__lldb_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Adding type for $__lldb_class: {1}"
, class_qual_type.getAsString()); } while (0)
811 class_qual_type.getAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Adding type for $__lldb_class: {1}"
, class_qual_type.getAsString()); } while (0)
;
812
813 AddContextClassType(context, class_user_type);
814
815 if (method_decl->isInstance()) {
816 // self is a pointer to the object
817
818 QualType class_pointer_type =
819 method_decl->getASTContext().getPointerType(class_qual_type);
820
821 TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
822 function_decl_ctx.GetTypeSystem());
823
824 m_struct_vars->m_object_pointer_type = self_user_type;
825 }
826 return;
827 }
828
829 // This branch will get hit if we are executing code in the context of
830 // a function that claims to have an object pointer (through
831 // DW_AT_object_pointer?) but is not formally a method of the class.
832 // In that case, just look up the "this" variable in the current scope
833 // and use its type.
834 // FIXME: This code is formally correct, but clang doesn't currently
835 // emit DW_AT_object_pointer
836 // for C++ so it hasn't actually been tested.
837
838 VariableList *vars = frame->GetVariableList(false);
839
840 lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
841
842 if (this_var && this_var->IsInScope(frame) &&
843 this_var->LocationIsValidForFrame(frame)) {
844 Type *this_type = this_var->GetType();
845
846 if (!this_type)
847 return;
848
849 TypeFromUser pointee_type =
850 this_type->GetForwardCompilerType().GetPointeeType();
851
852 LLDB_LOG(log, " FEVD Adding type for $__lldb_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " FEVD Adding type for $__lldb_class: {1}", ClangUtil
::GetQualType(pointee_type).getAsString()); } while (0)
853 ClangUtil::GetQualType(pointee_type).getAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " FEVD Adding type for $__lldb_class: {1}", ClangUtil
::GetQualType(pointee_type).getAsString()); } while (0)
;
854
855 AddContextClassType(context, pointee_type);
856 TypeFromUser this_user_type(this_type->GetFullCompilerType());
857 m_struct_vars->m_object_pointer_type = this_user_type;
858 }
859}
860
861void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context) {
862 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
863
864 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
865
866 if (m_ctx_obj) {
867 Status status;
868 lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
869 if (!ctx_obj_ptr || status.Fail())
870 return;
871
872 AddOneType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));
873
874 m_struct_vars->m_object_pointer_type =
875 TypeFromUser(ctx_obj_ptr->GetCompilerType());
876
877 return;
878 }
879
880 // Clang is looking for the type of "*self"
881
882 if (!frame)
883 return;
884
885 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
886 lldb::eSymbolContextBlock);
887
888 // Find the block that defines the function represented by "sym_ctx"
889 Block *function_block = sym_ctx.GetFunctionBlock();
890
891 if (!function_block)
892 return;
893
894 CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
895
896 if (!function_decl_ctx)
897 return;
898
899 clang::ObjCMethodDecl *method_decl =
900 TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
901
902 if (method_decl) {
903 ObjCInterfaceDecl *self_interface = method_decl->getClassInterface();
904
905 if (!self_interface)
906 return;
907
908 const clang::Type *interface_type = self_interface->getTypeForDecl();
909
910 if (!interface_type)
911 return; // This is unlikely, but we have seen crashes where this
912 // occurred
913
914 TypeFromUser class_user_type(QualType(interface_type, 0).getAsOpaquePtr(),
915 function_decl_ctx.GetTypeSystem());
916
917 LLDB_LOG(log, " FEVD[{0}] Adding type for $__lldb_objc_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(interface_type)); } while (0)
918 ClangUtil::ToString(interface_type))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(interface_type)); } while (0)
;
919
920 AddOneType(context, class_user_type);
921
922 if (method_decl->isInstanceMethod()) {
923 // self is a pointer to the object
924
925 QualType class_pointer_type =
926 method_decl->getASTContext().getObjCObjectPointerType(
927 QualType(interface_type, 0));
928
929 TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
930 function_decl_ctx.GetTypeSystem());
931
932 m_struct_vars->m_object_pointer_type = self_user_type;
933 } else {
934 // self is a Class pointer
935 QualType class_type = method_decl->getASTContext().getObjCClassType();
936
937 TypeFromUser self_user_type(class_type.getAsOpaquePtr(),
938 function_decl_ctx.GetTypeSystem());
939
940 m_struct_vars->m_object_pointer_type = self_user_type;
941 }
942
943 return;
944 }
945 // This branch will get hit if we are executing code in the context of
946 // a function that claims to have an object pointer (through
947 // DW_AT_object_pointer?) but is not formally a method of the class.
948 // In that case, just look up the "self" variable in the current scope
949 // and use its type.
950
951 VariableList *vars = frame->GetVariableList(false);
952
953 lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
954
955 if (!self_var)
956 return;
957 if (!self_var->IsInScope(frame))
958 return;
959 if (!self_var->LocationIsValidForFrame(frame))
960 return;
961
962 Type *self_type = self_var->GetType();
963
964 if (!self_type)
965 return;
966
967 CompilerType self_clang_type = self_type->GetFullCompilerType();
968
969 if (TypeSystemClang::IsObjCClassType(self_clang_type)) {
970 return;
971 }
972 if (!TypeSystemClang::IsObjCObjectPointerType(self_clang_type))
973 return;
974 self_clang_type = self_clang_type.GetPointeeType();
975
976 if (!self_clang_type)
977 return;
978
979 LLDB_LOG(log, " FEVD[{0}] Adding type for $__lldb_objc_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(self_type->GetFullCompilerType())); }
while (0)
980 ClangUtil::ToString(self_type->GetFullCompilerType()))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(self_type->GetFullCompilerType())); }
while (0)
;
981
982 TypeFromUser class_user_type(self_clang_type);
983
984 AddOneType(context, class_user_type);
985
986 TypeFromUser self_user_type(self_type->GetFullCompilerType());
987
988 m_struct_vars->m_object_pointer_type = self_user_type;
989}
990
991void ClangExpressionDeclMap::LookupLocalVarNamespace(
992 SymbolContext &sym_ctx, NameSearchContext &name_context) {
993 if (sym_ctx.block == nullptr)
994 return;
995
996 CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
997 if (!frame_decl_context)
998 return;
999
1000 TypeSystemClang *frame_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
1001 frame_decl_context.GetTypeSystem());
1002 if (!frame_ast)
1003 return;
1004
1005 clang::NamespaceDecl *namespace_decl =
1006 m_clang_ast_context->GetUniqueNamespaceDeclaration(
1007 g_lldb_local_vars_namespace_cstr, nullptr, OptionalClangModuleID());
1008 if (!namespace_decl)
1009 return;
1010
1011 name_context.AddNamedDecl(namespace_decl);
1012 clang::DeclContext *ctxt = clang::Decl::castToDeclContext(namespace_decl);
1013 ctxt->setHasExternalVisibleStorage(true);
1014 name_context.m_found_local_vars_nsp = true;
1015}
1016
1017void ClangExpressionDeclMap::LookupInModulesDeclVendor(
1018 NameSearchContext &context, ConstString name) {
1019 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1020
1021 if (!m_target)
1022 return;
1023
1024 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
1025 GetClangModulesDeclVendor();
1026 if (!modules_decl_vendor)
1027 return;
1028
1029 bool append = false;
1030 uint32_t max_matches = 1;
1031 std::vector<clang::NamedDecl *> decls;
1032
1033 if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
1034 return;
1035
1036 assert(!decls.empty() && "FindDecls returned true but no decls?")((void)0);
1037 clang::NamedDecl *const decl_from_modules = decls[0];
1038
1039 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
1040 " CAS::FEVD Matching decl found for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
1041 "\"{1}\" in the modules",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
1042 name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
;
1043
1044 clang::Decl *copied_decl = CopyDecl(decl_from_modules);
1045 if (!copied_decl) {
1046 LLDB_LOG(log, " CAS::FEVD - Couldn't export a "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CAS::FEVD - Couldn't export a " "declaration from the modules"
); } while (0)
1047 "declaration from the modules")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CAS::FEVD - Couldn't export a " "declaration from the modules"
); } while (0)
;
1048 return;
1049 }
1050
1051 if (auto copied_function = dyn_cast<clang::FunctionDecl>(copied_decl)) {
1052 MaybeRegisterFunctionBody(copied_function);
1053
1054 context.AddNamedDecl(copied_function);
1055
1056 context.m_found_function_with_type_info = true;
1057 context.m_found_function = true;
1058 } else if (auto copied_var = dyn_cast<clang::VarDecl>(copied_decl)) {
1059 context.AddNamedDecl(copied_var);
1060 context.m_found_variable = true;
1061 }
1062}
1063
1064bool ClangExpressionDeclMap::LookupLocalVariable(
1065 NameSearchContext &context, ConstString name, SymbolContext &sym_ctx,
1066 const CompilerDeclContext &namespace_decl) {
1067 if (sym_ctx.block == nullptr)
1068 return false;
1069
1070 CompilerDeclContext decl_context = sym_ctx.block->GetDeclContext();
1071 if (!decl_context)
1072 return false;
1073
1074 // Make sure that the variables are parsed so that we have the
1075 // declarations.
1076 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1077 VariableListSP vars = frame->GetInScopeVariableList(true);
1078 for (size_t i = 0; i < vars->GetSize(); i++)
1079 vars->GetVariableAtIndex(i)->GetDecl();
1080
1081 // Search for declarations matching the name. Do not include imported
1082 // decls in the search if we are looking for decls in the artificial
1083 // namespace $__lldb_local_vars.
1084 std::vector<CompilerDecl> found_decls =
1085 decl_context.FindDeclByName(name, namespace_decl.IsValid());
1086
1087 VariableSP var;
1088 bool variable_found = false;
1089 for (CompilerDecl decl : found_decls) {
1090 for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi) {
1091 VariableSP candidate_var = vars->GetVariableAtIndex(vi);
1092 if (candidate_var->GetDecl() == decl) {
1093 var = candidate_var;
1094 break;
1095 }
1096 }
1097
1098 if (var && !variable_found) {
1099 variable_found = true;
1100 ValueObjectSP valobj = ValueObjectVariable::Create(frame, var);
1101 AddOneVariable(context, var, valobj);
1102 context.m_found_variable = true;
1103 }
1104 }
1105 return variable_found;
1106}
1107
1108/// Structure to hold the info needed when comparing function
1109/// declarations.
1110namespace {
1111struct FuncDeclInfo {
1112 ConstString m_name;
1113 CompilerType m_copied_type;
1114 uint32_t m_decl_lvl;
1115 SymbolContext m_sym_ctx;
1116};
1117} // namespace
1118
1119SymbolContextList ClangExpressionDeclMap::SearchFunctionsInSymbolContexts(
1120 const SymbolContextList &sc_list,
1121 const CompilerDeclContext &frame_decl_context) {
1122 // First, symplify things by looping through the symbol contexts to
1123 // remove unwanted functions and separate out the functions we want to
1124 // compare and prune into a separate list. Cache the info needed about
1125 // the function declarations in a vector for efficiency.
1126 uint32_t num_indices = sc_list.GetSize();
1127 SymbolContextList sc_sym_list;
1128 std::vector<FuncDeclInfo> decl_infos;
1129 decl_infos.reserve(num_indices);
1130 clang::DeclContext *frame_decl_ctx =
1131 (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
1132 TypeSystemClang *ast = llvm::dyn_cast_or_null<TypeSystemClang>(
1
Assuming null pointer is passed into cast
2
'ast' initialized to a null pointer value
1133 frame_decl_context.GetTypeSystem());
1134
1135 for (uint32_t index = 0; index < num_indices; ++index) {
3
Assuming 'index' is < 'num_indices'
4
Loop condition is true. Entering loop body
1136 FuncDeclInfo fdi;
1137 SymbolContext sym_ctx;
1138 sc_list.GetContextAtIndex(index, sym_ctx);
1139
1140 // We don't know enough about symbols to compare them, but we should
1141 // keep them in the list.
1142 Function *function = sym_ctx.function;
1143 if (!function) {
5
Assuming 'function' is non-null
6
Taking false branch
1144 sc_sym_list.Append(sym_ctx);
1145 continue;
1146 }
1147 // Filter out functions without declaration contexts, as well as
1148 // class/instance methods, since they'll be skipped in the code that
1149 // follows anyway.
1150 CompilerDeclContext func_decl_context = function->GetDeclContext();
1151 if (!func_decl_context ||
7
Calling 'CompilerDeclContext::operator bool'
14
Returning from 'CompilerDeclContext::operator bool'
16
Taking false branch
1152 func_decl_context.IsClassMethod(nullptr, nullptr, nullptr))
15
Assuming the condition is false
1153 continue;
1154 // We can only prune functions for which we can copy the type.
1155 CompilerType func_clang_type = function->GetType()->GetFullCompilerType();
1156 CompilerType copied_func_type = GuardedCopyType(func_clang_type);
1157 if (!copied_func_type) {
17
Calling 'CompilerType::operator bool'
21
Returning from 'CompilerType::operator bool'
22
Taking false branch
1158 sc_sym_list.Append(sym_ctx);
1159 continue;
1160 }
1161
1162 fdi.m_sym_ctx = sym_ctx;
1163 fdi.m_name = function->GetName();
1164 fdi.m_copied_type = copied_func_type;
1165 fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL0xffffffffU;
1166 if (fdi.m_copied_type && func_decl_context) {
23
Calling 'CompilerType::operator bool'
25
Returning from 'CompilerType::operator bool'
26
Calling 'CompilerDeclContext::operator bool'
33
Returning from 'CompilerDeclContext::operator bool'
34
Taking true branch
1167 // Call CountDeclLevels to get the number of parent scopes we have
1168 // to look through before we find the function declaration. When
1169 // comparing functions of the same type, the one with a lower count
1170 // will be closer to us in the lookup scope and shadows the other.
1171 clang::DeclContext *func_decl_ctx =
1172 (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
1173 fdi.m_decl_lvl = ast->CountDeclLevels(frame_decl_ctx, func_decl_ctx,
35
Called C++ object pointer is null
1174 &fdi.m_name, &fdi.m_copied_type);
1175 }
1176 decl_infos.emplace_back(fdi);
1177 }
1178
1179 // Loop through the functions in our cache looking for matching types,
1180 // then compare their scope levels to see which is closer.
1181 std::multimap<CompilerType, const FuncDeclInfo *> matches;
1182 for (const FuncDeclInfo &fdi : decl_infos) {
1183 const CompilerType t = fdi.m_copied_type;
1184 auto q = matches.find(t);
1185 if (q != matches.end()) {
1186 if (q->second->m_decl_lvl > fdi.m_decl_lvl)
1187 // This function is closer; remove the old set.
1188 matches.erase(t);
1189 else if (q->second->m_decl_lvl < fdi.m_decl_lvl)
1190 // The functions in our set are closer - skip this one.
1191 continue;
1192 }
1193 matches.insert(std::make_pair(t, &fdi));
1194 }
1195
1196 // Loop through our matches and add their symbol contexts to our list.
1197 SymbolContextList sc_func_list;
1198 for (const auto &q : matches)
1199 sc_func_list.Append(q.second->m_sym_ctx);
1200
1201 // Rejoin the lists with the functions in front.
1202 sc_func_list.Append(sc_sym_list);
1203 return sc_func_list;
1204}
1205
1206void ClangExpressionDeclMap::LookupFunction(
1207 NameSearchContext &context, lldb::ModuleSP module_sp, ConstString name,
1208 const CompilerDeclContext &namespace_decl) {
1209 if (!m_parser_vars)
1210 return;
1211
1212 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1213
1214 std::vector<clang::NamedDecl *> decls_from_modules;
1215
1216 if (target) {
1217 if (std::shared_ptr<ClangModulesDeclVendor> decl_vendor =
1218 GetClangModulesDeclVendor()) {
1219 decl_vendor->FindDecls(name, false, UINT32_MAX0xffffffffU, decls_from_modules);
1220 }
1221 }
1222
1223 const bool include_inlines = false;
1224 SymbolContextList sc_list;
1225 if (namespace_decl && module_sp) {
1226 const bool include_symbols = false;
1227
1228 module_sp->FindFunctions(name, namespace_decl, eFunctionNameTypeBase,
1229 include_symbols, include_inlines, sc_list);
1230 } else if (target && !namespace_decl) {
1231 const bool include_symbols = true;
1232
1233 // TODO Fix FindFunctions so that it doesn't return
1234 // instance methods for eFunctionNameTypeBase.
1235
1236 target->GetImages().FindFunctions(
1237 name, eFunctionNameTypeFull | eFunctionNameTypeBase, include_symbols,
1238 include_inlines, sc_list);
1239 }
1240
1241 // If we found more than one function, see if we can use the frame's decl
1242 // context to remove functions that are shadowed by other functions which
1243 // match in type but are nearer in scope.
1244 //
1245 // AddOneFunction will not add a function whose type has already been
1246 // added, so if there's another function in the list with a matching type,
1247 // check to see if their decl context is a parent of the current frame's or
1248 // was imported via a and using statement, and pick the best match
1249 // according to lookup rules.
1250 if (sc_list.GetSize() > 1) {
1251 // Collect some info about our frame's context.
1252 StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1253 SymbolContext frame_sym_ctx;
1254 if (frame != nullptr)
1255 frame_sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
1256 lldb::eSymbolContextBlock);
1257 CompilerDeclContext frame_decl_context =
1258 frame_sym_ctx.block != nullptr ? frame_sym_ctx.block->GetDeclContext()
1259 : CompilerDeclContext();
1260
1261 // We can't do this without a compiler decl context for our frame.
1262 if (frame_decl_context) {
1263 sc_list = SearchFunctionsInSymbolContexts(sc_list, frame_decl_context);
1264 }
1265 }
1266
1267 if (sc_list.GetSize()) {
1268 Symbol *extern_symbol = nullptr;
1269 Symbol *non_extern_symbol = nullptr;
1270
1271 for (uint32_t index = 0, num_indices = sc_list.GetSize();
1272 index < num_indices; ++index) {
1273 SymbolContext sym_ctx;
1274 sc_list.GetContextAtIndex(index, sym_ctx);
1275
1276 if (sym_ctx.function) {
1277 CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();
1278
1279 if (!decl_ctx)
1280 continue;
1281
1282 // Filter out class/instance methods.
1283 if (decl_ctx.IsClassMethod(nullptr, nullptr, nullptr))
1284 continue;
1285
1286 AddOneFunction(context, sym_ctx.function, nullptr);
1287 context.m_found_function_with_type_info = true;
1288 context.m_found_function = true;
1289 } else if (sym_ctx.symbol) {
1290 if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target) {
1291 sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
1292 if (sym_ctx.symbol == nullptr)
1293 continue;
1294 }
1295
1296 if (sym_ctx.symbol->IsExternal())
1297 extern_symbol = sym_ctx.symbol;
1298 else
1299 non_extern_symbol = sym_ctx.symbol;
1300 }
1301 }
1302
1303 if (!context.m_found_function_with_type_info) {
1304 for (clang::NamedDecl *decl : decls_from_modules) {
1305 if (llvm::isa<clang::FunctionDecl>(decl)) {
1306 clang::NamedDecl *copied_decl =
1307 llvm::cast_or_null<FunctionDecl>(CopyDecl(decl));
1308 if (copied_decl) {
1309 context.AddNamedDecl(copied_decl);
1310 context.m_found_function_with_type_info = true;
1311 }
1312 }
1313 }
1314 }
1315
1316 if (!context.m_found_function_with_type_info) {
1317 if (extern_symbol) {
1318 AddOneFunction(context, nullptr, extern_symbol);
1319 context.m_found_function = true;
1320 } else if (non_extern_symbol) {
1321 AddOneFunction(context, nullptr, non_extern_symbol);
1322 context.m_found_function = true;
1323 }
1324 }
1325 }
1326}
1327
1328void ClangExpressionDeclMap::FindExternalVisibleDecls(
1329 NameSearchContext &context, lldb::ModuleSP module_sp,
1330 const CompilerDeclContext &namespace_decl) {
1331 assert(m_ast_context)((void)0);
1332
1333 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1334
1335 const ConstString name(context.m_decl_name.getAsString().c_str());
1336 if (IgnoreName(name, false))
1337 return;
1338
1339 // Only look for functions by name out in our symbols if the function doesn't
1340 // start with our phony prefix of '$'
1341
1342 Target *target = nullptr;
1343 StackFrame *frame = nullptr;
1344 SymbolContext sym_ctx;
1345 if (m_parser_vars) {
1346 target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1347 frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1348 }
1349 if (frame != nullptr)
1350 sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
1351 lldb::eSymbolContextBlock);
1352
1353 // Try the persistent decls, which take precedence over all else.
1354 if (!namespace_decl)
1355 SearchPersistenDecls(context, name);
1356
1357 if (name.GetStringRef().startswith("$") && !namespace_decl) {
1358 if (name == "$__lldb_class") {
1359 LookUpLldbClass(context);
1360 return;
1361 }
1362
1363 if (name == "$__lldb_objc_class") {
1364 LookUpLldbObjCClass(context);
1365 return;
1366 }
1367 if (name == g_lldb_local_vars_namespace_cstr) {
1368 LookupLocalVarNamespace(sym_ctx, context);
1369 return;
1370 }
1371
1372 // any other $__lldb names should be weeded out now
1373 if (name.GetStringRef().startswith("$__lldb"))
1374 return;
1375
1376 // No ParserVars means we can't do register or variable lookup.
1377 if (!m_parser_vars || !m_parser_vars->m_persistent_vars)
1378 return;
1379
1380 ExpressionVariableSP pvar_sp(
1381 m_parser_vars->m_persistent_vars->GetVariable(name));
1382
1383 if (pvar_sp) {
1384 AddOneVariable(context, pvar_sp);
1385 return;
1386 }
1387
1388 assert(name.GetStringRef().startswith("$"))((void)0);
1389 llvm::StringRef reg_name = name.GetStringRef().substr(1);
1390
1391 if (m_parser_vars->m_exe_ctx.GetRegisterContext()) {
1392 const RegisterInfo *reg_info(
1393 m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(
1394 reg_name));
1395
1396 if (reg_info) {
1397 LLDB_LOG(log, " CEDM::FEVD Found register {0}", reg_info->name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found register {0}", reg_info->name
); } while (0)
;
1398
1399 AddOneRegister(context, reg_info);
1400 }
1401 }
1402 return;
1403 }
1404
1405 bool local_var_lookup = !namespace_decl || (namespace_decl.GetName() ==
1406 g_lldb_local_vars_namespace_cstr);
1407 if (frame && local_var_lookup)
1408 if (LookupLocalVariable(context, name, sym_ctx, namespace_decl))
1409 return;
1410
1411 if (target) {
1412 ValueObjectSP valobj;
1413 VariableSP var;
1414 var = FindGlobalVariable(*target, module_sp, name, namespace_decl);
1415
1416 if (var) {
1417 valobj = ValueObjectVariable::Create(target, var);
1418 AddOneVariable(context, var, valobj);
1419 context.m_found_variable = true;
1420 return;
1421 }
1422 }
1423
1424 LookupFunction(context, module_sp, name, namespace_decl);
1425
1426 // Try the modules next.
1427 if (!context.m_found_function_with_type_info)
1428 LookupInModulesDeclVendor(context, name);
1429
1430 if (target && !context.m_found_variable && !namespace_decl) {
1431 // We couldn't find a non-symbol variable for this. Now we'll hunt for a
1432 // generic data symbol, and -- if it is found -- treat it as a variable.
1433 Status error;
1434
1435 const Symbol *data_symbol =
1436 m_parser_vars->m_sym_ctx.FindBestGlobalDataSymbol(name, error);
1437
1438 if (!error.Success()) {
1439 const unsigned diag_id =
1440 m_ast_context->getDiagnostics().getCustomDiagID(
1441 clang::DiagnosticsEngine::Level::Error, "%0");
1442 m_ast_context->getDiagnostics().Report(diag_id) << error.AsCString();
1443 }
1444
1445 if (data_symbol) {
1446 std::string warning("got name from symbols: ");
1447 warning.append(name.AsCString());
1448 const unsigned diag_id =
1449 m_ast_context->getDiagnostics().getCustomDiagID(
1450 clang::DiagnosticsEngine::Level::Warning, "%0");
1451 m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
1452 AddOneGenericVariable(context, *data_symbol);
1453 context.m_found_variable = true;
1454 }
1455 }
1456}
1457
1458bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
1459 lldb_private::Value &var_location,
1460 TypeFromUser *user_type,
1461 TypeFromParser *parser_type) {
1462 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1463
1464 Type *var_type = var->GetType();
1465
1466 if (!var_type) {
1467 LLDB_LOG(log, "Skipped a definition because it has no type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Skipped a definition because it has no type"); }
while (0)
;
1468 return false;
1469 }
1470
1471 CompilerType var_clang_type = var_type->GetFullCompilerType();
1472
1473 if (!var_clang_type) {
1474 LLDB_LOG(log, "Skipped a definition because it has no Clang type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Skipped a definition because it has no Clang type"
); } while (0)
;
1475 return false;
1476 }
1477
1478 TypeSystemClang *clang_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
1479 var_type->GetForwardCompilerType().GetTypeSystem());
1480
1481 if (!clang_ast) {
1482 LLDB_LOG(log, "Skipped a definition because it has no Clang AST")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Skipped a definition because it has no Clang AST"
); } while (0)
;
1483 return false;
1484 }
1485
1486 DWARFExpression &var_location_expr = var->LocationExpression();
1487
1488 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1489 Status err;
1490
1491 if (var->GetLocationIsConstantValueData()) {
1492 DataExtractor const_value_extractor;
1493
1494 if (var_location_expr.GetExpressionData(const_value_extractor)) {
1495 var_location = Value(const_value_extractor.GetDataStart(),
1496 const_value_extractor.GetByteSize());
1497 var_location.SetValueType(Value::ValueType::HostAddress);
1498 } else {
1499 LLDB_LOG(log, "Error evaluating constant variable: {0}", err.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Error evaluating constant variable: {0}", err.AsCString
()); } while (0)
;
1500 return false;
1501 }
1502 }
1503
1504 CompilerType type_to_use = GuardedCopyType(var_clang_type);
1505
1506 if (!type_to_use) {
1507 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Couldn't copy a variable's type into the parser's AST context"
); } while (0)
1508 "Couldn't copy a variable's type into the parser's AST context")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Couldn't copy a variable's type into the parser's AST context"
); } while (0)
;
1509
1510 return false;
1511 }
1512
1513 if (parser_type)
1514 *parser_type = TypeFromParser(type_to_use);
1515
1516 if (var_location.GetContextType() == Value::ContextType::Invalid)
1517 var_location.SetCompilerType(type_to_use);
1518
1519 if (var_location.GetValueType() == Value::ValueType::FileAddress) {
1520 SymbolContext var_sc;
1521 var->CalculateSymbolContext(&var_sc);
1522
1523 if (!var_sc.module_sp)
1524 return false;
1525
1526 Address so_addr(var_location.GetScalar().ULongLong(),
1527 var_sc.module_sp->GetSectionList());
1528
1529 lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
1530
1531 if (load_addr != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
1532 var_location.GetScalar() = load_addr;
1533 var_location.SetValueType(Value::ValueType::LoadAddress);
1534 }
1535 }
1536
1537 if (user_type)
1538 *user_type = TypeFromUser(var_clang_type);
1539
1540 return true;
1541}
1542
1543void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
1544 VariableSP var,
1545 ValueObjectSP valobj) {
1546 assert(m_parser_vars.get())((void)0);
1547
1548 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1549
1550 TypeFromUser ut;
1551 TypeFromParser pt;
1552 Value var_location;
1553
1554 if (!GetVariableValue(var, var_location, &ut, &pt))
1555 return;
1556
1557 clang::QualType parser_opaque_type =
1558 QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
1559
1560 if (parser_opaque_type.isNull())
1561 return;
1562
1563 if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
1564 if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
1565 CompleteType(tag_type->getDecl());
1566 if (const ObjCObjectPointerType *objc_object_ptr_type =
1567 dyn_cast<ObjCObjectPointerType>(parser_type))
1568 CompleteType(objc_object_ptr_type->getInterfaceDecl());
1569 }
1570
1571 bool is_reference = pt.IsReferenceType();
1572
1573 NamedDecl *var_decl = nullptr;
1574 if (is_reference)
1575 var_decl = context.AddVarDecl(pt);
1576 else
1577 var_decl = context.AddVarDecl(pt.GetLValueReferenceType());
1578
1579 std::string decl_name(context.m_decl_name.getAsString());
1580 ConstString entity_name(decl_name.c_str());
1581 ClangExpressionVariable *entity(new ClangExpressionVariable(valobj));
1582 m_found_entities.AddNewlyConstructedVariable(entity);
1583
1584 assert(entity)((void)0);
1585 entity->EnableParserVars(GetParserID());
1586 ClangExpressionVariable::ParserVars *parser_vars =
1587 entity->GetParserVars(GetParserID());
1588 parser_vars->m_named_decl = var_decl;
1589 parser_vars->m_llvm_value = nullptr;
1590 parser_vars->m_lldb_value = var_location;
1591 parser_vars->m_lldb_var = var;
1592
1593 if (is_reference)
1594 entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
1595
1596 LLDB_LOG(log, " CEDM::FEVD Found variable {1}, returned\n{2} (original {3})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found variable {1}, returned\n{2} (original {3})"
, decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString
(ut)); } while (0)
1597 decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString(ut))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found variable {1}, returned\n{2} (original {3})"
, decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString
(ut)); } while (0)
;
1598}
1599
1600void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
1601 ExpressionVariableSP &pvar_sp) {
1602 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1603
1604 TypeFromUser user_type(
1605 llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
1606
1607 TypeFromParser parser_type(GuardedCopyType(user_type));
1608
1609 if (!parser_type.GetOpaqueQualType()) {
1610 LLDB_LOG(log, " CEDM::FEVD Couldn't import type for pvar {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Couldn't import type for pvar {0}",
pvar_sp->GetName()); } while (0)
1611 pvar_sp->GetName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Couldn't import type for pvar {0}",
pvar_sp->GetName()); } while (0)
;
1612 return;
1613 }
1614
1615 NamedDecl *var_decl =
1616 context.AddVarDecl(parser_type.GetLValueReferenceType());
1617
1618 llvm::cast<ClangExpressionVariable>(pvar_sp.get())
1619 ->EnableParserVars(GetParserID());
1620 ClangExpressionVariable::ParserVars *parser_vars =
1621 llvm::cast<ClangExpressionVariable>(pvar_sp.get())
1622 ->GetParserVars(GetParserID());
1623 parser_vars->m_named_decl = var_decl;
1624 parser_vars->m_llvm_value = nullptr;
1625 parser_vars->m_lldb_value.Clear();
1626
1627 LLDB_LOG(log, " CEDM::FEVD Added pvar {1}, returned\n{2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Added pvar {1}, returned\n{2}", pvar_sp
->GetName(), ClangUtil::DumpDecl(var_decl)); } while (0)
1628 pvar_sp->GetName(), ClangUtil::DumpDecl(var_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Added pvar {1}, returned\n{2}", pvar_sp
->GetName(), ClangUtil::DumpDecl(var_decl)); } while (0)
;
1629}
1630
1631void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
1632 const Symbol &symbol) {
1633 assert(m_parser_vars.get())((void)0);
1634
1635 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1636
1637 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1638
1639 if (target == nullptr)
1640 return;
1641
1642 TypeSystemClang *scratch_ast_context = GetScratchContext(*target);
1643 if (!scratch_ast_context)
1644 return;
1645
1646 TypeFromUser user_type(scratch_ast_context->GetBasicType(eBasicTypeVoid)
1647 .GetPointerType()
1648 .GetLValueReferenceType());
1649 TypeFromParser parser_type(m_clang_ast_context->GetBasicType(eBasicTypeVoid)
1650 .GetPointerType()
1651 .GetLValueReferenceType());
1652 NamedDecl *var_decl = context.AddVarDecl(parser_type);
1653
1654 std::string decl_name(context.m_decl_name.getAsString());
1655 ConstString entity_name(decl_name.c_str());
1656 ClangExpressionVariable *entity(new ClangExpressionVariable(
1657 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(), entity_name,
1658 user_type, m_parser_vars->m_target_info.byte_order,
1659 m_parser_vars->m_target_info.address_byte_size));
1660 m_found_entities.AddNewlyConstructedVariable(entity);
1661
1662 entity->EnableParserVars(GetParserID());
1663 ClangExpressionVariable::ParserVars *parser_vars =
1664 entity->GetParserVars(GetParserID());
1665
1666 const Address symbol_address = symbol.GetAddress();
1667 lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
1668
1669 // parser_vars->m_lldb_value.SetContext(Value::ContextType::ClangType,
1670 // user_type.GetOpaqueQualType());
1671 parser_vars->m_lldb_value.SetCompilerType(user_type);
1672 parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
1673 parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
1674
1675 parser_vars->m_named_decl = var_decl;
1676 parser_vars->m_llvm_value = nullptr;
1677 parser_vars->m_lldb_sym = &symbol;
1678
1679 LLDB_LOG(log, " CEDM::FEVD Found variable {1}, returned\n{2}", decl_name,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found variable {1}, returned\n{2}",
decl_name, ClangUtil::DumpDecl(var_decl)); } while (0)
1680 ClangUtil::DumpDecl(var_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found variable {1}, returned\n{2}",
decl_name, ClangUtil::DumpDecl(var_decl)); } while (0)
;
1681}
1682
1683void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
1684 const RegisterInfo *reg_info) {
1685 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1686
1687 CompilerType clang_type =
1688 m_clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
1689 reg_info->encoding, reg_info->byte_size * 8);
1690
1691 if (!clang_type) {
1692 LLDB_LOG(log, " Tried to add a type for {0}, but couldn't get one",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Tried to add a type for {0}, but couldn't get one"
, context.m_decl_name.getAsString()); } while (0)
1693 context.m_decl_name.getAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Tried to add a type for {0}, but couldn't get one"
, context.m_decl_name.getAsString()); } while (0)
;
1694 return;
1695 }
1696
1697 TypeFromParser parser_clang_type(clang_type);
1698
1699 NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);
1700
1701 ClangExpressionVariable *entity(new ClangExpressionVariable(
1702 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1703 m_parser_vars->m_target_info.byte_order,
1704 m_parser_vars->m_target_info.address_byte_size));
1705 m_found_entities.AddNewlyConstructedVariable(entity);
1706
1707 std::string decl_name(context.m_decl_name.getAsString());
1708 entity->SetName(ConstString(decl_name.c_str()));
1709 entity->SetRegisterInfo(reg_info);
1710 entity->EnableParserVars(GetParserID());
1711 ClangExpressionVariable::ParserVars *parser_vars =
1712 entity->GetParserVars(GetParserID());
1713 parser_vars->m_named_decl = var_decl;
1714 parser_vars->m_llvm_value = nullptr;
1715 parser_vars->m_lldb_value.Clear();
1716 entity->m_flags |= ClangExpressionVariable::EVBareRegister;
1717
1718 LLDB_LOG(log, " CEDM::FEVD Added register {1}, returned\n{2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Added register {1}, returned\n{2}",
context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl
)); } while (0)
1719 context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Added register {1}, returned\n{2}",
context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl
)); } while (0)
;
1720}
1721
1722void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
1723 Function *function,
1724 Symbol *symbol) {
1725 assert(m_parser_vars.get())((void)0);
1726
1727 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1728
1729 NamedDecl *function_decl = nullptr;
1730 Address fun_address;
1731 CompilerType function_clang_type;
1732
1733 bool is_indirect_function = false;
1734
1735 if (function) {
1736 Type *function_type = function->GetType();
1737
1738 const auto lang = function->GetCompileUnit()->GetLanguage();
1739 const auto name = function->GetMangled().GetMangledName().AsCString();
1740 const bool extern_c = (Language::LanguageIsC(lang) &&
1741 !CPlusPlusLanguage::IsCPPMangledName(name)) ||
1742 (Language::LanguageIsObjC(lang) &&
1743 !Language::LanguageIsCPlusPlus(lang));
1744
1745 if (!extern_c) {
1746 TypeSystem *type_system = function->GetDeclContext().GetTypeSystem();
1747 if (llvm::isa<TypeSystemClang>(type_system)) {
1748 clang::DeclContext *src_decl_context =
1749 (clang::DeclContext *)function->GetDeclContext()
1750 .GetOpaqueDeclContext();
1751 clang::FunctionDecl *src_function_decl =
1752 llvm::dyn_cast_or_null<clang::FunctionDecl>(src_decl_context);
1753 if (src_function_decl &&
1754 src_function_decl->getTemplateSpecializationInfo()) {
1755 clang::FunctionTemplateDecl *function_template =
1756 src_function_decl->getTemplateSpecializationInfo()->getTemplate();
1757 clang::FunctionTemplateDecl *copied_function_template =
1758 llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(
1759 CopyDecl(function_template));
1760 if (copied_function_template) {
1761 if (log) {
1762 StreamString ss;
1763
1764 function->DumpSymbolContext(&ss);
1765
1766 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function template"
" {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
1767 " CEDM::FEVD Imported decl for function template"do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function template"
" {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
1768 " {1} (description {2}), returned\n{3}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function template"
" {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
1769 copied_function_template->getNameAsString(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function template"
" {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
1770 ss.GetData(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function template"
" {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
1771 ClangUtil::DumpDecl(copied_function_template))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function template"
" {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
;
1772 }
1773
1774 context.AddNamedDecl(copied_function_template);
1775 }
1776 } else if (src_function_decl) {
1777 if (clang::FunctionDecl *copied_function_decl =
1778 llvm::dyn_cast_or_null<clang::FunctionDecl>(
1779 CopyDecl(src_function_decl))) {
1780 if (log) {
1781 StreamString ss;
1782
1783 function->DumpSymbolContext(&ss);
1784
1785 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
1786 " CEDM::FEVD Imported decl for function {1} "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
1787 "(description {2}), returned\n{3}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
1788 copied_function_decl->getNameAsString(), ss.GetData(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
1789 ClangUtil::DumpDecl(copied_function_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
;
1790 }
1791
1792 context.AddNamedDecl(copied_function_decl);
1793 return;
1794 } else {
1795 LLDB_LOG(log, " Failed to import the function decl for '{0}'",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to import the function decl for '{0}'",
src_function_decl->getName()); } while (0)
1796 src_function_decl->getName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to import the function decl for '{0}'",
src_function_decl->getName()); } while (0)
;
1797 }
1798 }
1799 }
1800 }
1801
1802 if (!function_type) {
1803 LLDB_LOG(log, " Skipped a function because it has no type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Skipped a function because it has no type"); }
while (0)
;
1804 return;
1805 }
1806
1807 function_clang_type = function_type->GetFullCompilerType();
1808
1809 if (!function_clang_type) {
1810 LLDB_LOG(log, " Skipped a function because it has no Clang type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Skipped a function because it has no Clang type"
); } while (0)
;
1811 return;
1812 }
1813
1814 fun_address = function->GetAddressRange().GetBaseAddress();
1815
1816 CompilerType copied_function_type = GuardedCopyType(function_clang_type);
1817 if (copied_function_type) {
1818 function_decl = context.AddFunDecl(copied_function_type, extern_c);
1819
1820 if (!function_decl) {
1821 LLDB_LOG(log, " Failed to create a function decl for '{0}' ({1:x})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to create a function decl for '{0}' ({1:x})"
, function_type->GetName(), function_type->GetID()); } while
(0)
1822 function_type->GetName(), function_type->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to create a function decl for '{0}' ({1:x})"
, function_type->GetName(), function_type->GetID()); } while
(0)
;
1823
1824 return;
1825 }
1826 } else {
1827 // We failed to copy the type we found
1828 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to import the function type '{0}' ({1:x})"
" into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
1829 " Failed to import the function type '{0}' ({1:x})"do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to import the function type '{0}' ({1:x})"
" into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
1830 " into the expression parser AST contenxt",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to import the function type '{0}' ({1:x})"
" into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
1831 function_type->GetName(), function_type->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " Failed to import the function type '{0}' ({1:x})"
" into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
;
1832
1833 return;
1834 }
1835 } else if (symbol) {
1836 fun_address = symbol->GetAddress();
1837 function_decl = context.AddGenericFunDecl();
1838 is_indirect_function = symbol->IsIndirect();
1839 } else {
1840 LLDB_LOG(log, " AddOneFunction called with no function and no symbol")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " AddOneFunction called with no function and no symbol"
); } while (0)
;
1841 return;
1842 }
1843
1844 Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1845
1846 lldb::addr_t load_addr =
1847 fun_address.GetCallableLoadAddress(target, is_indirect_function);
1848
1849 ClangExpressionVariable *entity(new ClangExpressionVariable(
1850 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1851 m_parser_vars->m_target_info.byte_order,
1852 m_parser_vars->m_target_info.address_byte_size));
1853 m_found_entities.AddNewlyConstructedVariable(entity);
1854
1855 std::string decl_name(context.m_decl_name.getAsString());
1856 entity->SetName(ConstString(decl_name.c_str()));
1857 entity->SetCompilerType(function_clang_type);
1858 entity->EnableParserVars(GetParserID());
1859
1860 ClangExpressionVariable::ParserVars *parser_vars =
1861 entity->GetParserVars(GetParserID());
1862
1863 if (load_addr != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
1864 parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
1865 parser_vars->m_lldb_value.GetScalar() = load_addr;
1866 } else {
1867 // We have to try finding a file address.
1868
1869 lldb::addr_t file_addr = fun_address.GetFileAddress();
1870
1871 parser_vars->m_lldb_value.SetValueType(Value::ValueType::FileAddress);
1872 parser_vars->m_lldb_value.GetScalar() = file_addr;
1873 }
1874
1875 parser_vars->m_named_decl = function_decl;
1876 parser_vars->m_llvm_value = nullptr;
1877
1878 if (log) {
1879 StreamString ss;
1880
1881 fun_address.Dump(&ss,
1882 m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1883 Address::DumpStyleResolvedDescription);
1884
1885 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found {1} function {2} (description {3}), "
"returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
1886 " CEDM::FEVD Found {1} function {2} (description {3}), "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found {1} function {2} (description {3}), "
"returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
1887 "returned\n{4}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found {1} function {2} (description {3}), "
"returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
1888 (function ? "specific" : "generic"), decl_name, ss.GetData(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found {1} function {2} (description {3}), "
"returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
1889 ClangUtil::DumpDecl(function_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::FEVD Found {1} function {2} (description {3}), "
"returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
;
1890 }
1891}
1892
1893void ClangExpressionDeclMap::AddContextClassType(NameSearchContext &context,
1894 const TypeFromUser &ut) {
1895 CompilerType copied_clang_type = GuardedCopyType(ut);
1896
1897 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1898
1899 if (!copied_clang_type) {
1900 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddThisType - Couldn't import the type"
); } while (0)
1901 "ClangExpressionDeclMap::AddThisType - Couldn't import the type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddThisType - Couldn't import the type"
); } while (0)
;
1902
1903 return;
1904 }
1905
1906 if (copied_clang_type.IsAggregateType() &&
1907 copied_clang_type.GetCompleteType()) {
1908 CompilerType void_clang_type =
1909 m_clang_ast_context->GetBasicType(eBasicTypeVoid);
1910 CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();
1911
1912 CompilerType method_type = m_clang_ast_context->CreateFunctionType(
1913 void_clang_type, &void_ptr_clang_type, 1, false, 0);
1914
1915 const bool is_virtual = false;
1916 const bool is_static = false;
1917 const bool is_inline = false;
1918 const bool is_explicit = false;
1919 const bool is_attr_used = true;
1920 const bool is_artificial = false;
1921
1922 CXXMethodDecl *method_decl = m_clang_ast_context->AddMethodToCXXRecordType(
1923 copied_clang_type.GetOpaqueQualType(), "$__lldb_expr", nullptr,
1924 method_type, lldb::eAccessPublic, is_virtual, is_static, is_inline,
1925 is_explicit, is_attr_used, is_artificial);
1926
1927 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::AddThisType Added function $__lldb_expr "
"(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
(0)
1928 " CEDM::AddThisType Added function $__lldb_expr "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::AddThisType Added function $__lldb_expr "
"(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
(0)
1929 "(description {0}) for this type\n{1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::AddThisType Added function $__lldb_expr "
"(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
(0)
1930 ClangUtil::ToString(copied_clang_type),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::AddThisType Added function $__lldb_expr "
"(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
(0)
1931 ClangUtil::DumpDecl(method_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, " CEDM::AddThisType Added function $__lldb_expr "
"(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
(0)
;
1932 }
1933
1934 if (!copied_clang_type.IsValid())
1935 return;
1936
1937 TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(
1938 QualType::getFromOpaquePtr(copied_clang_type.GetOpaqueQualType()));
1939
1940 if (!type_source_info)
1941 return;
1942
1943 // Construct a typedef type because if "*this" is a templated type we can't
1944 // just return ClassTemplateSpecializationDecls in response to name queries.
1945 // Using a typedef makes this much more robust.
1946
1947 TypedefDecl *typedef_decl = TypedefDecl::Create(
1948 *m_ast_context, m_ast_context->getTranslationUnitDecl(), SourceLocation(),
1949 SourceLocation(), context.m_decl_name.getAsIdentifierInfo(),
1950 type_source_info);
1951
1952 if (!typedef_decl)
1953 return;
1954
1955 context.AddNamedDecl(typedef_decl);
1956
1957 return;
1958}
1959
1960void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
1961 const TypeFromUser &ut) {
1962 CompilerType copied_clang_type = GuardedCopyType(ut);
1963
1964 if (!copied_clang_type) {
1965 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
1966
1967 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddOneType - Couldn't import the type"
); } while (0)
1968 "ClangExpressionDeclMap::AddOneType - Couldn't import the type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddOneType - Couldn't import the type"
); } while (0)
;
1969
1970 return;
1971 }
1972
1973 context.AddTypeDecl(copied_clang_type);
1974}

/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/include/lldb/Symbol/CompilerDeclContext.h

1//===-- CompilerDeclContext.h -----------------------------------*- C++ -*-===//
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#ifndef LLDB_SYMBOL_COMPILERDECLCONTEXT_H
10#define LLDB_SYMBOL_COMPILERDECLCONTEXT_H
11
12#include <vector>
13
14#include "lldb/Utility/ConstString.h"
15#include "lldb/lldb-private.h"
16
17namespace lldb_private {
18
19/// Represents a generic declaration context in a program. A declaration context
20/// is data structure that contains declarations (e.g. namespaces).
21///
22/// This class serves as an abstraction for a declaration context inside one of
23/// the TypeSystems implemented by the language plugins. It does not have any
24/// actual logic in it but only stores an opaque pointer and a pointer to the
25/// TypeSystem that gives meaning to this opaque pointer. All methods of this
26/// class should call their respective method in the TypeSystem interface and
27/// pass the opaque pointer along.
28///
29/// \see lldb_private::TypeSystem
30class CompilerDeclContext {
31public:
32 /// Constructs an invalid CompilerDeclContext.
33 CompilerDeclContext() = default;
34
35 /// Constructs a CompilerDeclContext with the given opaque decl context
36 /// and its respective TypeSystem instance.
37 ///
38 /// This constructor should only be called from the respective TypeSystem
39 /// implementation.
40 ///
41 /// \see lldb_private::TypeSystemClang::CreateDeclContext(clang::DeclContext*)
42 CompilerDeclContext(TypeSystem *type_system, void *decl_ctx)
43 : m_type_system(type_system), m_opaque_decl_ctx(decl_ctx) {}
44
45 // Tests
46
47 explicit operator bool() const { return IsValid(); }
8
Calling 'CompilerDeclContext::IsValid'
12
Returning from 'CompilerDeclContext::IsValid'
13
Returning the value 1, which participates in a condition later
27
Calling 'CompilerDeclContext::IsValid'
31
Returning from 'CompilerDeclContext::IsValid'
32
Returning the value 1, which participates in a condition later
48
49 bool operator<(const CompilerDeclContext &rhs) const {
50 if (m_type_system == rhs.m_type_system)
51 return m_opaque_decl_ctx < rhs.m_opaque_decl_ctx;
52 return m_type_system < rhs.m_type_system;
53 }
54
55 bool IsValid() const {
56 return m_type_system != nullptr && m_opaque_decl_ctx != nullptr;
9
Assuming the condition is true
10
Assuming the condition is true
11
Returning the value 1, which participates in a condition later
28
Assuming the condition is true
29
Assuming the condition is true
30
Returning the value 1, which participates in a condition later
57 }
58
59 std::vector<CompilerDecl> FindDeclByName(ConstString name,
60 const bool ignore_using_decls);
61
62 /// Checks if this decl context represents a method of a class.
63 ///
64 /// \param[out] language_ptr
65 /// If non NULL and \b true is returned from this function,
66 /// this will indicate if the language that respresents the method.
67 ///
68 /// \param[out] is_instance_method_ptr
69 /// If non NULL and \b true is returned from this function,
70 /// this will indicate if the method is an instance function (true)
71 /// or a class method (false indicating the function is static, or
72 /// doesn't require an instance of the class to be called).
73 ///
74 /// \param[out] language_object_name_ptr
75 /// If non NULL and \b true is returned from this function,
76 /// this will indicate if implicit object name for the language
77 /// like "this" for C++, and "self" for Objective C.
78 ///
79 /// \return
80 /// Returns true if this is a decl context that represents a method
81 /// in a struct, union or class.
82 bool IsClassMethod(lldb::LanguageType *language_ptr,
83 bool *is_instance_method_ptr,
84 ConstString *language_object_name_ptr);
85
86 /// Check if the given other decl context is contained in the lookup
87 /// of this decl context (for example because the other context is a nested
88 /// inline namespace).
89 ///
90 /// @param[in] other
91 /// The other decl context for which we should check if it is contained
92 /// in the lookoup of this context.
93 ///
94 /// @return
95 /// Returns true iff the other decl context is contained in the lookup
96 /// of this decl context.
97 bool IsContainedInLookup(CompilerDeclContext other) const;
98
99 // Accessors
100
101 TypeSystem *GetTypeSystem() const { return m_type_system; }
102
103 void *GetOpaqueDeclContext() const { return m_opaque_decl_ctx; }
104
105 void SetDeclContext(TypeSystem *type_system, void *decl_ctx) {
106 m_type_system = type_system;
107 m_opaque_decl_ctx = decl_ctx;
108 }
109
110 void Clear() {
111 m_type_system = nullptr;
112 m_opaque_decl_ctx = nullptr;
113 }
114
115 ConstString GetName() const;
116
117 ConstString GetScopeQualifiedName() const;
118
119private:
120 TypeSystem *m_type_system = nullptr;
121 void *m_opaque_decl_ctx = nullptr;
122};
123
124bool operator==(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
125bool operator!=(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
126
127} // namespace lldb_private
128
129#endif // LLDB_SYMBOL_COMPILERDECLCONTEXT_H

/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/include/lldb/Symbol/CompilerType.h

1//===-- CompilerType.h ------------------------------------------*- C++ -*-===//
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#ifndef LLDB_SYMBOL_COMPILERTYPE_H
10#define LLDB_SYMBOL_COMPILERTYPE_H
11
12#include <functional>
13#include <string>
14#include <vector>
15
16#include "lldb/lldb-private.h"
17#include "llvm/ADT/APSInt.h"
18
19namespace lldb_private {
20
21class DataExtractor;
22
23/// Generic representation of a type in a programming language.
24///
25/// This class serves as an abstraction for a type inside one of the TypeSystems
26/// implemented by the language plugins. It does not have any actual logic in it
27/// but only stores an opaque pointer and a pointer to the TypeSystem that
28/// gives meaning to this opaque pointer. All methods of this class should call
29/// their respective method in the TypeSystem interface and pass the opaque
30/// pointer along.
31///
32/// \see lldb_private::TypeSystem
33class CompilerType {
34public:
35 /// Creates a CompilerType with the given TypeSystem and opaque compiler type.
36 ///
37 /// This constructor should only be called from the respective TypeSystem
38 /// implementation.
39 ///
40 /// \see lldb_private::TypeSystemClang::GetType(clang::QualType)
41 CompilerType(TypeSystem *type_system, lldb::opaque_compiler_type_t type)
42 : m_type(type), m_type_system(type_system) {
43 assert(Verify() && "verification failed")((void)0);
44 }
45
46 CompilerType(const CompilerType &rhs)
47 : m_type(rhs.m_type), m_type_system(rhs.m_type_system) {}
48
49 CompilerType() = default;
50
51 /// Operators.
52 /// \{
53 const CompilerType &operator=(const CompilerType &rhs) {
54 m_type = rhs.m_type;
55 m_type_system = rhs.m_type_system;
56 return *this;
57 }
58
59 bool operator<(const CompilerType &rhs) const {
60 if (m_type_system == rhs.m_type_system)
61 return m_type < rhs.m_type;
62 return m_type_system < rhs.m_type_system;
63 }
64 /// \}
65
66 /// Tests.
67 /// \{
68 explicit operator bool() const {
69 return m_type != nullptr && m_type_system != nullptr;
18
Assuming the condition is true
19
Assuming the condition is true
20
Returning the value 1, which participates in a condition later
24
Returning the value 1, which participates in a condition later
70 }
71
72 bool IsValid() const { return m_type != nullptr && m_type_system != nullptr; }
73
74 bool IsArrayType(CompilerType *element_type = nullptr,
75 uint64_t *size = nullptr,
76 bool *is_incomplete = nullptr) const;
77
78 bool IsVectorType(CompilerType *element_type = nullptr,
79 uint64_t *size = nullptr) const;
80
81 bool IsArrayOfScalarType() const;
82
83 bool IsAggregateType() const;
84
85 bool IsAnonymousType() const;
86
87 bool IsScopedEnumerationType() const;
88
89 bool IsBeingDefined() const;
90
91 bool IsCharType() const;
92
93 bool IsCompleteType() const;
94
95 bool IsConst() const;
96
97 bool IsCStringType(uint32_t &length) const;
98
99 bool IsDefined() const;
100
101 bool IsFloatingPointType(uint32_t &count, bool &is_complex) const;
102
103 bool IsFunctionType() const;
104
105 uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const;
106
107 size_t GetNumberOfFunctionArguments() const;
108
109 CompilerType GetFunctionArgumentAtIndex(const size_t index) const;
110
111 bool IsVariadicFunctionType() const;
112
113 bool IsFunctionPointerType() const;
114
115 bool
116 IsBlockPointerType(CompilerType *function_pointer_type_ptr = nullptr) const;
117
118 bool IsIntegerType(bool &is_signed) const;
119
120 bool IsEnumerationType(bool &is_signed) const;
121
122 bool IsIntegerOrEnumerationType(bool &is_signed) const;
123
124 bool IsPolymorphicClass() const;
125
126 /// \param target_type Can pass nullptr.
127 bool IsPossibleDynamicType(CompilerType *target_type, bool check_cplusplus,
128 bool check_objc) const;
129
130 bool IsPointerToScalarType() const;
131
132 bool IsRuntimeGeneratedType() const;
133
134 bool IsPointerType(CompilerType *pointee_type = nullptr) const;
135
136 bool IsPointerOrReferenceType(CompilerType *pointee_type = nullptr) const;
137
138 bool IsReferenceType(CompilerType *pointee_type = nullptr,
139 bool *is_rvalue = nullptr) const;
140
141 bool ShouldTreatScalarValueAsAddress() const;
142
143 bool IsScalarType() const;
144
145 bool IsTypedefType() const;
146
147 bool IsVoidType() const;
148 /// \}
149
150 /// Type Completion.
151 /// \{
152 bool GetCompleteType() const;
153 /// \}
154
155 /// AST related queries.
156 /// \{
157 size_t GetPointerByteSize() const;
158 /// \}
159
160 /// Accessors.
161 /// \{
162 TypeSystem *GetTypeSystem() const { return m_type_system; }
163
164 ConstString GetTypeName() const;
165
166 ConstString GetDisplayTypeName() const;
167
168 uint32_t
169 GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) const;
170
171 lldb::LanguageType GetMinimumLanguage();
172
173 lldb::opaque_compiler_type_t GetOpaqueQualType() const { return m_type; }
174
175 lldb::TypeClass GetTypeClass() const;
176
177 void SetCompilerType(TypeSystem *type_system,
178 lldb::opaque_compiler_type_t type);
179
180 unsigned GetTypeQualifiers() const;
181 /// \}
182
183 /// Creating related types.
184 /// \{
185 CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const;
186
187 CompilerType GetArrayType(uint64_t size) const;
188
189 CompilerType GetCanonicalType() const;
190
191 CompilerType GetFullyUnqualifiedType() const;
192
193 CompilerType GetEnumerationIntegerType() const;
194
195 /// Returns -1 if this isn't a function of if the function doesn't
196 /// have a prototype Returns a value >= 0 if there is a prototype.
197 int GetFunctionArgumentCount() const;
198
199 CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const;
200
201 CompilerType GetFunctionReturnType() const;
202
203 size_t GetNumMemberFunctions() const;
204
205 TypeMemberFunctionImpl GetMemberFunctionAtIndex(size_t idx);
206
207 /// If this type is a reference to a type (L value or R value reference),
208 /// return a new type with the reference removed, else return the current type
209 /// itself.
210 CompilerType GetNonReferenceType() const;
211
212 /// If this type is a pointer type, return the type that the pointer points
213 /// to, else return an invalid type.
214 CompilerType GetPointeeType() const;
215
216 /// Return a new CompilerType that is a pointer to this type
217 CompilerType GetPointerType() const;
218
219 /// Return a new CompilerType that is a L value reference to this type if this
220 /// type is valid and the type system supports L value references, else return
221 /// an invalid type.
222 CompilerType GetLValueReferenceType() const;
223
224 /// Return a new CompilerType that is a R value reference to this type if this
225 /// type is valid and the type system supports R value references, else return
226 /// an invalid type.
227 CompilerType GetRValueReferenceType() const;
228
229 /// Return a new CompilerType adds a const modifier to this type if this type
230 /// is valid and the type system supports const modifiers, else return an
231 /// invalid type.
232 CompilerType AddConstModifier() const;
233
234 /// Return a new CompilerType adds a volatile modifier to this type if this
235 /// type is valid and the type system supports volatile modifiers, else return
236 /// an invalid type.
237 CompilerType AddVolatileModifier() const;
238
239 /// Return a new CompilerType that is the atomic type of this type. If this
240 /// type is not valid or the type system doesn't support atomic types, this
241 /// returns an invalid type.
242 CompilerType GetAtomicType() const;
243
244 /// Return a new CompilerType adds a restrict modifier to this type if this
245 /// type is valid and the type system supports restrict modifiers, else return
246 /// an invalid type.
247 CompilerType AddRestrictModifier() const;
248
249 /// Create a typedef to this type using "name" as the name of the typedef this
250 /// type is valid and the type system supports typedefs, else return an
251 /// invalid type.
252 /// \param payload The typesystem-specific \p lldb::Type payload.
253 CompilerType CreateTypedef(const char *name,
254 const CompilerDeclContext &decl_ctx,
255 uint32_t payload) const;
256
257 /// If the current object represents a typedef type, get the underlying type
258 CompilerType GetTypedefedType() const;
259
260 /// Create related types using the current type's AST
261 CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const;
262 /// \}
263
264 /// Exploring the type.
265 /// \{
266 struct IntegralTemplateArgument;
267
268 /// Return the size of the type in bytes.
269 llvm::Optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope) const;
270 /// Return the size of the type in bits.
271 llvm::Optional<uint64_t> GetBitSize(ExecutionContextScope *exe_scope) const;
272
273 lldb::Encoding GetEncoding(uint64_t &count) const;
274
275 lldb::Format GetFormat() const;
276
277 llvm::Optional<size_t>
278 GetTypeBitAlign(ExecutionContextScope *exe_scope) const;
279
280 uint32_t GetNumChildren(bool omit_empty_base_classes,
281 const ExecutionContext *exe_ctx) const;
282
283 lldb::BasicType GetBasicTypeEnumeration() const;
284
285 static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
286
287 /// If this type is an enumeration, iterate through all of its enumerators
288 /// using a callback. If the callback returns true, keep iterating, else abort
289 /// the iteration.
290 void ForEachEnumerator(
291 std::function<bool(const CompilerType &integer_type, ConstString name,
292 const llvm::APSInt &value)> const &callback) const;
293
294 uint32_t GetNumFields() const;
295
296 CompilerType GetFieldAtIndex(size_t idx, std::string &name,
297 uint64_t *bit_offset_ptr,
298 uint32_t *bitfield_bit_size_ptr,
299 bool *is_bitfield_ptr) const;
300
301 uint32_t GetNumDirectBaseClasses() const;
302
303 uint32_t GetNumVirtualBaseClasses() const;
304
305 CompilerType GetDirectBaseClassAtIndex(size_t idx,
306 uint32_t *bit_offset_ptr) const;
307
308 CompilerType GetVirtualBaseClassAtIndex(size_t idx,
309 uint32_t *bit_offset_ptr) const;
310
311 uint32_t GetIndexOfFieldWithName(const char *name,
312 CompilerType *field_compiler_type = nullptr,
313 uint64_t *bit_offset_ptr = nullptr,
314 uint32_t *bitfield_bit_size_ptr = nullptr,
315 bool *is_bitfield_ptr = nullptr) const;
316
317 CompilerType GetChildCompilerTypeAtIndex(
318 ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
319 bool omit_empty_base_classes, bool ignore_array_bounds,
320 std::string &child_name, uint32_t &child_byte_size,
321 int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
322 uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
323 bool &child_is_deref_of_parent, ValueObject *valobj,
324 uint64_t &language_flags) const;
325
326 /// Lookup a child given a name. This function will match base class names and
327 /// member member names in "clang_type" only, not descendants.
328 uint32_t GetIndexOfChildWithName(const char *name,
329 bool omit_empty_base_classes) const;
330
331 /// Lookup a child member given a name. This function will match member names
332 /// only and will descend into "clang_type" children in search for the first
333 /// member in this class, or any base class that matches "name".
334 /// TODO: Return all matches for a given name by returning a
335 /// vector<vector<uint32_t>>
336 /// so we catch all names that match a given child name, not just the first.
337 size_t
338 GetIndexOfChildMemberWithName(const char *name, bool omit_empty_base_classes,
339 std::vector<uint32_t> &child_indexes) const;
340
341 size_t GetNumTemplateArguments() const;
342
343 lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
344 CompilerType GetTypeTemplateArgument(size_t idx) const;
345
346 /// Returns the value of the template argument and its type.
347 llvm::Optional<IntegralTemplateArgument>
348 GetIntegralTemplateArgument(size_t idx) const;
349
350 CompilerType GetTypeForFormatters() const;
351
352 LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;
353
354 bool IsMeaninglessWithoutDynamicResolution() const;
355 /// \}
356
357 /// Dumping types.
358 /// \{
359#ifndef NDEBUG1
360 /// Convenience LLVM-style dump method for use in the debugger only.
361 /// Don't call this function from actual code.
362 LLVM_DUMP_METHOD__attribute__((noinline)) void dump() const;
363#endif
364
365 void DumpValue(ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
366 const DataExtractor &data, lldb::offset_t data_offset,
367 size_t data_byte_size, uint32_t bitfield_bit_size,
368 uint32_t bitfield_bit_offset, bool show_types,
369 bool show_summary, bool verbose, uint32_t depth);
370
371 bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data,
372 lldb::offset_t data_offset, size_t data_byte_size,
373 uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
374 ExecutionContextScope *exe_scope);
375
376 void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
377 const DataExtractor &data, lldb::offset_t data_offset,
378 size_t data_byte_size);
379
380 /// Dump to stdout.
381 void DumpTypeDescription(lldb::DescriptionLevel level =
382 lldb::eDescriptionLevelFull) const;
383
384 /// Print a description of the type to a stream. The exact implementation
385 /// varies, but the expectation is that eDescriptionLevelFull returns a
386 /// source-like representation of the type, whereas eDescriptionLevelVerbose
387 /// does a dump of the underlying AST if applicable.
388 void DumpTypeDescription(Stream *s, lldb::DescriptionLevel level =
389 lldb::eDescriptionLevelFull) const;
390 /// \}
391
392 bool GetValueAsScalar(const DataExtractor &data, lldb::offset_t data_offset,
393 size_t data_byte_size, Scalar &value,
394 ExecutionContextScope *exe_scope) const;
395 void Clear() {
396 m_type = nullptr;
397 m_type_system = nullptr;
398 }
399
400private:
401#ifndef NDEBUG1
402 /// If the type is valid, ask the TypeSystem to verify the integrity
403 /// of the type to catch CompilerTypes that mix and match invalid
404 /// TypeSystem/Opaque type pairs.
405 bool Verify() const;
406#endif
407
408 lldb::opaque_compiler_type_t m_type = nullptr;
409 TypeSystem *m_type_system = nullptr;
410};
411
412bool operator==(const CompilerType &lhs, const CompilerType &rhs);
413bool operator!=(const CompilerType &lhs, const CompilerType &rhs);
414
415struct CompilerType::IntegralTemplateArgument {
416 llvm::APSInt value;
417 CompilerType type;
418};
419
420} // namespace lldb_private
421
422#endif // LLDB_SYMBOL_COMPILERTYPE_H