Yi Kong | 878f994 | 2023-12-13 12:55:04 +0900 | [diff] [blame^] | 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 | |
| 13 | #include "lldb/Breakpoint/BreakpointResolver.h" |
| 14 | #include "lldb/Breakpoint/BreakpointResolverName.h" |
| 15 | #include "lldb/Core/PluginInterface.h" |
| 16 | #include "lldb/Core/Value.h" |
| 17 | #include "lldb/Core/ValueObject.h" |
| 18 | #include "lldb/Expression/LLVMUserExpression.h" |
| 19 | #include "lldb/Symbol/DeclVendor.h" |
| 20 | #include "lldb/Target/ExecutionContextScope.h" |
| 21 | #include "lldb/Target/Runtime.h" |
| 22 | #include "lldb/lldb-private.h" |
| 23 | #include "lldb/lldb-public.h" |
| 24 | #include <optional> |
| 25 | |
| 26 | namespace lldb_private { |
| 27 | |
| 28 | class ExceptionSearchFilter : public SearchFilter { |
| 29 | public: |
| 30 | ExceptionSearchFilter(const lldb::TargetSP &target_sp, |
| 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 * |
| 45 | CreateFromStructuredData(Target &target, |
| 46 | const StructuredData::Dictionary &data_dict, |
| 47 | Status &error); |
| 48 | |
| 49 | StructuredData::ObjectSP SerializeToStructuredData() override; |
| 50 | |
| 51 | protected: |
| 52 | lldb::LanguageType m_language; |
| 53 | LanguageRuntime *m_language_runtime; |
| 54 | lldb::SearchFilterSP m_filter_sp; |
| 55 | |
| 56 | lldb::SearchFilterSP DoCreateCopy() override; |
| 57 | |
| 58 | void UpdateModuleListIfNeeded(); |
| 59 | }; |
| 60 | |
| 61 | class LanguageRuntime : public Runtime, public PluginInterface { |
| 62 | public: |
| 63 | static LanguageRuntime *FindPlugin(Process *process, |
| 64 | lldb::LanguageType language); |
| 65 | |
| 66 | static void InitializeCommands(CommandObject *parent); |
| 67 | |
| 68 | virtual lldb::LanguageType GetLanguageType() const = 0; |
| 69 | |
| 70 | /// Return the preferred language runtime instance, which in most cases will |
| 71 | /// be the current instance. |
| 72 | virtual LanguageRuntime *GetPreferredLanguageRuntime(ValueObject &in_value) { |
| 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. |
| 91 | virtual CompilerType GetConcreteType(ExecutionContextScope *exe_scope, |
| 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 | |
| 110 | virtual void ClearExceptionBreakpoints() {} |
| 111 | |
| 112 | virtual bool ExceptionBreakpointsAreSet() { return false; } |
| 113 | |
| 114 | virtual bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) { |
| 115 | return false; |
| 116 | } |
| 117 | |
| 118 | static lldb::BreakpointSP |
| 119 | CreateExceptionBreakpoint(Target &target, lldb::LanguageType language, |
| 120 | bool catch_bp, bool throw_bp, |
| 121 | bool is_internal = false); |
| 122 | |
| 123 | static lldb::BreakpointPreconditionSP |
| 124 | GetExceptionPrecondition(lldb::LanguageType language, bool throw_bp); |
| 125 | |
| 126 | virtual lldb::ValueObjectSP GetExceptionObjectForThread( |
| 127 | lldb::ThreadSP thread_sp) { |
| 128 | return lldb::ValueObjectSP(); |
| 129 | } |
| 130 | |
| 131 | virtual lldb::ThreadSP GetBacktraceThreadFromException( |
| 132 | lldb::ValueObjectSP thread_sp) { |
| 133 | return lldb::ThreadSP(); |
| 134 | } |
| 135 | |
| 136 | virtual DeclVendor *GetDeclVendor() { return nullptr; } |
| 137 | |
| 138 | virtual lldb::BreakpointResolverSP |
| 139 | CreateExceptionResolver(const lldb::BreakpointSP &bkpt, |
| 140 | bool catch_bp, bool throw_bp) = 0; |
| 141 | |
| 142 | virtual lldb::SearchFilterSP CreateExceptionSearchFilter() { |
| 143 | return m_process->GetTarget().GetSearchFilterForModule(nullptr); |
| 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 | |
| 153 | virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread, |
| 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. |
| 176 | virtual lldb::addr_t LookupRuntimeSymbol(ConstString name) { |
| 177 | return LLDB_INVALID_ADDRESS; |
| 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 |
| 213 | GetRuntimeUnwindPlan(lldb_private::Thread &thread, |
| 214 | lldb_private::RegisterContext *regctx, |
| 215 | bool &behaves_like_zeroth_frame); |
| 216 | |
| 217 | protected: |
| 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 |
| 222 | GetRuntimeUnwindPlan(lldb::ProcessSP process_sp, |
| 223 | lldb_private::RegisterContext *regctx, |
| 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 |