LLDB  mainline
ASTStructExtractor.h
Go to the documentation of this file.
1 //===-- ASTStructExtractor.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_ASTSTRUCTEXTRACTOR_H
10 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTSTRUCTEXTRACTOR_H
11 
13 #include "ClangFunctionCaller.h"
14 
15 #include "clang/Sema/SemaConsumer.h"
16 
17 namespace lldb_private {
18 
19 /// \class ASTStructExtractor ASTStructExtractor.h
20 /// "lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument
21 /// structure for a wrapped function.
22 ///
23 /// This pass integrates with ClangFunctionCaller, which calls functions with
24 /// custom sets of arguments. To avoid having to implement the full calling
25 /// convention for the target's architecture, ClangFunctionCaller writes a
26 /// simple wrapper function that takes a pointer to an argument structure that
27 /// contains room for the address of the function to be called, the values of
28 /// all its arguments, and room for the function's return value.
29 ///
30 /// The definition of this struct is itself in the body of the wrapper
31 /// function, so Clang does the structure layout itself. ASTStructExtractor
32 /// reads through the AST for the wrapper function and finds the struct.
33 class ASTStructExtractor : public clang::SemaConsumer {
34 public:
35  /// Constructor
36  ///
37  /// \param[in] passthrough
38  /// Since the ASTs must typically go through to the Clang code generator
39  /// in order to produce LLVM IR, this SemaConsumer must allow them to
40  /// pass to the next step in the chain after processing. Passthrough is
41  /// the next ASTConsumer, or NULL if none is required.
42  ///
43  /// \param[in] struct_name
44  /// The name of the structure to extract from the wrapper function.
45  ///
46  /// \param[in] function
47  /// The caller object whose members should be populated with information
48  /// about the argument struct. ClangFunctionCaller friends
49  /// ASTStructExtractor
50  /// for this purpose.
51  ASTStructExtractor(clang::ASTConsumer *passthrough, const char *struct_name,
52  ClangFunctionCaller &function);
53 
54  /// Destructor
55  ~ASTStructExtractor() override;
56 
57  /// Link this consumer with a particular AST context
58  ///
59  /// \param[in] Context
60  /// This AST context will be used for types and identifiers, and also
61  /// forwarded to the passthrough consumer, if one exists.
62  void Initialize(clang::ASTContext &Context) override;
63 
64  /// Examine a list of Decls to find the function $__lldb_expr and transform
65  /// its code
66  ///
67  /// \param[in] D
68  /// The list of Decls to search. These may contain LinkageSpecDecls,
69  /// which need to be searched recursively. That job falls to
70  /// TransformTopLevelDecl.
71  bool HandleTopLevelDecl(clang::DeclGroupRef D) override;
72 
73  /// Passthrough stub
74  void HandleTranslationUnit(clang::ASTContext &Ctx) override;
75 
76  /// Passthrough stub
77  void HandleTagDeclDefinition(clang::TagDecl *D) override;
78 
79  /// Passthrough stub
80  void CompleteTentativeDefinition(clang::VarDecl *D) override;
81 
82  /// Passthrough stub
83  void HandleVTable(clang::CXXRecordDecl *RD) override;
84 
85  /// Passthrough stub
86  void PrintStats() override;
87 
88  /// Set the Sema object to use when performing transforms, and pass it on
89  ///
90  /// \param[in] S
91  /// The Sema to use. Because Sema isn't externally visible, this class
92  /// casts it to an Action for actual use.
93  void InitializeSema(clang::Sema &S) override;
94 
95  /// Reset the Sema to NULL now that transformations are done
96  void ForgetSema() override;
97 
98 private:
99  /// Hunt the given FunctionDecl for the argument struct and place
100  /// information about it into m_function
101  ///
102  /// \param[in] F
103  /// The FunctionDecl to hunt.
104  void ExtractFromFunctionDecl(clang::FunctionDecl *F);
105 
106  /// Hunt the given Decl for FunctionDecls named the same as the wrapper
107  /// function name, recursing as necessary through LinkageSpecDecls, and
108  /// calling ExtractFromFunctionDecl on anything that was found
109  ///
110  /// \param[in] D
111  /// The Decl to hunt.
112  void ExtractFromTopLevelDecl(clang::Decl *D);
113 
114  clang::ASTContext
115  *m_ast_context; ///< The AST context to use for identifiers and types.
116  clang::ASTConsumer *m_passthrough; ///< The ASTConsumer down the chain, for
117  ///passthrough. NULL if it's a
118  ///SemaConsumer.
119  clang::SemaConsumer *m_passthrough_sema; ///< The SemaConsumer down the chain,
120  ///for passthrough. NULL if it's an
121  ///ASTConsumer.
122  clang::Sema *m_sema; ///< The Sema to use.
123 
124  ClangFunctionCaller &m_function; ///< The function to populate with
125  ///information about the argument structure.
126  std::string m_struct_name; ///< The name of the structure to extract.
127 };
128 
129 } // namespace lldb_private
130 
131 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTSTRUCTEXTRACTOR_H
A class that represents a running process on the host machine.
void PrintStats() override
Passthrough stub.
void ExtractFromTopLevelDecl(clang::Decl *D)
Hunt the given Decl for FunctionDecls named the same as the wrapper function name, recursing as necessary through LinkageSpecDecls, and calling ExtractFromFunctionDecl on anything that was found.
void HandleTagDeclDefinition(clang::TagDecl *D) override
Passthrough stub.
void ExtractFromFunctionDecl(clang::FunctionDecl *F)
Hunt the given FunctionDecl for the argument struct and place information about it into m_function...
clang::ASTConsumer * m_passthrough
The ASTConsumer down the chain, for passthrough.
void Initialize(clang::ASTContext &Context) override
Link this consumer with a particular AST context.
clang::ASTContext * m_ast_context
The AST context to use for identifiers and types.
clang::Sema * m_sema
The Sema to use.
std::string m_struct_name
The name of the structure to extract.
"lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument structure for a wrapped fu...
bool HandleTopLevelDecl(clang::DeclGroupRef D) override
Examine a list of Decls to find the function $__lldb_expr and transform its code. ...
ASTStructExtractor(clang::ASTConsumer *passthrough, const char *struct_name, ClangFunctionCaller &function)
Constructor.
~ASTStructExtractor() override
Destructor.
void HandleTranslationUnit(clang::ASTContext &Ctx) override
Passthrough stub.
"lldb/Expression/ClangFunctionCaller.h" Encapsulates a function that can be called.
void ForgetSema() override
Reset the Sema to NULL now that transformations are done.
void CompleteTentativeDefinition(clang::VarDecl *D) override
Passthrough stub.
clang::SemaConsumer * m_passthrough_sema
The SemaConsumer down the chain, for passthrough.
void InitializeSema(clang::Sema &S) override
Set the Sema object to use when performing transforms, and pass it on.
void HandleVTable(clang::CXXRecordDecl *RD) override
Passthrough stub.
ClangFunctionCaller & m_function
The function to populate with information about the argument structure.