ClangExpressionParser.h revision 314564
1//===-- ClangExpressionParser.h ---------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef liblldb_ClangExpressionParser_h_ 11#define liblldb_ClangExpressionParser_h_ 12 13#include "lldb/Core/ArchSpec.h" 14#include "lldb/Core/ClangForward.h" 15#include "lldb/Core/Error.h" 16#include "lldb/Expression/DiagnosticManager.h" 17#include "lldb/Expression/ExpressionParser.h" 18#include "lldb/lldb-public.h" 19 20#include <string> 21#include <vector> 22 23namespace lldb_private { 24 25class IRExecutionUnit; 26 27//---------------------------------------------------------------------- 28/// @class ClangExpressionParser ClangExpressionParser.h 29/// "lldb/Expression/ClangExpressionParser.h" 30/// @brief Encapsulates an instance of Clang that can parse expressions. 31/// 32/// ClangExpressionParser is responsible for preparing an instance of 33/// ClangExpression for execution. ClangExpressionParser uses ClangExpression 34/// as a glorified parameter list, performing the required parsing and 35/// conversion to formats (DWARF bytecode, or JIT compiled machine code) 36/// that can be executed. 37//---------------------------------------------------------------------- 38class ClangExpressionParser : public ExpressionParser { 39public: 40 //------------------------------------------------------------------ 41 /// Constructor 42 /// 43 /// Initializes class variables. 44 /// 45 /// @param[in] exe_scope, 46 /// If non-NULL, an execution context scope that can help to 47 /// correctly create an expression with a valid process for 48 /// optional tuning Objective-C runtime support. Can be NULL. 49 /// 50 /// @param[in] expr 51 /// The expression to be parsed. 52 //------------------------------------------------------------------ 53 ClangExpressionParser(ExecutionContextScope *exe_scope, Expression &expr, 54 bool generate_debug_info); 55 56 //------------------------------------------------------------------ 57 /// Destructor 58 //------------------------------------------------------------------ 59 ~ClangExpressionParser() override; 60 61 //------------------------------------------------------------------ 62 /// Parse a single expression and convert it to IR using Clang. Don't 63 /// wrap the expression in anything at all. 64 /// 65 /// @param[in] diagnostic_manager 66 /// The diagnostic manager to report errors to. 67 /// 68 /// @return 69 /// The number of errors encountered during parsing. 0 means 70 /// success. 71 //------------------------------------------------------------------ 72 unsigned Parse(DiagnosticManager &diagnostic_manager) override; 73 74 bool RewriteExpression(DiagnosticManager &diagnostic_manager) override; 75 76 //------------------------------------------------------------------ 77 /// Ready an already-parsed expression for execution, possibly 78 /// evaluating it statically. 79 /// 80 /// @param[out] func_addr 81 /// The address to which the function has been written. 82 /// 83 /// @param[out] func_end 84 /// The end of the function's allocated memory region. (func_addr 85 /// and func_end do not delimit an allocated region; the allocated 86 /// region may begin before func_addr.) 87 /// 88 /// @param[in] execution_unit_sp 89 /// After parsing, ownership of the execution unit for 90 /// for the expression is handed to this shared pointer. 91 /// 92 /// @param[in] exe_ctx 93 /// The execution context to write the function into. 94 /// 95 /// @param[out] evaluated_statically 96 /// Set to true if the expression could be interpreted statically; 97 /// untouched otherwise. 98 /// 99 /// @param[out] const_result 100 /// If the result of the expression is constant, and the 101 /// expression has no side effects, this is set to the result of the 102 /// expression. 103 /// 104 /// @param[in] execution_policy 105 /// Determines whether the expression must be JIT-compiled, must be 106 /// evaluated statically, or whether this decision may be made 107 /// opportunistically. 108 /// 109 /// @return 110 /// An error code indicating the success or failure of the operation. 111 /// Test with Success(). 112 //------------------------------------------------------------------ 113 Error 114 PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end, 115 lldb::IRExecutionUnitSP &execution_unit_sp, 116 ExecutionContext &exe_ctx, bool &can_interpret, 117 lldb_private::ExecutionPolicy execution_policy) override; 118 119 //------------------------------------------------------------------ 120 /// Run all static initializers for an execution unit. 121 /// 122 /// @param[in] execution_unit_sp 123 /// The execution unit. 124 /// 125 /// @param[in] exe_ctx 126 /// The execution context to use when running them. Thread can't be null. 127 /// 128 /// @return 129 /// The error code indicating the 130 //------------------------------------------------------------------ 131 Error RunStaticInitializers(lldb::IRExecutionUnitSP &execution_unit_sp, 132 ExecutionContext &exe_ctx); 133 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 //------------------------------------------------------------------- 143 std::string GetClangTargetABI(const ArchSpec &target_arch); 144 145private: 146 std::unique_ptr<llvm::LLVMContext> 147 m_llvm_context; ///< The LLVM context to generate IR into 148 std::unique_ptr<clang::FileManager> 149 m_file_manager; ///< The Clang file manager object used by the compiler 150 std::unique_ptr<clang::CompilerInstance> 151 m_compiler; ///< The Clang compiler used to parse expressions into IR 152 std::unique_ptr<clang::Builtin::Context> 153 m_builtin_context; ///< Context for Clang built-ins 154 std::unique_ptr<clang::SelectorTable> 155 m_selector_table; ///< Selector table for Objective-C methods 156 std::unique_ptr<clang::CodeGenerator> 157 m_code_generator; ///< The Clang object that generates IR 158 159 class LLDBPreprocessorCallbacks; 160 LLDBPreprocessorCallbacks *m_pp_callbacks; ///< Called when the preprocessor 161 ///encounters module imports 162 std::unique_ptr<ClangASTContext> m_ast_context; 163}; 164} 165 166#endif // liblldb_ClangExpressionParser_h_ 167