1 //===-- LLVMUserExpression.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_EXPRESSION_LLVMUSEREXPRESSION_H 10 #define LLDB_EXPRESSION_LLVMUSEREXPRESSION_H 11 12 #include <map> 13 #include <string> 14 #include <vector> 15 16 #include "llvm/IR/LegacyPassManager.h" 17 18 #include "lldb/Expression/UserExpression.h" 19 20 namespace lldb_private { 21 22 /// \class LLVMUserExpression LLVMUserExpression.h 23 /// "lldb/Expression/LLVMUserExpression.h" Encapsulates a one-time expression 24 /// for use in lldb. 25 /// 26 /// LLDB uses expressions for various purposes, notably to call functions 27 /// and as a backend for the expr command. LLVMUserExpression is a virtual 28 /// base class that encapsulates the objects needed to parse and JIT an 29 /// expression. The actual parsing part will be provided by the specific 30 /// implementations of LLVMUserExpression - which will be vended through the 31 /// appropriate TypeSystem. 32 class LLVMUserExpression : public UserExpression { 33 // LLVM RTTI support 34 static char ID; 35 36 public: isA(const void * ClassID)37 bool isA(const void *ClassID) const override { 38 return ClassID == &ID || UserExpression::isA(ClassID); 39 } classof(const Expression * obj)40 static bool classof(const Expression *obj) { return obj->isA(&ID); } 41 42 // The IRPasses struct is filled in by a runtime after an expression is 43 // compiled and can be used to to run fixups/analysis passes as required. 44 // EarlyPasses are run on the generated module before lldb runs its own IR 45 // fixups and inserts instrumentation code/pointer checks. LatePasses are run 46 // after the module has been processed by llvm, before the module is 47 // assembled and run in the ThreadPlan. 48 struct IRPasses { IRPassesIRPasses49 IRPasses() : EarlyPasses(nullptr), LatePasses(nullptr){}; 50 std::shared_ptr<llvm::legacy::PassManager> EarlyPasses; 51 std::shared_ptr<llvm::legacy::PassManager> LatePasses; 52 }; 53 54 LLVMUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr, 55 llvm::StringRef prefix, lldb::LanguageType language, 56 ResultType desired_type, 57 const EvaluateExpressionOptions &options); 58 ~LLVMUserExpression() override; 59 60 bool FinalizeJITExecution( 61 DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, 62 lldb::ExpressionVariableSP &result, 63 lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS, 64 lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS) override; 65 CanInterpret()66 bool CanInterpret() override { return m_can_interpret; } 67 GetMaterializer()68 Materializer *GetMaterializer() override { return m_materializer_up.get(); } 69 70 /// Return the string that the parser should parse. Must be a full 71 /// translation unit. Text()72 const char *Text() override { return m_transformed_text.c_str(); } 73 74 protected: 75 lldb::ExpressionResults 76 DoExecute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, 77 const EvaluateExpressionOptions &options, 78 lldb::UserExpressionSP &shared_ptr_to_me, 79 lldb::ExpressionVariableSP &result) override; 80 81 virtual void ScanContext(ExecutionContext &exe_ctx, 82 lldb_private::Status &err) = 0; 83 84 bool PrepareToExecuteJITExpression(DiagnosticManager &diagnostic_manager, 85 ExecutionContext &exe_ctx, 86 lldb::addr_t &struct_address); 87 88 virtual bool AddArguments(ExecutionContext &exe_ctx, 89 std::vector<lldb::addr_t> &args, 90 lldb::addr_t struct_address, 91 DiagnosticManager &diagnostic_manager) = 0; 92 93 lldb::addr_t 94 m_stack_frame_bottom; ///< The bottom of the allocated stack frame. 95 lldb::addr_t m_stack_frame_top; ///< The top of the allocated stack frame. 96 97 bool m_allow_cxx; ///< True if the language allows C++. 98 bool m_allow_objc; ///< True if the language allows Objective-C. 99 std::string 100 m_transformed_text; ///< The text of the expression, as send to the parser 101 102 std::shared_ptr<IRExecutionUnit> 103 m_execution_unit_sp; ///< The execution unit the expression is stored in. 104 std::unique_ptr<Materializer> m_materializer_up; ///< The materializer to use 105 /// when running the 106 /// expression. 107 lldb::ModuleWP m_jit_module_wp; 108 Target *m_target; ///< The target for storing persistent data like types and 109 ///variables. 110 111 bool m_can_interpret; ///< True if the expression could be evaluated 112 ///statically; false otherwise. 113 lldb::addr_t m_materialized_address; ///< The address at which the arguments 114 ///to the expression have been 115 ///materialized. 116 Materializer::DematerializerSP m_dematerializer_sp; ///< The dematerializer. 117 }; 118 119 } // namespace lldb_private 120 #endif 121