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: |
37 | bool isA(const void *ClassID) const override { |
38 | return ClassID == &ID || UserExpression::isA(ClassID); |
39 | } |
40 | static bool classof(const Expression *obj) { return obj->isA(ClassID: &ID); } |
41 | |
42 | // The IRPasses struct is filled in by a runtime after an expression is |
43 | // compiled and can be used 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 { |
49 | 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 | |
66 | bool CanInterpret() override { return m_can_interpret; } |
67 | |
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. |
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 | |