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 |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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 | ||||
58 | using namespace lldb; | |||
59 | using namespace lldb_private; | |||
60 | using namespace clang; | |||
61 | ||||
62 | namespace { | |||
63 | const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars"; | |||
64 | } // anonymous namespace | |||
65 | ||||
66 | ClangExpressionDeclMap::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 | ||||
78 | ClangExpressionDeclMap::~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 | ||||
87 | bool 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 | ||||
123 | void 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 | ||||
129 | void ClangExpressionDeclMap::InstallDiagnosticManager( | |||
130 | DiagnosticManager &diag_manager) { | |||
131 | assert(m_parser_vars)((void)0); | |||
132 | m_parser_vars->m_diagnostics = &diag_manager; | |||
133 | } | |||
134 | ||||
135 | void 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 | ||||
162 | ClangExpressionDeclMap::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 | ||||
184 | TypeFromUser 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 | ||||
194 | bool 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 | ||||
324 | bool 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 | ||||
412 | bool 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 | ||||
429 | bool 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 | ||||
443 | bool 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 | ||||
479 | bool 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 | ||||
498 | addr_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 | ||||
598 | addr_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 | ||||
610 | lldb::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 | ||||
625 | TypeSystemClang *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 | ||||
645 | void 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 | ||||
709 | void 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 | ||||
717 | clang::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 | ||||
731 | void 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 | ||||
760 | void 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 | ||||
861 | void 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 | ||||
991 | void 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 | ||||
1017 | void 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 | ||||
1064 | bool 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. | |||
1110 | namespace { | |||
1111 | struct 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 | ||||
1119 | SymbolContextList 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>( | |||
| ||||
1133 | frame_decl_context.GetTypeSystem()); | |||
1134 | ||||
1135 | for (uint32_t index = 0; index < num_indices; ++index) { | |||
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) { | |||
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 || | |||
1152 | func_decl_context.IsClassMethod(nullptr, nullptr, nullptr)) | |||
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) { | |||
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) { | |||
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, | |||
| ||||
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 | ||||
1206 | void 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 | ||||
1328 | void 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 | ||||
1458 | bool 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 | ||||
1543 | void 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 | ||||
1600 | void 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 | ||||
1631 | void 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 | ||||
1683 | void 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 | ||||
1722 | void 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 | ||||
1893 | void 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 | ||||
1960 | void 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 | } |
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 | |
17 | namespace 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 |
30 | class CompilerDeclContext { |
31 | public: |
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(); } |
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; |
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 | |
119 | private: |
120 | TypeSystem *m_type_system = nullptr; |
121 | void *m_opaque_decl_ctx = nullptr; |
122 | }; |
123 | |
124 | bool operator==(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs); |
125 | bool operator!=(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs); |
126 | |
127 | } // namespace lldb_private |
128 | |
129 | #endif // LLDB_SYMBOL_COMPILERDECLCONTEXT_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 | |
19 | namespace lldb_private { |
20 | |
21 | class 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 |
33 | class CompilerType { |
34 | public: |
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; |
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 | |
400 | private: |
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 | |
412 | bool operator==(const CompilerType &lhs, const CompilerType &rhs); |
413 | bool operator!=(const CompilerType &lhs, const CompilerType &rhs); |
414 | |
415 | struct CompilerType::IntegralTemplateArgument { |
416 | llvm::APSInt value; |
417 | CompilerType type; |
418 | }; |
419 | |
420 | } // namespace lldb_private |
421 | |
422 | #endif // LLDB_SYMBOL_COMPILERTYPE_H |