LLDB mainline
ClangExpressionDeclMap.h
Go to the documentation of this file.
1//===-- ClangExpressionDeclMap.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_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONDECLMAP_H
10#define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONDECLMAP_H
11
12#include <csignal>
13#include <cstdint>
14
15#include <memory>
16#include <vector>
17
18#include "ClangASTSource.h"
20
21#include "lldb/Core/Value.h"
26#include "lldb/lldb-public.h"
27#include "clang/AST/Decl.h"
28#include "llvm/ADT/DenseMap.h"
29
30namespace lldb_private {
31
32class ClangPersistentVariables;
33
34/// \class ClangExpressionDeclMap ClangExpressionDeclMap.h
35/// "lldb/Expression/ClangExpressionDeclMap.h" Manages named entities that are
36/// defined in LLDB's debug information.
37///
38/// The Clang parser uses the ClangASTSource as an interface to request named
39/// entities from outside an expression. The ClangASTSource reports back,
40/// listing all possible objects corresponding to a particular name. But it
41/// in turn relies on ClangExpressionDeclMap, which performs several important
42/// functions.
43///
44/// First, it records what variables and functions were looked up and what
45/// Decls were returned for them.
46///
47/// Second, it constructs a struct on behalf of IRForTarget, recording which
48/// variables should be placed where and relaying this information back so
49/// that IRForTarget can generate context-independent code.
50///
51/// Third, it "materializes" this struct on behalf of the expression command,
52/// finding the current values of each variable and placing them into the
53/// struct so that it can be passed to the JITted version of the IR.
54///
55/// Fourth and finally, it "dematerializes" the struct after the JITted code
56/// has executed, placing the new values back where it found the old ones.
58public:
59 /// Constructor
60 ///
61 /// Initializes class variables.
62 ///
63 /// \param[in] keep_result_in_memory
64 /// If true, inhibits the normal deallocation of the memory for
65 /// the result persistent variable, and instead marks the variable
66 /// as persisting.
67 ///
68 /// \param[in] result_delegate
69 /// If non-NULL, use this delegate to report result values. This
70 /// allows the client ClangUserExpression to report a result.
71 ///
72 /// \param[in] target
73 /// The target to use when parsing.
74 ///
75 /// \param[in] importer
76 /// The ClangASTImporter to use when parsing.
77 ///
78 /// \param[in] ctx_obj
79 /// If not empty, then expression is evaluated in context of this object.
80 /// See the comment to `UserExpression::Evaluate` for details.
82 bool keep_result_in_memory,
84 const lldb::TargetSP &target,
85 const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj);
86
87 /// Destructor
88 ~ClangExpressionDeclMap() override;
89
90 /// Enable the state needed for parsing and IR transformation.
91 ///
92 /// \param[in] exe_ctx
93 /// The execution context to use when finding types for variables.
94 /// Also used to find a "scratch" AST context to store result types.
95 ///
96 /// \param[in] materializer
97 /// If non-NULL, the materializer to populate with information about
98 /// the variables to use
99 ///
100 /// \return
101 /// True if parsing is possible; false if it is unsafe to continue.
102 bool WillParse(ExecutionContext &exe_ctx, Materializer *materializer);
103
104 void InstallCodeGenerator(clang::ASTConsumer *code_gen);
105
107
108 /// Disable the state needed for parsing and IR transformation.
109 void DidParse();
110
111 /// [Used by IRForTarget] Add a variable to the list of persistent
112 /// variables for the process.
113 ///
114 /// \param[in] decl
115 /// The Clang declaration for the persistent variable, used for
116 /// lookup during parsing.
117 ///
118 /// \param[in] name
119 /// The name of the persistent variable, usually $something.
120 ///
121 /// \param[in] type
122 /// The type of the variable, in the Clang parser's context.
123 ///
124 /// \return
125 /// True on success; false otherwise.
126 bool AddPersistentVariable(const clang::NamedDecl *decl,
127 ConstString name, TypeFromParser type,
128 bool is_result, bool is_lvalue);
129
130 /// [Used by IRForTarget] Add a variable to the struct that needs to
131 /// be materialized each time the expression runs.
132 ///
133 /// \param[in] decl
134 /// The Clang declaration for the variable.
135 ///
136 /// \param[in] name
137 /// The name of the variable.
138 ///
139 /// \param[in] value
140 /// The LLVM IR value for this variable.
141 ///
142 /// \param[in] size
143 /// The size of the variable in bytes.
144 ///
145 /// \param[in] alignment
146 /// The required alignment of the variable in bytes.
147 ///
148 /// \return
149 /// True on success; false otherwise.
150 bool AddValueToStruct(const clang::NamedDecl *decl, ConstString name,
151 llvm::Value *value, size_t size,
152 lldb::offset_t alignment);
153
154 /// [Used by IRForTarget] Finalize the struct, laying out the position of
155 /// each object in it.
156 ///
157 /// \return
158 /// True on success; false otherwise.
159 bool DoStructLayout();
160
161 /// [Used by IRForTarget] Get general information about the laid-out struct
162 /// after DoStructLayout() has been called.
163 ///
164 /// \param[out] num_elements
165 /// The number of elements in the struct.
166 ///
167 /// \param[out] size
168 /// The size of the struct, in bytes.
169 ///
170 /// \param[out] alignment
171 /// The alignment of the struct, in bytes.
172 ///
173 /// \return
174 /// True if the information could be retrieved; false otherwise.
175 bool GetStructInfo(uint32_t &num_elements, size_t &size,
176 lldb::offset_t &alignment);
177
178 /// [Used by IRForTarget] Get specific information about one field of the
179 /// laid-out struct after DoStructLayout() has been called.
180 ///
181 /// \param[out] decl
182 /// The parsed Decl for the field, as generated by ClangASTSource
183 /// on ClangExpressionDeclMap's behalf. In the case of the result
184 /// value, this will have the name $__lldb_result even if the
185 /// result value ends up having the name $1. This is an
186 /// implementation detail of IRForTarget.
187 ///
188 /// \param[out] value
189 /// The IR value for the field (usually a GlobalVariable). In
190 /// the case of the result value, this will have the correct
191 /// name ($1, for instance). This is an implementation detail
192 /// of IRForTarget.
193 ///
194 /// \param[out] offset
195 /// The offset of the field from the beginning of the struct.
196 /// As long as the struct is aligned according to its required
197 /// alignment, this offset will align the field correctly.
198 ///
199 /// \param[out] name
200 /// The name of the field as used in materialization.
201 ///
202 /// \param[in] index
203 /// The index of the field about which information is requested.
204 ///
205 /// \return
206 /// True if the information could be retrieved; false otherwise.
207 bool GetStructElement(const clang::NamedDecl *&decl, llvm::Value *&value,
208 lldb::offset_t &offset, ConstString &name,
209 uint32_t index);
210
211 /// [Used by IRForTarget] Get information about a function given its Decl.
212 ///
213 /// \param[in] decl
214 /// The parsed Decl for the Function, as generated by ClangASTSource
215 /// on ClangExpressionDeclMap's behalf.
216 ///
217 /// \param[out] ptr
218 /// The absolute address of the function in the target.
219 ///
220 /// \return
221 /// True if the information could be retrieved; false otherwise.
222 bool GetFunctionInfo(const clang::NamedDecl *decl, uint64_t &ptr);
223
224 /// [Used by IRForTarget] Get the address of a symbol given nothing but its
225 /// name.
226 ///
227 /// \param[in] target
228 /// The target to find the symbol in. If not provided,
229 /// then the current parsing context's Target.
230 ///
231 /// \param[in] process
232 /// The process to use. For Objective-C symbols, the process's
233 /// Objective-C language runtime may be queried if the process
234 /// is non-NULL.
235 ///
236 /// \param[in] name
237 /// The name of the symbol.
238 ///
239 /// \param[in] module
240 /// The module to limit the search to. This can be NULL
241 ///
242 /// \return
243 /// Valid load address for the symbol
245 ConstString name, lldb::SymbolType symbol_type,
246 Module *module = nullptr);
247
249 lldb::SymbolType symbol_type);
250
251 struct TargetInfo {
254
255 TargetInfo() = default;
256
257 bool IsValid() {
259 }
260 };
261 TargetInfo GetTargetInfo();
262
263 /// [Used by ClangASTSource] Find all entities matching a given name, using
264 /// a NameSearchContext to make Decls for them.
265 ///
266 /// \param[in] context
267 /// The NameSearchContext that can construct Decls for this name.
268 void FindExternalVisibleDecls(NameSearchContext &context) override;
269
270 /// Find all entities matching a given name in a given module/namespace,
271 /// using a NameSearchContext to make Decls for them.
272 ///
273 /// \param[in] context
274 /// The NameSearchContext that can construct Decls for this name.
275 ///
276 /// \param[in] module
277 /// If non-NULL, the module to query.
278 ///
279 /// \param[in] namespace_decl
280 /// If valid and module is non-NULL, the parent namespace.
282 lldb::ModuleSP module,
283 const CompilerDeclContext &namespace_decl);
284
285protected:
286 /// Retrieves the declaration with the given name from the storage of
287 /// persistent declarations.
288 ///
289 /// \return
290 /// A persistent decl with the given name or a nullptr.
291 virtual clang::NamedDecl *GetPersistentDecl(ConstString name);
292
293private:
295 m_found_entities; ///< All entities that were looked up for the parser.
297 m_struct_members; ///< All entities that need to be placed in the struct.
298 bool m_keep_result_in_memory; ///< True if result persistent variables
299 ///generated by this expression should stay in
300 ///memory.
302 *m_result_delegate; ///< If non-NULL, used to report expression results to
303 ///ClangUserExpression.
304 ValueObject *m_ctx_obj; ///< If not empty, then expression is
305 ///evaluated in context of this object.
306 ///For details see the comment to
307 ///`UserExpression::Evaluate`.
308
309 /// The following values should not live beyond parsing
311 public:
312 ParserVars() = default;
313
316 return m_exe_ctx.GetTargetPtr();
317 else if (m_sym_ctx.target_sp)
318 return m_sym_ctx.target_sp.get();
319 return nullptr;
320 }
321
322 ExecutionContext m_exe_ctx; ///< The execution context to use when parsing.
323 SymbolContext m_sym_ctx; ///< The symbol context to use in finding variables
324 ///and types.
326 nullptr; ///< The persistent variables for the process.
327 bool m_enable_lookups = false; ///< Set to true during parsing if we have
328 ///found the first "$__lldb" name.
329 TargetInfo m_target_info; ///< Basic information about the target.
330 Materializer *m_materializer = nullptr; ///< If non-NULL, the materializer
331 ///to use when reporting used
332 ///variables.
333 clang::ASTConsumer *m_code_gen = nullptr; ///< If non-NULL, a code generator
334 ///that receives new top-level
335 ///functions.
337
338 private:
339 ParserVars(const ParserVars &) = delete;
340 const ParserVars &operator=(const ParserVars &) = delete;
341 };
342
343 std::unique_ptr<ParserVars> m_parser_vars;
344
345 /// Activate parser-specific variables
347 if (!m_parser_vars.get())
348 m_parser_vars = std::make_unique<ParserVars>();
349 }
350
351 /// Deallocate parser-specific variables
353
354 /// The following values contain layout information for the materialized
355 /// struct, but are not specific to a single materialization
356 struct StructVars {
357 StructVars() = default;
358
360 0; ///< The alignment of the struct in bytes.
361 size_t m_struct_size = 0; ///< The size of the struct in bytes.
363 false; ///< True if the struct has been laid out and the
364 /// layout is valid (that is, no new fields have been
365 /// added since).
367 m_result_name; ///< The name of the result variable ($1, for example)
368 };
369
370 std::unique_ptr<StructVars> m_struct_vars;
371
372 /// Activate struct variables
374 if (!m_struct_vars.get())
375 m_struct_vars.reset(new struct StructVars);
376 }
377
378 /// Deallocate struct variables
380
383 m_ast_context->getLangOpts());
384 }
385
386 /// Get this parser's ID for use in extracting parser- and JIT-specific data
387 /// from persistent variables.
388 uint64_t GetParserID() { return (uint64_t) this; }
389
390 /// Should be called on all copied functions.
391 void MaybeRegisterFunctionBody(clang::FunctionDecl *copied_function_decl);
392
393 /// Searches the persistent decls of the target for entities with the
394 /// given name.
395 ///
396 /// \param[in] context
397 /// The NameSearchContext that can construct Decls for this name.
398 ///
399 /// \param[in] name
400 /// The name of the entities that need to be found.
401 void SearchPersistenDecls(NameSearchContext &context, const ConstString name);
402
403 /// Handles looking up $__lldb_class which requires special treatment.
404 ///
405 /// \param[in] context
406 /// The NameSearchContext that can construct Decls for this name.
407 void LookUpLldbClass(NameSearchContext &context);
408
409 /// Handles looking up $__lldb_objc_class which requires special treatment.
410 ///
411 /// \param[in] context
412 /// The NameSearchContext that can construct Decls for this name.
414
415 /// Handles looking up the synthetic namespace that contains our local
416 /// variables for the current frame.
417 ///
418 /// \param[in] sym_ctx
419 /// The current SymbolContext of this frame.
420 ///
421 /// \param[in] name_context
422 /// The NameSearchContext that can construct Decls for this name.
424 NameSearchContext &name_context);
425
426 /// Lookup entities in the ClangModulesDeclVendor.
427 /// \param[in] context
428 /// The NameSearchContext that can construct Decls for this name.
429 ///
430 /// \param[in] name
431 /// The name of the entities that need to be found.
433
434 /// Looks up a local variable.
435 ///
436 /// \param[in] context
437 /// The NameSearchContext that can construct Decls for this name.
438 ///
439 /// \param[in] name
440 /// The name of the entities that need to be found.
441 ///
442 /// \param[in] sym_ctx
443 /// The current SymbolContext of this frame.
444 ///
445 /// \param[in] namespace_decl
446 /// The parent namespace if there is one.
447 ///
448 /// \return
449 /// True iff a local variable was found.
451 SymbolContext &sym_ctx,
452 const CompilerDeclContext &namespace_decl);
453
454 /// Searches for functions in the given SymbolContextList.
455 ///
456 /// \param[in] sc_list
457 /// The SymbolContextList to search.
458 ///
459 /// \param[in] frame_decl_context
460 /// The current DeclContext of the current frame.
461 ///
462 /// \return
463 /// A SymbolContextList with any found functions in the front and
464 /// any unknown SymbolContexts which are not functions in the back.
465 /// The SymbolContexts for the functions are ordered by how close they are
466 /// to the DeclContext for the given frame DeclContext.
468 const SymbolContextList &sc_list,
469 const CompilerDeclContext &frame_decl_context);
470
471 /// Looks up a function.
472 ///
473 /// \param[in] context
474 /// The NameSearchContext that can construct Decls for this name.
475 ///
476 /// \param[in] module_sp
477 /// If non-NULL, the module to query.
478 ///
479 /// \param[in] name
480 /// The name of the function that should be find.
481 ///
482 /// \param[in] namespace_decl
483 /// If valid and module is non-NULL, the parent namespace.
484 void LookupFunction(NameSearchContext &context, lldb::ModuleSP module_sp,
485 ConstString name,
486 const CompilerDeclContext &namespace_decl);
487
488 /// Given a target, find a variable that matches the given name and type.
489 ///
490 /// \param[in] target
491 /// The target to use as a basis for finding the variable.
492 ///
493 /// \param[in] module
494 /// If non-NULL, the module to search.
495 ///
496 /// \param[in] name
497 /// The name as a plain C string.
498 ///
499 /// \param[in] namespace_decl
500 /// If non-NULL and module is non-NULL, the parent namespace.
501 ///
502 /// \return
503 /// The LLDB Variable found, or NULL if none was found.
506 const CompilerDeclContext &namespace_decl);
507
508 /// Get the value of a variable in a given execution context and return the
509 /// associated Types if needed.
510 ///
511 /// \param[in] var
512 /// The variable to evaluate.
513 ///
514 /// \param[out] var_location
515 /// The variable location value to fill in
516 ///
517 /// \param[out] found_type
518 /// The type of the found value, as it was found in the user process.
519 /// This is only useful when the variable is being inspected on behalf
520 /// of the parser, hence the default.
521 ///
522 /// \param[out] parser_type
523 /// The type of the found value, as it was copied into the parser's
524 /// AST context. This is only useful when the variable is being
525 /// inspected on behalf of the parser, hence the default.
526 ///
527 /// \return
528 /// Return true if the value was successfully filled in.
530 lldb_private::Value &var_location,
531 TypeFromUser *found_type = nullptr,
532 TypeFromParser *parser_type = nullptr);
533
534 /// Use the NameSearchContext to generate a Decl for the given LLDB
535 /// ValueObject, and put it in the list of found entities.
536 ///
537 /// Helper function used by the other AddOneVariable APIs.
538 ///
539 /// \param[in,out] context
540 /// The NameSearchContext to use when constructing the Decl.
541 ///
542 /// \param[in] pt
543 /// The CompilerType of the variable we're adding a Decl for.
544 ///
545 /// \param[in] var
546 /// The LLDB ValueObject that needs a Decl.
549 lldb::ValueObjectSP valobj);
550
551 /// Use the NameSearchContext to generate a Decl for the given LLDB
552 /// Variable, and put it in the Tuple list.
553 ///
554 /// \param[in] context
555 /// The NameSearchContext to use when constructing the Decl.
556 ///
557 /// \param[in] var
558 /// The LLDB Variable that needs a Decl.
559 ///
560 /// \param[in] valobj
561 /// The LLDB ValueObject for that variable.
563 lldb::ValueObjectSP valobj);
564
565 /// Use the NameSearchContext to generate a Decl for the given ValueObject
566 /// and put it in the list of found entities.
567 ///
568 /// \param[in,out] context
569 /// The NameSearchContext to use when constructing the Decl.
570 ///
571 /// \param[in] valobj
572 /// The ValueObject that needs a Decl.
573 ///
574 /// \param[in] valobj_provider Callback that fetches a ValueObjectSP
575 /// from the specified frame
577 ValueObjectProviderTy valobj_provider);
578
579 /// Use the NameSearchContext to generate a Decl for the given persistent
580 /// variable, and put it in the list of found entities.
581 ///
582 /// \param[in] context
583 /// The NameSearchContext to use when constructing the Decl.
584 ///
585 /// \param[in] pvar_sp
586 /// The persistent variable that needs a Decl.
587 void AddOneVariable(NameSearchContext &context,
589
590 /// Use the NameSearchContext to generate a Decl for the given LLDB symbol
591 /// (treated as a variable), and put it in the list of found entities.
592 void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol);
593
594 /// Use the NameSearchContext to generate a Decl for the given function.
595 /// (Functions are not placed in the Tuple list.) Can handle both fully
596 /// typed functions and generic functions.
597 ///
598 /// \param[in] context
599 /// The NameSearchContext to use when constructing the Decl.
600 ///
601 /// \param[in] fun
602 /// The Function that needs to be created. If non-NULL, this is
603 /// a fully-typed function.
604 ///
605 /// \param[in] sym
606 /// The Symbol that corresponds to a function that needs to be
607 /// created with generic type (unitptr_t foo(...)).
608 void AddOneFunction(NameSearchContext &context, Function *fun, Symbol *sym);
609
610 /// Use the NameSearchContext to generate a Decl for the given register.
611 ///
612 /// \param[in] context
613 /// The NameSearchContext to use when constructing the Decl.
614 ///
615 /// \param[in] reg_info
616 /// The information corresponding to that register.
617 void AddOneRegister(NameSearchContext &context, const RegisterInfo *reg_info);
618
619 /// Use the NameSearchContext to generate a Decl for the given type. (Types
620 /// are not placed in the Tuple list.)
621 ///
622 /// \param[in] context
623 /// The NameSearchContext to use when constructing the Decl.
624 ///
625 /// \param[in] type
626 /// The type that needs to be created.
627 void AddOneType(NameSearchContext &context, const TypeFromUser &type);
628
629 /// Adds the class in which the expression is evaluated to the lookup and
630 /// prepares the class to be used as a context for expression evaluation (for
631 /// example, it creates a fake member function that will contain the
632 /// expression LLDB is trying to evaluate).
633 ///
634 /// \param[in] context
635 /// The NameSearchContext to which the class should be added as a lookup
636 /// result.
637 ///
638 /// \param[in] type
639 /// The type of the class that serves as the evaluation context.
641 const TypeFromUser &type);
642
643 /// Move a type out of the current ASTContext into another, but make sure to
644 /// export all components of the type also.
645 ///
646 /// \param[in] target
647 /// The TypeSystemClang to move to.
648 /// \param[in] source
649 /// The TypeSystemClang to move from. This is assumed to be going away.
650 /// \param[in] parser_type
651 /// The type as it appears in the source context.
652 ///
653 /// \return
654 /// Returns the moved type, or an empty type if there was a problem.
656 TypeFromParser parser_type);
657
659};
660
661} // namespace lldb_private
662
663#endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONDECLMAP_H
Provider for named objects defined in the debug info for Clang.
clang::ASTContext * m_ast_context
The AST context requests are coming in for.
The following values should not live beyond parsing.
ClangPersistentVariables * m_persistent_vars
The persistent variables for the process.
bool m_enable_lookups
Set to true during parsing if we have found the first "$__lldb" name.
clang::ASTConsumer * m_code_gen
If non-NULL, a code generator that receives new top-level functions.
const ParserVars & operator=(const ParserVars &)=delete
TargetInfo m_target_info
Basic information about the target.
ExecutionContext m_exe_ctx
The execution context to use when parsing.
Materializer * m_materializer
If non-NULL, the materializer to use when reporting used variables.
SymbolContext m_sym_ctx
The symbol context to use in finding variables and types.
"lldb/Expression/ClangExpressionDeclMap.h" Manages named entities that are defined in LLDB's debug in...
bool GetVariableValue(lldb::VariableSP &var, lldb_private::Value &var_location, TypeFromUser *found_type=nullptr, TypeFromParser *parser_type=nullptr)
Get the value of a variable in a given execution context and return the associated Types if needed.
ClangExpressionVariable::ParserVars * AddExpressionVariable(NameSearchContext &context, TypeFromParser const &pt, lldb::ValueObjectSP valobj)
Use the NameSearchContext to generate a Decl for the given LLDB ValueObject, and put it in the list o...
std::unique_ptr< StructVars > m_struct_vars
void EnableParserVars()
Activate parser-specific variables.
uint64_t GetParserID()
Get this parser's ID for use in extracting parser- and JIT-specific data from persistent variables.
bool AddPersistentVariable(const clang::NamedDecl *decl, ConstString name, TypeFromParser type, bool is_result, bool is_lvalue)
[Used by IRForTarget] Add a variable to the list of persistent variables for the process.
bool LookupLocalVariable(NameSearchContext &context, ConstString name, SymbolContext &sym_ctx, const CompilerDeclContext &namespace_decl)
Looks up a local variable.
void DisableStructVars()
Deallocate struct variables.
void AddOneVariable(NameSearchContext &context, lldb::VariableSP var, lldb::ValueObjectSP valobj)
Use the NameSearchContext to generate a Decl for the given LLDB Variable, and put it in the Tuple lis...
void FindExternalVisibleDecls(NameSearchContext &context) override
[Used by ClangASTSource] Find all entities matching a given name, using a NameSearchContext to make D...
void AddOneFunction(NameSearchContext &context, Function *fun, Symbol *sym)
Use the NameSearchContext to generate a Decl for the given function.
bool GetStructElement(const clang::NamedDecl *&decl, llvm::Value *&value, lldb::offset_t &offset, ConstString &name, uint32_t index)
[Used by IRForTarget] Get specific information about one field of the laid-out struct after DoStructL...
bool DoStructLayout()
[Used by IRForTarget] Finalize the struct, laying out the position of each object in it.
void MaybeRegisterFunctionBody(clang::FunctionDecl *copied_function_decl)
Should be called on all copied functions.
void EnableStructVars()
Activate struct variables.
void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol)
Use the NameSearchContext to generate a Decl for the given LLDB symbol (treated as a variable),...
void DidParse()
Disable the state needed for parsing and IR transformation.
void AddOneRegister(NameSearchContext &context, const RegisterInfo *reg_info)
Use the NameSearchContext to generate a Decl for the given register.
bool WillParse(ExecutionContext &exe_ctx, Materializer *materializer)
Enable the state needed for parsing and IR transformation.
void LookUpLldbObjCClass(NameSearchContext &context)
Handles looking up $__lldb_objc_class which requires special treatment.
void DisableParserVars()
Deallocate parser-specific variables.
void LookupLocalVarNamespace(SymbolContext &sym_ctx, NameSearchContext &name_context)
Handles looking up the synthetic namespace that contains our local variables for the current frame.
bool AddValueToStruct(const clang::NamedDecl *decl, ConstString name, llvm::Value *value, size_t size, lldb::offset_t alignment)
[Used by IRForTarget] Add a variable to the struct that needs to be materialized each time the expres...
lldb::addr_t GetSymbolAddress(Target &target, Process *process, ConstString name, lldb::SymbolType symbol_type, Module *module=nullptr)
[Used by IRForTarget] Get the address of a symbol given nothing but its name.
void InstallDiagnosticManager(DiagnosticManager &diag_manager)
void LookUpLldbClass(NameSearchContext &context)
Handles looking up $__lldb_class which requires special treatment.
bool m_keep_result_in_memory
True if result persistent variables generated by this expression should stay in memory.
bool GetFunctionInfo(const clang::NamedDecl *decl, uint64_t &ptr)
[Used by IRForTarget] Get information about a function given its Decl.
lldb::TypeSystemClangSP GetScratchContext(Target &target)
void AddContextClassType(NameSearchContext &context, const TypeFromUser &type)
Adds the class in which the expression is evaluated to the lookup and prepares the class to be used a...
bool GetStructInfo(uint32_t &num_elements, size_t &size, lldb::offset_t &alignment)
[Used by IRForTarget] Get general information about the laid-out struct after DoStructLayout() has be...
SymbolContextList SearchFunctionsInSymbolContexts(const SymbolContextList &sc_list, const CompilerDeclContext &frame_decl_context)
Searches for functions in the given SymbolContextList.
ExpressionVariableList m_struct_members
All entities that need to be placed in the struct.
ExpressionVariableList m_found_entities
All entities that were looked up for the parser.
void SearchPersistenDecls(NameSearchContext &context, const ConstString name)
Searches the persistent decls of the target for entities with the given name.
TypeFromUser DeportType(TypeSystemClang &target, TypeSystemClang &source, TypeFromParser parser_type)
Move a type out of the current ASTContext into another, but make sure to export all components of the...
Materializer::PersistentVariableDelegate * m_result_delegate
If non-NULL, used to report expression results to ClangUserExpression.
void LookupFunction(NameSearchContext &context, lldb::ModuleSP module_sp, ConstString name, const CompilerDeclContext &namespace_decl)
Looks up a function.
void LookupInModulesDeclVendor(NameSearchContext &context, ConstString name)
Lookup entities in the ClangModulesDeclVendor.
void AddOneType(NameSearchContext &context, const TypeFromUser &type)
Use the NameSearchContext to generate a Decl for the given type.
ValueObject * m_ctx_obj
If not empty, then expression is evaluated in context of this object.
lldb::VariableSP FindGlobalVariable(Target &target, lldb::ModuleSP &module, ConstString name, const CompilerDeclContext &namespace_decl)
Given a target, find a variable that matches the given name and type.
std::unique_ptr< ParserVars > m_parser_vars
void InstallCodeGenerator(clang::ASTConsumer *code_gen)
virtual clang::NamedDecl * GetPersistentDecl(ConstString name)
Retrieves the declaration with the given name from the storage of persistent declarations.
The following values should not live beyond parsing.
"lldb/Expression/ClangPersistentVariables.h" Manages persistent values that need to be preserved betw...
Represents a generic declaration context in a program.
A uniqued constant string class.
Definition: ConstString.h:40
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Target * GetTargetPtr() const
Returns a pointer to the target object.
"lldb/Expression/ExpressionVariable.h" A list of variable references.
A class that describes a function.
Definition: Function.h:399
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
static lldb::TypeSystemClangSP GetForTarget(Target &target, std::optional< IsolatedASTKind > ast_kind=DefaultAST, bool create_on_demand=true)
Returns the scratch TypeSystemClang for the given target.
Defines a list of symbol context objects.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
lldb::TargetSP target_sp
The Target for a given query.
A TypeSystem implementation based on Clang.
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
TaggedASTType< 0 > TypeFromParser
Definition: TaggedASTType.h:40
std::function< lldb::ValueObjectSP(ConstString, StackFrame *)> ValueObjectProviderTy
Functor that returns a ValueObjectSP for a variable given its name and the StackFrame of interest.
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:472
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:343
uint64_t offset_t
Definition: lldb-types.h:83
SymbolType
Symbol types.
ByteOrder
Byte ordering definitions.
@ eByteOrderInvalid
std::shared_ptr< lldb_private::Variable > VariableSP
Definition: lldb-forward.h:474
std::shared_ptr< lldb_private::TypeSystemClang > TypeSystemClangSP
Definition: lldb-forward.h:458
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365
The following values contain layout information for the materialized struct, but are not specific to ...
lldb::offset_t m_struct_alignment
The alignment of the struct in bytes.
ConstString m_result_name
The name of the result variable ($1, for example)
bool m_struct_laid_out
True if the struct has been laid out and the layout is valid (that is, no new fields have been added ...
size_t m_struct_size
The size of the struct in bytes.
"lldb/Expression/ClangASTSource.h" Container for all objects relevant to a single name lookup
Every register is described in detail including its name, alternate name (optional),...