contrib/llvm/tools/lldb/include/lldb/Expression/ClangExpressionParser.h

   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
  22 namespace lldb_private
  23 {
  24
  25 class 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 //----------------------------------------------------------------------
  37 class ClangExpressionParser
  38 {
  39 public:
  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] execution_unit_ap
  88     ///     After parsing, ownership of the execution unit for
  89     ///     for the expression is handed to this unique pointer.
  90     ///
  91     /// @param[in] exe_ctx
  92     ///     The execution context to write the function into.
  93     ///
  94     /// @param[out] evaluated_statically
  95     ///     Set to true if the expression could be interpreted statically;
  96     ///     untouched otherwise.
  97     ///
  98     /// @param[out] const_result
  99     ///     If the result of the expression is constant, and the
 100     ///     expression has no side effects, this is set to the result of the
 101     ///     expression.
 102     ///
 103     /// @param[in] execution_policy
 104     ///     Determines whether the expression must be JIT-compiled, must be
 105     ///     evaluated statically, or whether this decision may be made
 106     ///     opportunistically.
 107     ///
 108     /// @return
 109     ///     An error code indicating the success or failure of the operation.
 110     ///     Test with Success().
 111     //------------------------------------------------------------------
 112     Error
 113     PrepareForExecution (lldb::addr_t &func_addr,
 114                          lldb::addr_t &func_end,
 115                          std::unique_ptr<IRExecutionUnit> &execution_unit_ap,
 116                          ExecutionContext &exe_ctx,
 117                          bool &can_interpret,
 118                          lldb_private::ExecutionPolicy execution_policy);
 119
 120     //------------------------------------------------------------------
 121     /// Disassemble the machine code for a JITted function from the target
 122     /// process's memory and print the result to a stream.
 123     ///
 124     /// @param[in] stream
 125     ///     The stream to print disassembly to.
 126     ///
 127     /// @param[in] exc_context
 128     ///     The execution context to get the machine code from.
 129     ///
 130     /// @return
 131     ///     The error generated.  If .Success() is true, disassembly succeeded.
 132     //------------------------------------------------------------------
 133     Error
 134     DisassembleFunction (Stream &stream,
 135                          ExecutionContext &exe_ctx);
 136
 137 private:
 138     ClangExpression &                       m_expr;                 ///< The expression to be parsed
 139     std::unique_ptr<llvm::LLVMContext>       m_llvm_context;         ///< The LLVM context to generate IR into
 140     std::unique_ptr<clang::FileManager>      m_file_manager;         ///< The Clang file manager object used by the compiler
 141     std::unique_ptr<clang::CompilerInstance> m_compiler;             ///< The Clang compiler used to parse expressions into IR
 142     std::unique_ptr<clang::Builtin::Context> m_builtin_context;      ///< Context for Clang built-ins
 143     std::unique_ptr<clang::SelectorTable>    m_selector_table;       ///< Selector table for Objective-C methods
 144     std::unique_ptr<clang::ASTContext>       m_ast_context;          ///< The AST context used to hold types and names for the parser
 145     std::unique_ptr<clang::CodeGenerator>    m_code_generator;       ///< The Clang object that generates IR
 146     std::unique_ptr<IRExecutionUnit>         m_execution_unit;       ///< The container for the finished Module
 147 };
 148
 149 }
 150
 151 #endif  // liblldb_ClangExpressionParser_h_