1 //===-- ClangUserExpression.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 liblldb_ClangUserExpression_h_
10 #define liblldb_ClangUserExpression_h_
11 
12 #include <vector>
13 
14 #include "ASTResultSynthesizer.h"
15 #include "ASTStructExtractor.h"
16 #include "ClangExpressionDeclMap.h"
17 #include "ClangExpressionHelper.h"
18 #include "ClangExpressionSourceCode.h"
19 #include "ClangExpressionVariable.h"
20 #include "IRForTarget.h"
21 
22 #include "lldb/Core/Address.h"
23 #include "lldb/Core/ClangForward.h"
24 #include "lldb/Expression/LLVMUserExpression.h"
25 #include "lldb/Expression/Materializer.h"
26 #include "lldb/Target/ExecutionContext.h"
27 #include "lldb/lldb-forward.h"
28 #include "lldb/lldb-private.h"
29 
30 namespace lldb_private {
31 
32 /// \class ClangUserExpression ClangUserExpression.h
33 /// "lldb/Expression/ClangUserExpression.h" Encapsulates a single expression
34 /// for use with Clang
35 ///
36 /// LLDB uses expressions for various purposes, notably to call functions
37 /// and as a backend for the expr command.  ClangUserExpression encapsulates
38 /// the objects needed to parse and interpret or JIT an expression.  It uses
39 /// the Clang parser to produce LLVM IR from the expression.
40 class ClangUserExpression : public LLVMUserExpression {
41   // LLVM RTTI support
42   static char ID;
43 
44 public:
45   bool isA(const void *ClassID) const override {
46     return ClassID == &ID || LLVMUserExpression::isA(ClassID);
47   }
48   static bool classof(const Expression *obj) { return obj->isA(&ID); }
49 
50   enum { kDefaultTimeout = 500000u };
51 
52   class ClangUserExpressionHelper : public ClangExpressionHelper {
53   public:
54     ClangUserExpressionHelper(Target &target, bool top_level)
55         : m_target(target), m_top_level(top_level) {}
56 
57     ~ClangUserExpressionHelper() override = default;
58 
59     /// Return the object that the parser should use when resolving external
60     /// values.  May be NULL if everything should be self-contained.
61     ClangExpressionDeclMap *DeclMap() override {
62       return m_expr_decl_map_up.get();
63     }
64 
65     void ResetDeclMap() { m_expr_decl_map_up.reset(); }
66 
67     void ResetDeclMap(ExecutionContext &exe_ctx,
68                       Materializer::PersistentVariableDelegate &result_delegate,
69                       bool keep_result_in_memory,
70                       ValueObject *ctx_obj);
71 
72     /// Return the object that the parser should allow to access ASTs. May be
73     /// NULL if the ASTs do not need to be transformed.
74     ///
75     /// \param[in] passthrough
76     ///     The ASTConsumer that the returned transformer should send
77     ///     the ASTs to after transformation.
78     clang::ASTConsumer *
79     ASTTransformer(clang::ASTConsumer *passthrough) override;
80 
81     void CommitPersistentDecls() override;
82 
83   private:
84     Target &m_target;
85     std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up;
86     std::unique_ptr<ASTStructExtractor> m_struct_extractor_up; ///< The class
87                                                                ///that generates
88                                                                ///the argument
89                                                                ///struct layout.
90     std::unique_ptr<ASTResultSynthesizer> m_result_synthesizer_up;
91     bool m_top_level;
92   };
93 
94   /// Constructor
95   ///
96   /// \param[in] expr
97   ///     The expression to parse.
98   ///
99   /// \param[in] prefix
100   ///     If non-NULL, a C string containing translation-unit level
101   ///     definitions to be included when the expression is parsed.
102   ///
103   /// \param[in] language
104   ///     If not eLanguageTypeUnknown, a language to use when parsing
105   ///     the expression.  Currently restricted to those languages
106   ///     supported by Clang.
107   ///
108   /// \param[in] desired_type
109   ///     If not eResultTypeAny, the type to use for the expression
110   ///     result.
111   ///
112   /// \param[in] options
113   ///     Additional options for the expression.
114   ///
115   /// \param[in] ctx_obj
116   ///     The object (if any) in which context the expression
117   ///     must be evaluated. For details see the comment to
118   ///     `UserExpression::Evaluate`.
119   ClangUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
120                       llvm::StringRef prefix, lldb::LanguageType language,
121                       ResultType desired_type,
122                       const EvaluateExpressionOptions &options,
123                       ValueObject *ctx_obj);
124 
125   ~ClangUserExpression() override;
126 
127   /// Parse the expression
128   ///
129   /// \param[in] diagnostic_manager
130   ///     A diagnostic manager to report parse errors and warnings to.
131   ///
132   /// \param[in] exe_ctx
133   ///     The execution context to use when looking up entities that
134   ///     are needed for parsing (locations of functions, types of
135   ///     variables, persistent variables, etc.)
136   ///
137   /// \param[in] execution_policy
138   ///     Determines whether interpretation is possible or mandatory.
139   ///
140   /// \param[in] keep_result_in_memory
141   ///     True if the resulting persistent variable should reside in
142   ///     target memory, if applicable.
143   ///
144   /// \return
145   ///     True on success (no errors); false otherwise.
146   bool Parse(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
147              lldb_private::ExecutionPolicy execution_policy,
148              bool keep_result_in_memory, bool generate_debug_info) override;
149 
150   bool Complete(ExecutionContext &exe_ctx, CompletionRequest &request,
151                 unsigned complete_pos) override;
152 
153   ExpressionTypeSystemHelper *GetTypeSystemHelper() override {
154     return &m_type_system_helper;
155   }
156 
157   ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); }
158 
159   void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); }
160 
161   void ResetDeclMap(ExecutionContext &exe_ctx,
162                     Materializer::PersistentVariableDelegate &result_delegate,
163                     bool keep_result_in_memory) {
164     m_type_system_helper.ResetDeclMap(exe_ctx, result_delegate,
165                                       keep_result_in_memory,
166                                       m_ctx_obj);
167   }
168 
169   lldb::ExpressionVariableSP
170   GetResultAfterDematerialization(ExecutionContextScope *exe_scope) override;
171 
172   bool DidImportCxxModules() const { return m_imported_cpp_modules; }
173 
174 private:
175   /// Populate m_in_cplusplus_method and m_in_objectivec_method based on the
176   /// environment.
177 
178   void ScanContext(ExecutionContext &exe_ctx,
179                    lldb_private::Status &err) override;
180 
181   bool AddArguments(ExecutionContext &exe_ctx, std::vector<lldb::addr_t> &args,
182                     lldb::addr_t struct_address,
183                     DiagnosticManager &diagnostic_manager) override;
184 
185   void CreateSourceCode(DiagnosticManager &diagnostic_manager,
186                         ExecutionContext &exe_ctx,
187                         std::vector<std::string> modules_to_import,
188                         bool for_completion);
189   void UpdateLanguageForExpr();
190   bool SetupPersistentState(DiagnosticManager &diagnostic_manager,
191                                    ExecutionContext &exe_ctx);
192   bool PrepareForParsing(DiagnosticManager &diagnostic_manager,
193                          ExecutionContext &exe_ctx, bool for_completion);
194 
195   ClangUserExpressionHelper m_type_system_helper;
196 
197   class ResultDelegate : public Materializer::PersistentVariableDelegate {
198   public:
199     ResultDelegate(lldb::TargetSP target) : m_target_sp(target) {}
200     ConstString GetName() override;
201     void DidDematerialize(lldb::ExpressionVariableSP &variable) override;
202 
203     void RegisterPersistentState(PersistentExpressionState *persistent_state);
204     lldb::ExpressionVariableSP &GetVariable();
205 
206   private:
207     PersistentExpressionState *m_persistent_state;
208     lldb::ExpressionVariableSP m_variable;
209     lldb::TargetSP m_target_sp;
210   };
211 
212   /// The language type of the current expression.
213   lldb::LanguageType m_expr_lang = lldb::eLanguageTypeUnknown;
214   /// The include directories that should be used when parsing the expression.
215   std::vector<std::string> m_include_directories;
216 
217   /// The absolute character position in the transformed source code where the
218   /// user code (as typed by the user) starts. If the variable is empty, then we
219   /// were not able to calculate this position.
220   llvm::Optional<size_t> m_user_expression_start_pos;
221   ResultDelegate m_result_delegate;
222   ClangPersistentVariables *m_clang_state;
223   std::unique_ptr<ClangExpressionSourceCode> m_source_code;
224   /// File name used for the expression.
225   std::string m_filename;
226 
227   /// The object (if any) in which context the expression is evaluated.
228   /// See the comment to `UserExpression::Evaluate` for details.
229   ValueObject *m_ctx_obj;
230 
231   /// True iff this expression explicitly imported C++ modules.
232   bool m_imported_cpp_modules = false;
233 
234   /// True if the expression parser should enforce the presence of a valid class
235   /// pointer in order to generate the expression as a method.
236   bool m_enforce_valid_object = true;
237   /// True if the expression is compiled as a C++ member function (true if it
238   /// was parsed when exe_ctx was in a C++ method).
239   bool m_in_cplusplus_method = false;
240   /// True if the expression is compiled as an Objective-C method (true if it
241   /// was parsed when exe_ctx was in an Objective-C method).
242   bool m_in_objectivec_method = false;
243   /// True if the expression is compiled as a static (or class) method
244   /// (currently true if it was parsed when exe_ctx was in an Objective-C class
245   /// method).
246   bool m_in_static_method = false;
247   /// True if "this" or "self" must be looked up and passed in.  False if the
248   /// expression doesn't really use them and they can be NULL.
249   bool m_needs_object_ptr = false;
250 };
251 
252 } // namespace lldb_private
253 
254 #endif // liblldb_ClangUserExpression_h_
255