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 DoPrepareForExecution( 117 lldb::addr_t &func_addr, lldb::addr_t &func_end, 118 lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx, 119 bool &can_interpret, 120 lldb_private::ExecutionPolicy execution_policy) override; 121 122 /// Returns a string representing current ABI. 123 /// 124 /// \param[in] target_arch 125 /// The target architecture. 126 /// 127 /// \return 128 /// A string representing target ABI for the current architecture. 129 std::string GetClangTargetABI(const ArchSpec &target_arch); 130 131 private: 132 /// Parses the expression. 133 /// 134 /// \param[in] diagnostic_manager 135 /// The diagnostic manager that should receive the diagnostics 136 /// from the parsing process. 137 /// 138 /// \param[in] completion 139 /// The completion consumer that should be used during parsing 140 /// (or a nullptr if no consumer should be attached). 141 /// 142 /// \param[in] completion_line 143 /// The line in which the completion marker should be placed. 144 /// The first line is represented by the value 0. 145 /// 146 /// \param[in] completion_column 147 /// The column in which the completion marker should be placed. 148 /// The first column is represented by the value 0. 149 /// 150 /// \return 151 /// The number of parsing errors. 152 unsigned ParseInternal(DiagnosticManager &diagnostic_manager, 153 clang::CodeCompleteConsumer *completion = nullptr, 154 unsigned completion_line = 0, 155 unsigned completion_column = 0); 156 157 std::unique_ptr<llvm::LLVMContext> 158 m_llvm_context; ///< The LLVM context to generate IR into 159 std::unique_ptr<clang::CompilerInstance> 160 m_compiler; ///< The Clang compiler used to parse expressions into IR 161 std::unique_ptr<clang::CodeGenerator> 162 m_code_generator; ///< The Clang object that generates IR 163 164 class LLDBPreprocessorCallbacks; 165 LLDBPreprocessorCallbacks *m_pp_callbacks; ///< Called when the preprocessor 166 ///encounters module imports 167 std::shared_ptr<TypeSystemClang> m_ast_context; 168 169 std::vector<std::string> m_include_directories; 170 /// File name used for the user expression. 171 std::string m_filename; 172 }; 173 } 174 175 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONPARSER_H 176