ClangExpressionParser.h revision 1cf3da8b0fb0cabf2431b5fe521842929fca69a3
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/lldb-public.h" 14#include "lldb/Core/ArchSpec.h" 15#include "lldb/Core/ClangForward.h" 16#include "lldb/Core/Error.h" 17#include "lldb/Expression/IRForTarget.h" 18 19#include <string> 20#include <vector> 21 22namespace lldb_private 23{ 24 25class IRExecutionUnit; 26 27//---------------------------------------------------------------------- 28/// @class ClangExpressionParser ClangExpressionParser.h "lldb/Expression/ClangExpressionParser.h" 29/// @brief Encapsulates an instance of Clang that can parse expressions. 30/// 31/// ClangExpressionParser is responsible for preparing an instance of 32/// ClangExpression for execution. ClangExpressionParser uses ClangExpression 33/// as a glorified parameter list, performing the required parsing and 34/// conversion to formats (DWARF bytecode, or JIT compiled machine code) 35/// that can be executed. 36//---------------------------------------------------------------------- 37class ClangExpressionParser 38{ 39public: 40 //------------------------------------------------------------------ 41 /// Constructor 42 /// 43 /// Initializes class variabes. 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, 54 ClangExpression &expr); 55 56 //------------------------------------------------------------------ 57 /// Destructor 58 //------------------------------------------------------------------ 59 ~ClangExpressionParser (); 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] stream 66 /// The stream to print errors to. 67 /// 68 /// @return 69 /// The number of errors encountered during parsing. 0 means 70 /// success. 71 //------------------------------------------------------------------ 72 unsigned 73 Parse (Stream &stream); 74 75 //------------------------------------------------------------------ 76 /// Ready an already-parsed expression for execution, possibly 77 /// evaluating it statically. 78 /// 79 /// @param[out] func_addr 80 /// The address to which the function has been written. 81 /// 82 /// @param[out] func_end 83 /// The end of the function's allocated memory region. (func_addr 84 /// and func_end do not delimit an allocated region; the allocated 85 /// region may begin before func_addr.) 86 /// 87 /// @param[in] exe_ctx 88 /// The execution context to write the function into. 89 /// 90 /// @param[out] evaluated_statically 91 /// Set to true if the expression could be interpreted statically; 92 /// untouched otherwise. 93 /// 94 /// @param[out] const_result 95 /// If the result of the expression is constant, and the 96 /// expression has no side effects, this is set to the result of the 97 /// expression. 98 /// 99 /// @param[in] execution_policy 100 /// Determines whether the expression must be JIT-compiled, must be 101 /// evaluated statically, or whether this decision may be made 102 /// opportunistically. 103 /// 104 /// @return 105 /// An error code indicating the success or failure of the operation. 106 /// Test with Success(). 107 //------------------------------------------------------------------ 108 Error 109 PrepareForExecution (lldb::addr_t &func_addr, 110 lldb::addr_t &func_end, 111 ExecutionContext &exe_ctx, 112 bool &evaluated_statically, 113 lldb::ClangExpressionVariableSP &const_result, 114 lldb_private::ExecutionPolicy execution_policy); 115 116 //------------------------------------------------------------------ 117 /// Disassemble the machine code for a JITted function from the target 118 /// process's memory and print the result to a stream. 119 /// 120 /// @param[in] stream 121 /// The stream to print disassembly to. 122 /// 123 /// @param[in] exc_context 124 /// The execution context to get the machine code from. 125 /// 126 /// @return 127 /// The error generated. If .Success() is true, disassembly succeeded. 128 //------------------------------------------------------------------ 129 Error 130 DisassembleFunction (Stream &stream, 131 ExecutionContext &exe_ctx); 132 133private: 134 ClangExpression &m_expr; ///< The expression to be parsed 135 136 std::auto_ptr<llvm::LLVMContext> m_llvm_context; ///< The LLVM context to generate IR into 137 std::auto_ptr<clang::FileManager> m_file_manager; ///< The Clang file manager object used by the compiler 138 std::auto_ptr<clang::CompilerInstance> m_compiler; ///< The Clang compiler used to parse expressions into IR 139 std::auto_ptr<clang::Builtin::Context> m_builtin_context; ///< Context for Clang built-ins 140 std::auto_ptr<clang::SelectorTable> m_selector_table; ///< Selector table for Objective-C methods 141 std::auto_ptr<clang::ASTContext> m_ast_context; ///< The AST context used to hold types and names for the parser 142 std::auto_ptr<clang::CodeGenerator> m_code_generator; ///< The Clang object that generates IR 143 std::auto_ptr<IRExecutionUnit> m_execution_unit; ///< The container for the finished Module 144}; 145 146} 147 148#endif // liblldb_ClangExpressionParser_h_ 149