LLDB mainline
LanguageRuntime.h
Go to the documentation of this file.
1//===-- LanguageRuntime.h ---------------------------------------------------*-
2// C++ -*-===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef LLDB_TARGET_LANGUAGERUNTIME_H
11#define LLDB_TARGET_LANGUAGERUNTIME_H
12
16#include "lldb/Core/Value.h"
21#include "lldb/Target/Runtime.h"
22#include "lldb/lldb-private.h"
23#include "lldb/lldb-public.h"
24#include <optional>
25
26namespace lldb_private {
27
29public:
31 lldb::LanguageType language,
32 bool update_module_list = true);
33
34 ~ExceptionSearchFilter() override = default;
35
36 bool ModulePasses(const lldb::ModuleSP &module_sp) override;
37
38 bool ModulePasses(const FileSpec &spec) override;
39
40 void Search(Searcher &searcher) override;
41
42 void GetDescription(Stream *s) override;
43
44 static SearchFilter *
46 const StructuredData::Dictionary &data_dict,
47 Status &error);
48
50
51protected:
55
57
59};
60
61class LanguageRuntime : public Runtime, public PluginInterface {
62public:
63 static LanguageRuntime *FindPlugin(Process *process,
64 lldb::LanguageType language);
65
66 static void InitializeCommands(CommandObject *parent);
67
69
70 /// Return the preferred language runtime instance, which in most cases will
71 /// be the current instance.
73 return nullptr;
74 }
75
76 virtual bool GetObjectDescription(Stream &str, ValueObject &object) = 0;
77
78 virtual bool GetObjectDescription(Stream &str, Value &value,
79 ExecutionContextScope *exe_scope) = 0;
80
81 // this call should return true if it could set the name and/or the type
82 virtual bool GetDynamicTypeAndAddress(ValueObject &in_value,
83 lldb::DynamicValueType use_dynamic,
84 TypeAndOrName &class_type_or_name,
85 Address &address,
86 Value::ValueType &value_type) = 0;
87
88 // This call should return a CompilerType given a generic type name and an
89 // ExecutionContextScope in which one can actually fetch any specialization
90 // information required.
92 ConstString abstract_type_name) {
93 return CompilerType();
94 }
95
96 // This should be a fast test to determine whether it is likely that this
97 // value would have a dynamic type.
98 virtual bool CouldHaveDynamicValue(ValueObject &in_value) = 0;
99
100 // The contract for GetDynamicTypeAndAddress() is to return a "bare-bones"
101 // dynamic type For instance, given a Base* pointer,
102 // GetDynamicTypeAndAddress() will return the type of Derived, not Derived*.
103 // The job of this API is to correct this misalignment between the static
104 // type and the discovered dynamic type
105 virtual TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
106 ValueObject &static_value) = 0;
107
108 virtual void SetExceptionBreakpoints() {}
109
111
112 virtual bool ExceptionBreakpointsAreSet() { return false; }
113
115 return false;
116 }
117
118 static lldb::BreakpointSP
120 bool catch_bp, bool throw_bp,
121 bool is_internal = false);
122
124 GetExceptionPrecondition(lldb::LanguageType language, bool throw_bp);
125
127 lldb::ThreadSP thread_sp) {
128 return lldb::ValueObjectSP();
129 }
130
132 lldb::ValueObjectSP thread_sp) {
133 return lldb::ThreadSP();
134 }
135
136 virtual DeclVendor *GetDeclVendor() { return nullptr; }
137
140 bool catch_bp, bool throw_bp) = 0;
141
144 }
145
146 virtual bool GetTypeBitSize(const CompilerType &compiler_type,
147 uint64_t &size) {
148 return false;
149 }
150
151 virtual void SymbolsDidLoad(const ModuleList &module_list) {}
152
154 bool stop_others) = 0;
155
156 /// Identify whether a name is a runtime value that should not be hidden by
157 /// from the user interface.
158 virtual bool IsAllowedRuntimeValue(ConstString name) { return false; }
159
160 virtual std::optional<CompilerType> GetRuntimeType(CompilerType base_type) {
161 return std::nullopt;
162 }
163
164 void ModulesDidLoad(const ModuleList &module_list) override {}
165
166 // Called by ClangExpressionParser::PrepareForExecution to query for any
167 // custom LLVM IR passes that need to be run before an expression is
168 // assembled and run.
169 virtual bool GetIRPasses(LLVMUserExpression::IRPasses &custom_passes) {
170 return false;
171 }
172
173 // Given the name of a runtime symbol (e.g. in Objective-C, an ivar offset
174 // symbol), try to determine from the runtime what the value of that symbol
175 // would be. Useful when the underlying binary is stripped.
178 }
179
180 virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
181 static char ID;
182
183 /// A language runtime may be able to provide a special UnwindPlan for
184 /// the frame represented by the register contents \a regctx when that
185 /// frame is not following the normal ABI conventions.
186 /// Instead of using the normal UnwindPlan for the function, we will use
187 /// this special UnwindPlan for this one backtrace.
188 /// One example of this would be a language that has asynchronous functions,
189 /// functions that may not be currently-executing, while waiting on other
190 /// asynchronous calls they made, but are part of a logical backtrace that
191 /// we want to show the developer because that's how they think of the
192 /// program flow.
193 ///
194 /// \param[in] thread
195 /// The thread that the unwind is happening on.
196 ///
197 /// \param[in] regctx
198 /// The RegisterContext for the frame we need to create an UnwindPlan.
199 /// We don't yet have a StackFrame when we're selecting the UnwindPlan.
200 ///
201 /// \param[out] behaves_like_zeroth_frame
202 /// With normal ABI calls, all stack frames except the zeroth frame need
203 /// to have the return-pc value backed up by 1 for symbolication purposes.
204 /// For these LanguageRuntime unwind plans, they may not follow normal ABI
205 /// calling conventions and the return pc may need to be symbolicated
206 /// as-is.
207 ///
208 /// \return
209 /// Returns an UnwindPlan to find the caller frame if it should be used,
210 /// instead of the UnwindPlan that would normally be used for this
211 /// function.
212 static lldb::UnwindPlanSP
215 bool &behaves_like_zeroth_frame);
216
217protected:
218 // The static GetRuntimeUnwindPlan method above is only implemented in the
219 // base class; subclasses may override this protected member if they can
220 // provide one of these UnwindPlans.
221 virtual lldb::UnwindPlanSP
224 bool &behaves_like_zeroth_frame) {
225 return lldb::UnwindPlanSP();
226 }
227
228 LanguageRuntime(Process *process);
229};
230
231} // namespace lldb_private
232
233#endif // LLDB_TARGET_LANGUAGERUNTIME_H
static llvm::raw_ostream & error(Stream &strm)
A section + offset based address class.
Definition: Address.h:59
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:40
static SearchFilter * CreateFromStructuredData(Target &target, const StructuredData::Dictionary &data_dict, Status &error)
bool ModulePasses(const lldb::ModuleSP &module_sp) override
Call this method with a Module to see if that module passes the filter.
lldb::SearchFilterSP DoCreateCopy() override
void Search(Searcher &searcher) override
Call this method to do the search using the Searcher.
~ExceptionSearchFilter() override=default
StructuredData::ObjectSP SerializeToStructuredData() override
void GetDescription(Stream *s) override
Prints a canonical description for the search filter to the stream s.
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
A file utility class.
Definition: FileSpec.h:56
virtual bool IsAllowedRuntimeValue(ConstString name)
Identify whether a name is a runtime value that should not be hidden by from the user interface.
virtual std::optional< CompilerType > GetRuntimeType(CompilerType base_type)
virtual void SetExceptionBreakpoints()
virtual lldb::LanguageType GetLanguageType() const =0
virtual CompilerType GetConcreteType(ExecutionContextScope *exe_scope, ConstString abstract_type_name)
virtual TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value)=0
virtual lldb::ThreadSP GetBacktraceThreadFromException(lldb::ValueObjectSP thread_sp)
virtual lldb::UnwindPlanSP GetRuntimeUnwindPlan(lldb::ProcessSP process_sp, lldb_private::RegisterContext *regctx, bool &behaves_like_zeroth_frame)
virtual lldb::ValueObjectSP GetExceptionObjectForThread(lldb::ThreadSP thread_sp)
static LanguageRuntime * FindPlugin(Process *process, lldb::LanguageType language)
virtual bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason)
virtual void ClearExceptionBreakpoints()
virtual LanguageRuntime * GetPreferredLanguageRuntime(ValueObject &in_value)
Return the preferred language runtime instance, which in most cases will be the current instance.
virtual bool GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name, Address &address, Value::ValueType &value_type)=0
virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, bool stop_others)=0
virtual bool isA(const void *ClassID) const
virtual lldb::addr_t LookupRuntimeSymbol(ConstString name)
virtual bool ExceptionBreakpointsAreSet()
static lldb::UnwindPlanSP GetRuntimeUnwindPlan(lldb_private::Thread &thread, lldb_private::RegisterContext *regctx, bool &behaves_like_zeroth_frame)
A language runtime may be able to provide a special UnwindPlan for the frame represented by the regis...
void ModulesDidLoad(const ModuleList &module_list) override
Called when modules have been loaded in the process.
virtual DeclVendor * GetDeclVendor()
virtual void SymbolsDidLoad(const ModuleList &module_list)
static lldb::BreakpointSP CreateExceptionBreakpoint(Target &target, lldb::LanguageType language, bool catch_bp, bool throw_bp, bool is_internal=false)
virtual bool GetTypeBitSize(const CompilerType &compiler_type, uint64_t &size)
virtual bool GetIRPasses(LLVMUserExpression::IRPasses &custom_passes)
static void InitializeCommands(CommandObject *parent)
virtual bool CouldHaveDynamicValue(ValueObject &in_value)=0
virtual bool GetObjectDescription(Stream &str, Value &value, ExecutionContextScope *exe_scope)=0
virtual bool GetObjectDescription(Stream &str, ValueObject &object)=0
virtual lldb::SearchFilterSP CreateExceptionSearchFilter()
virtual lldb::BreakpointResolverSP CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp, bool throw_bp)=0
static lldb::BreakpointPreconditionSP GetExceptionPrecondition(lldb::LanguageType language, bool throw_bp)
A collection class for Module objects.
Definition: ModuleList.h:82
A plug-in interface definition class for debugging a process.
Definition: Process.h:336
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1242
Process * m_process
Definition: Runtime.h:29
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition: SearchFilter.h:83
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition: SearchFilter.h:42
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
std::shared_ptr< Object > ObjectSP
lldb::SearchFilterSP GetSearchFilterForModule(const FileSpec *containingModule)
Definition: Target.cpp:534
Sometimes you can find the name of the type corresponding to an object, but we don't have debug infor...
Definition: Type.h:410
ValueType
Type that describes Value::m_value.
Definition: Value.h:41
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:76
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:428
std::shared_ptr< lldb_private::SearchFilter > SearchFilterSP
Definition: lldb-forward.h:397
std::shared_ptr< lldb_private::BreakpointResolver > BreakpointResolverSP
Definition: lldb-forward.h:310
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:425
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:458
LanguageType
Programming language type.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:303
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:368
std::shared_ptr< lldb_private::BreakpointPrecondition > BreakpointPreconditionSP
Definition: lldb-forward.h:309
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
Definition: lldb-forward.h:457
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:406
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:423
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:354