LLDB mainline
LLVMUserExpression.h
Go to the documentation of this file.
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
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.
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(&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, SourceLanguage language,
56 ResultType desired_type,
57 const EvaluateExpressionOptions &options);
58 ~LLVMUserExpression() override;
59
61 DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
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:
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
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.
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.
117};
118
119} // namespace lldb_private
120#endif
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Encapsulates a single expression for use in lldb.
Definition: Expression.h:31
virtual bool isA(const void *ClassID) const =0
"lldb/Expression/LLVMUserExpression.h" Encapsulates a one-time expression for use in lldb.
lldb::ExpressionResults DoExecute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, lldb::UserExpressionSP &shared_ptr_to_me, lldb::ExpressionVariableSP &result) override
std::string m_transformed_text
The text of the expression, as send to the parser.
bool m_can_interpret
True if the expression could be evaluated statically; false otherwise.
Materializer * GetMaterializer() override
Return the Materializer that the parser should use when registering external values.
std::unique_ptr< Materializer > m_materializer_up
The materializer to use when running the expression.
bool m_allow_cxx
True if the language allows C++.
virtual void ScanContext(ExecutionContext &exe_ctx, lldb_private::Status &err)=0
Target * m_target
The target for storing persistent data like types and variables.
const char * Text() override
Return the string that the parser should parse.
bool isA(const void *ClassID) const override
bool FinalizeJITExecution(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, lldb::ExpressionVariableSP &result, lldb::addr_t function_stack_bottom=LLDB_INVALID_ADDRESS, lldb::addr_t function_stack_top=LLDB_INVALID_ADDRESS) override
Apply the side effects of the function to program state.
bool PrepareToExecuteJITExpression(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, lldb::addr_t &struct_address)
lldb::addr_t m_stack_frame_bottom
The bottom of the allocated stack frame.
std::shared_ptr< IRExecutionUnit > m_execution_unit_sp
The execution unit the expression is stored in.
bool m_allow_objc
True if the language allows Objective-C.
static bool classof(const Expression *obj)
Materializer::DematerializerSP m_dematerializer_sp
The dematerializer.
lldb::addr_t m_stack_frame_top
The top of the allocated stack frame.
virtual bool AddArguments(ExecutionContext &exe_ctx, std::vector< lldb::addr_t > &args, lldb::addr_t struct_address, DiagnosticManager &diagnostic_manager)=0
lldb::addr_t m_materialized_address
The address at which the arguments to the expression have been materialized.
std::shared_ptr< Dematerializer > DematerializerSP
Definition: Materializer.h:64
An error handling class.
Definition: Status.h:44
Encapsulates a one-time expression for use in lldb.
bool isA(const void *ClassID) const override
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
std::weak_ptr< lldb_private::Module > ModuleWP
Definition: lldb-forward.h:369
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:346
std::shared_ptr< lldb_private::UserExpression > UserExpressionSP
Definition: lldb-forward.h:327
ExpressionResults
The results of expression evaluation.
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< llvm::legacy::PassManager > EarlyPasses
std::shared_ptr< llvm::legacy::PassManager > LatePasses
A type-erased pair of llvm::dwarf::SourceLanguageName and version.