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