1 //===-- ClangExpressionParser.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_CLANGEXPRESSIONPARSER_H
10 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONPARSER_H
11 
12 #include "lldb/Expression/DiagnosticManager.h"
13 #include "lldb/Expression/ExpressionParser.h"
14 #include "lldb/Utility/ArchSpec.h"
15 #include "lldb/Utility/Status.h"
16 #include "lldb/lldb-public.h"
17 
18 #include <string>
19 #include <vector>
20 
21 namespace llvm {
22 class LLVMContext;
23 }
24 
25 namespace clang {
26 class CodeGenerator;
27 class CodeCompleteConsumer;
28 class CompilerInstance;
29 } // namespace clang
30 
31 namespace lldb_private {
32 
33 class IRExecutionUnit;
34 class TypeSystemClang;
35 
36 /// \class ClangExpressionParser ClangExpressionParser.h
37 /// "lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of
38 /// Clang that can parse expressions.
39 ///
40 /// ClangExpressionParser is responsible for preparing an instance of
41 /// ClangExpression for execution.  ClangExpressionParser uses ClangExpression
42 /// as a glorified parameter list, performing the required parsing and
43 /// conversion to formats (DWARF bytecode, or JIT compiled machine code) that
44 /// can be executed.
45 class ClangExpressionParser : public ExpressionParser {
46 public:
47   /// Constructor
48   ///
49   /// Initializes class variables.
50   ///
51   /// \param[in] exe_scope
52   ///     If non-NULL, an execution context scope that can help to
53   ///     correctly create an expression with a valid process for
54   ///     optional tuning Objective-C runtime support. Can be NULL.
55   ///
56   /// \param[in] expr
57   ///     The expression to be parsed.
58   ///
59   /// @param[in] include_directories
60   ///     List of include directories that should be used when parsing the
61   ///     expression.
62   ///
63   /// @param[in] filename
64   ///     Name of the source file that should be used when rendering
65   ///     diagnostics (i.e. errors, warnings or notes from Clang).
66   ClangExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
67                         bool generate_debug_info,
68                         std::vector<std::string> include_directories = {},
69                         std::string filename = "<clang expression>");
70 
71   /// Destructor
72   ~ClangExpressionParser() override;
73 
74   bool Complete(CompletionRequest &request, unsigned line, unsigned pos,
75                 unsigned typed_pos) override;
76 
77   /// Parse a single expression and convert it to IR using Clang.  Don't wrap
78   /// the expression in anything at all.
79   ///
80   /// \param[in] diagnostic_manager
81   ///     The diagnostic manager to report errors to.
82   ///
83   /// \return
84   ///     The number of errors encountered during parsing.  0 means
85   ///     success.
86   unsigned Parse(DiagnosticManager &diagnostic_manager);
87 
88   bool RewriteExpression(DiagnosticManager &diagnostic_manager) override;
89 
90   /// Ready an already-parsed expression for execution, possibly evaluating it
91   /// statically.
92   ///
93   /// \param[out] func_addr
94   ///     The address to which the function has been written.
95   ///
96   /// \param[out] func_end
97   ///     The end of the function's allocated memory region.  (func_addr
98   ///     and func_end do not delimit an allocated region; the allocated
99   ///     region may begin before func_addr.)
100   ///
101   /// \param[in] execution_unit_sp
102   ///     After parsing, ownership of the execution unit for
103   ///     for the expression is handed to this shared pointer.
104   ///
105   /// \param[in] exe_ctx
106   ///     The execution context to write the function into.
107   ///
108   /// \param[in] execution_policy
109   ///     Determines whether the expression must be JIT-compiled, must be
110   ///     evaluated statically, or whether this decision may be made
111   ///     opportunistically.
112   ///
113   /// \return
114   ///     An error code indicating the success or failure of the operation.
115   ///     Test with Success().
116   Status
117   PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end,
118                       lldb::IRExecutionUnitSP &execution_unit_sp,
119                       ExecutionContext &exe_ctx, bool &can_interpret,
120                       lldb_private::ExecutionPolicy execution_policy) override;
121 
122   /// Run all static initializers for an execution unit.
123   ///
124   /// \param[in] execution_unit_sp
125   ///     The execution unit.
126   ///
127   /// \param[in] exe_ctx
128   ///     The execution context to use when running them.  Thread can't be null.
129   ///
130   /// \return
131   ///     The error code indicating the
132   Status RunStaticInitializers(lldb::IRExecutionUnitSP &execution_unit_sp,
133                                ExecutionContext &exe_ctx);
134 
135   /// Returns a string representing current ABI.
136   ///
137   /// \param[in] target_arch
138   ///     The target architecture.
139   ///
140   /// \return
141   ///     A string representing target ABI for the current architecture.
142   std::string GetClangTargetABI(const ArchSpec &target_arch);
143 
144 private:
145   /// Parses the expression.
146   ///
147   /// \param[in] diagnostic_manager
148   ///     The diagnostic manager that should receive the diagnostics
149   ///     from the parsing process.
150   ///
151   /// \param[in] completion
152   ///     The completion consumer that should be used during parsing
153   ///     (or a nullptr if no consumer should be attached).
154   ///
155   /// \param[in] completion_line
156   ///     The line in which the completion marker should be placed.
157   ///     The first line is represented by the value 0.
158   ///
159   /// \param[in] completion_column
160   ///     The column in which the completion marker should be placed.
161   ///     The first column is represented by the value 0.
162   ///
163   /// \return
164   ///    The number of parsing errors.
165   unsigned ParseInternal(DiagnosticManager &diagnostic_manager,
166                          clang::CodeCompleteConsumer *completion = nullptr,
167                          unsigned completion_line = 0,
168                          unsigned completion_column = 0);
169 
170   std::unique_ptr<llvm::LLVMContext>
171       m_llvm_context; ///< The LLVM context to generate IR into
172   std::unique_ptr<clang::CompilerInstance>
173       m_compiler; ///< The Clang compiler used to parse expressions into IR
174   std::unique_ptr<clang::CodeGenerator>
175       m_code_generator; ///< The Clang object that generates IR
176 
177   class LLDBPreprocessorCallbacks;
178   LLDBPreprocessorCallbacks *m_pp_callbacks; ///< Called when the preprocessor
179                                              ///encounters module imports
180   std::shared_ptr<TypeSystemClang> m_ast_context;
181 
182   std::vector<std::string> m_include_directories;
183   /// File name used for the user expression.
184   std::string m_filename;
185 };
186 }
187 
188 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONPARSER_H
189