| File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/lldb/source/Target/LanguageRuntime.cpp |
| Warning: | line 290, column 9 Although the value stored to 'create_callback' is used in the enclosing expression, the value is never actually read from 'create_callback' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===-- LanguageRuntime.cpp -----------------------------------------------===// |
| 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 | #include "lldb/Target/LanguageRuntime.h" |
| 10 | #include "lldb/Core/PluginManager.h" |
| 11 | #include "lldb/Core/SearchFilter.h" |
| 12 | #include "lldb/Interpreter/CommandInterpreter.h" |
| 13 | #include "lldb/Target/Language.h" |
| 14 | #include "lldb/Target/Target.h" |
| 15 | |
| 16 | using namespace lldb; |
| 17 | using namespace lldb_private; |
| 18 | |
| 19 | char LanguageRuntime::ID = 0; |
| 20 | |
| 21 | ExceptionSearchFilter::ExceptionSearchFilter(const lldb::TargetSP &target_sp, |
| 22 | lldb::LanguageType language, |
| 23 | bool update_module_list) |
| 24 | : SearchFilter(target_sp, FilterTy::Exception), m_language(language), |
| 25 | m_language_runtime(nullptr), m_filter_sp() { |
| 26 | if (update_module_list) |
| 27 | UpdateModuleListIfNeeded(); |
| 28 | } |
| 29 | |
| 30 | bool ExceptionSearchFilter::ModulePasses(const lldb::ModuleSP &module_sp) { |
| 31 | UpdateModuleListIfNeeded(); |
| 32 | if (m_filter_sp) |
| 33 | return m_filter_sp->ModulePasses(module_sp); |
| 34 | return false; |
| 35 | } |
| 36 | |
| 37 | bool ExceptionSearchFilter::ModulePasses(const FileSpec &spec) { |
| 38 | UpdateModuleListIfNeeded(); |
| 39 | if (m_filter_sp) |
| 40 | return m_filter_sp->ModulePasses(spec); |
| 41 | return false; |
| 42 | } |
| 43 | |
| 44 | void ExceptionSearchFilter::Search(Searcher &searcher) { |
| 45 | UpdateModuleListIfNeeded(); |
| 46 | if (m_filter_sp) |
| 47 | m_filter_sp->Search(searcher); |
| 48 | } |
| 49 | |
| 50 | void ExceptionSearchFilter::GetDescription(Stream *s) { |
| 51 | UpdateModuleListIfNeeded(); |
| 52 | if (m_filter_sp) |
| 53 | m_filter_sp->GetDescription(s); |
| 54 | } |
| 55 | |
| 56 | void ExceptionSearchFilter::UpdateModuleListIfNeeded() { |
| 57 | ProcessSP process_sp(m_target_sp->GetProcessSP()); |
| 58 | if (process_sp) { |
| 59 | bool refreash_filter = !m_filter_sp; |
| 60 | if (m_language_runtime == nullptr) { |
| 61 | m_language_runtime = process_sp->GetLanguageRuntime(m_language); |
| 62 | refreash_filter = true; |
| 63 | } else { |
| 64 | LanguageRuntime *language_runtime = |
| 65 | process_sp->GetLanguageRuntime(m_language); |
| 66 | if (m_language_runtime != language_runtime) { |
| 67 | m_language_runtime = language_runtime; |
| 68 | refreash_filter = true; |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | if (refreash_filter && m_language_runtime) { |
| 73 | m_filter_sp = m_language_runtime->CreateExceptionSearchFilter(); |
| 74 | } |
| 75 | } else { |
| 76 | m_filter_sp.reset(); |
| 77 | m_language_runtime = nullptr; |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | SearchFilterSP ExceptionSearchFilter::DoCreateCopy() { |
| 82 | return SearchFilterSP( |
| 83 | new ExceptionSearchFilter(TargetSP(), m_language, false)); |
| 84 | } |
| 85 | |
| 86 | SearchFilter *ExceptionSearchFilter::CreateFromStructuredData( |
| 87 | Target &target, const StructuredData::Dictionary &data_dict, |
| 88 | Status &error) { |
| 89 | SearchFilter *result = nullptr; |
| 90 | return result; |
| 91 | } |
| 92 | |
| 93 | StructuredData::ObjectSP ExceptionSearchFilter::SerializeToStructuredData() { |
| 94 | StructuredData::ObjectSP result_sp; |
| 95 | |
| 96 | return result_sp; |
| 97 | } |
| 98 | |
| 99 | // The Target is the one that knows how to create breakpoints, so this function |
| 100 | // is meant to be used either by the target or internally in |
| 101 | // Set/ClearExceptionBreakpoints. |
| 102 | class ExceptionBreakpointResolver : public BreakpointResolver { |
| 103 | public: |
| 104 | ExceptionBreakpointResolver(lldb::LanguageType language, bool catch_bp, |
| 105 | bool throw_bp) |
| 106 | : BreakpointResolver(nullptr, BreakpointResolver::ExceptionResolver), |
| 107 | m_language(language), m_catch_bp(catch_bp), m_throw_bp(throw_bp) {} |
| 108 | |
| 109 | ~ExceptionBreakpointResolver() override = default; |
| 110 | |
| 111 | Searcher::CallbackReturn SearchCallback(SearchFilter &filter, |
| 112 | SymbolContext &context, |
| 113 | Address *addr) override { |
| 114 | |
| 115 | if (SetActualResolver()) |
| 116 | return m_actual_resolver_sp->SearchCallback(filter, context, addr); |
| 117 | else |
| 118 | return eCallbackReturnStop; |
| 119 | } |
| 120 | |
| 121 | lldb::SearchDepth GetDepth() override { |
| 122 | if (SetActualResolver()) |
| 123 | return m_actual_resolver_sp->GetDepth(); |
| 124 | else |
| 125 | return lldb::eSearchDepthTarget; |
| 126 | } |
| 127 | |
| 128 | void GetDescription(Stream *s) override { |
| 129 | Language *language_plugin = Language::FindPlugin(m_language); |
| 130 | if (language_plugin) |
| 131 | language_plugin->GetExceptionResolverDescription(m_catch_bp, m_throw_bp, |
| 132 | *s); |
| 133 | else |
| 134 | Language::GetDefaultExceptionResolverDescription(m_catch_bp, m_throw_bp, |
| 135 | *s); |
| 136 | |
| 137 | SetActualResolver(); |
| 138 | if (m_actual_resolver_sp) { |
| 139 | s->Printf(" using: "); |
| 140 | m_actual_resolver_sp->GetDescription(s); |
| 141 | } else |
| 142 | s->Printf(" the correct runtime exception handler will be determined " |
| 143 | "when you run"); |
| 144 | } |
| 145 | |
| 146 | void Dump(Stream *s) const override {} |
| 147 | |
| 148 | /// Methods for support type inquiry through isa, cast, and dyn_cast: |
| 149 | static inline bool classof(const BreakpointResolverName *) { return true; } |
| 150 | static inline bool classof(const BreakpointResolver *V) { |
| 151 | return V->getResolverID() == BreakpointResolver::ExceptionResolver; |
| 152 | } |
| 153 | |
| 154 | protected: |
| 155 | BreakpointResolverSP CopyForBreakpoint(BreakpointSP &breakpoint) override { |
| 156 | BreakpointResolverSP ret_sp( |
| 157 | new ExceptionBreakpointResolver(m_language, m_catch_bp, m_throw_bp)); |
| 158 | ret_sp->SetBreakpoint(breakpoint); |
| 159 | return ret_sp; |
| 160 | } |
| 161 | |
| 162 | bool SetActualResolver() { |
| 163 | BreakpointSP breakpoint_sp = GetBreakpoint(); |
| 164 | if (breakpoint_sp) { |
| 165 | ProcessSP process_sp = breakpoint_sp->GetTarget().GetProcessSP(); |
| 166 | if (process_sp) { |
| 167 | bool refreash_resolver = !m_actual_resolver_sp; |
| 168 | if (m_language_runtime == nullptr) { |
| 169 | m_language_runtime = process_sp->GetLanguageRuntime(m_language); |
| 170 | refreash_resolver = true; |
| 171 | } else { |
| 172 | LanguageRuntime *language_runtime = |
| 173 | process_sp->GetLanguageRuntime(m_language); |
| 174 | if (m_language_runtime != language_runtime) { |
| 175 | m_language_runtime = language_runtime; |
| 176 | refreash_resolver = true; |
| 177 | } |
| 178 | } |
| 179 | |
| 180 | if (refreash_resolver && m_language_runtime) { |
| 181 | m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver( |
| 182 | breakpoint_sp, m_catch_bp, m_throw_bp); |
| 183 | } |
| 184 | } else { |
| 185 | m_actual_resolver_sp.reset(); |
| 186 | m_language_runtime = nullptr; |
| 187 | } |
| 188 | } else { |
| 189 | m_actual_resolver_sp.reset(); |
| 190 | m_language_runtime = nullptr; |
| 191 | } |
| 192 | return (bool)m_actual_resolver_sp; |
| 193 | } |
| 194 | |
| 195 | lldb::BreakpointResolverSP m_actual_resolver_sp; |
| 196 | lldb::LanguageType m_language; |
| 197 | LanguageRuntime *m_language_runtime = nullptr; |
| 198 | bool m_catch_bp; |
| 199 | bool m_throw_bp; |
| 200 | }; |
| 201 | |
| 202 | LanguageRuntime *LanguageRuntime::FindPlugin(Process *process, |
| 203 | lldb::LanguageType language) { |
| 204 | LanguageRuntimeCreateInstance create_callback; |
| 205 | for (uint32_t idx = 0; |
| 206 | (create_callback = |
| 207 | PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != |
| 208 | nullptr; |
| 209 | ++idx) { |
| 210 | if (LanguageRuntime *runtime = create_callback(process, language)) |
| 211 | return runtime; |
| 212 | } |
| 213 | return nullptr; |
| 214 | } |
| 215 | |
| 216 | LanguageRuntime::LanguageRuntime(Process *process) : Runtime(process) {} |
| 217 | |
| 218 | BreakpointPreconditionSP |
| 219 | LanguageRuntime::GetExceptionPrecondition(LanguageType language, |
| 220 | bool throw_bp) { |
| 221 | LanguageRuntimeCreateInstance create_callback; |
| 222 | for (uint32_t idx = 0; |
| 223 | (create_callback = |
| 224 | PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != |
| 225 | nullptr; |
| 226 | idx++) { |
| 227 | if (auto precondition_callback = |
| 228 | PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex( |
| 229 | idx)) { |
| 230 | if (BreakpointPreconditionSP precond = |
| 231 | precondition_callback(language, throw_bp)) |
| 232 | return precond; |
| 233 | } |
| 234 | } |
| 235 | return BreakpointPreconditionSP(); |
| 236 | } |
| 237 | |
| 238 | BreakpointSP LanguageRuntime::CreateExceptionBreakpoint( |
| 239 | Target &target, lldb::LanguageType language, bool catch_bp, bool throw_bp, |
| 240 | bool is_internal) { |
| 241 | BreakpointResolverSP resolver_sp( |
| 242 | new ExceptionBreakpointResolver(language, catch_bp, throw_bp)); |
| 243 | SearchFilterSP filter_sp( |
| 244 | new ExceptionSearchFilter(target.shared_from_this(), language)); |
| 245 | bool hardware = false; |
| 246 | bool resolve_indirect_functions = false; |
| 247 | BreakpointSP exc_breakpt_sp( |
| 248 | target.CreateBreakpoint(filter_sp, resolver_sp, is_internal, hardware, |
| 249 | resolve_indirect_functions)); |
| 250 | if (exc_breakpt_sp) { |
| 251 | if (auto precond = GetExceptionPrecondition(language, throw_bp)) |
| 252 | exc_breakpt_sp->SetPrecondition(precond); |
| 253 | |
| 254 | if (is_internal) |
| 255 | exc_breakpt_sp->SetBreakpointKind("exception"); |
| 256 | } |
| 257 | |
| 258 | return exc_breakpt_sp; |
| 259 | } |
| 260 | |
| 261 | UnwindPlanSP |
| 262 | LanguageRuntime::GetRuntimeUnwindPlan(Thread &thread, RegisterContext *regctx, |
| 263 | bool &behaves_like_zeroth_frame) { |
| 264 | ProcessSP process_sp = thread.GetProcess(); |
| 265 | if (!process_sp.get()) |
| 266 | return UnwindPlanSP(); |
| 267 | if (process_sp->GetDisableLangRuntimeUnwindPlans() == true) |
| 268 | return UnwindPlanSP(); |
| 269 | for (const lldb::LanguageType lang_type : Language::GetSupportedLanguages()) { |
| 270 | if (LanguageRuntime *runtime = process_sp->GetLanguageRuntime(lang_type)) { |
| 271 | UnwindPlanSP plan_sp = runtime->GetRuntimeUnwindPlan( |
| 272 | process_sp, regctx, behaves_like_zeroth_frame); |
| 273 | if (plan_sp.get()) |
| 274 | return plan_sp; |
| 275 | } |
| 276 | } |
| 277 | return UnwindPlanSP(); |
| 278 | } |
| 279 | |
| 280 | void LanguageRuntime::InitializeCommands(CommandObject *parent) { |
| 281 | if (!parent) |
| 282 | return; |
| 283 | |
| 284 | if (!parent->IsMultiwordObject()) |
| 285 | return; |
| 286 | |
| 287 | LanguageRuntimeCreateInstance create_callback; |
| 288 | |
| 289 | for (uint32_t idx = 0; |
| 290 | (create_callback = |
Although the value stored to 'create_callback' is used in the enclosing expression, the value is never actually read from 'create_callback' | |
| 291 | PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != |
| 292 | nullptr; |
| 293 | ++idx) { |
| 294 | if (LanguageRuntimeGetCommandObject command_callback = |
| 295 | PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(idx)) { |
| 296 | CommandObjectSP command = |
| 297 | command_callback(parent->GetCommandInterpreter()); |
| 298 | if (command) { |
| 299 | // the CommandObject vended by a Language plugin cannot be created once |
| 300 | // and cached because we may create multiple debuggers and need one |
| 301 | // instance of the command each - the implementing function is meant to |
| 302 | // create a new instance of the command each time it is invoked. |
| 303 | parent->LoadSubCommand(command->GetCommandName().str().c_str(), command); |
| 304 | } |
| 305 | } |
| 306 | } |
| 307 | } |