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
20namespace 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.
32class LLVMUserExpression : public UserExpression {
33 // LLVM RTTI support
34 static char ID;
35
36public:
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
74protected:
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

source code of lldb/include/lldb/Expression/LLVMUserExpression.h