1 //===-- LanguageRuntime.cpp -------------------------------------*- 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 #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 82 ExceptionSearchFilter::DoCopyForBreakpoint(Breakpoint &breakpoint) { 83 return SearchFilterSP( 84 new ExceptionSearchFilter(TargetSP(), m_language, false)); 85 } 86 87 SearchFilter *ExceptionSearchFilter::CreateFromStructuredData( 88 Target &target, const StructuredData::Dictionary &data_dict, 89 Status &error) { 90 SearchFilter *result = nullptr; 91 return result; 92 } 93 94 StructuredData::ObjectSP ExceptionSearchFilter::SerializeToStructuredData() { 95 StructuredData::ObjectSP result_sp; 96 97 return result_sp; 98 } 99 100 // The Target is the one that knows how to create breakpoints, so this function 101 // is meant to be used either by the target or internally in 102 // Set/ClearExceptionBreakpoints. 103 class ExceptionBreakpointResolver : public BreakpointResolver { 104 public: 105 ExceptionBreakpointResolver(lldb::LanguageType language, bool catch_bp, 106 bool throw_bp) 107 : BreakpointResolver(nullptr, BreakpointResolver::ExceptionResolver), 108 m_language(language), m_language_runtime(nullptr), m_catch_bp(catch_bp), 109 m_throw_bp(throw_bp) {} 110 111 ~ExceptionBreakpointResolver() override = default; 112 113 Searcher::CallbackReturn SearchCallback(SearchFilter &filter, 114 SymbolContext &context, Address *addr, 115 bool containing) override { 116 117 if (SetActualResolver()) 118 return m_actual_resolver_sp->SearchCallback(filter, context, addr, 119 containing); 120 else 121 return eCallbackReturnStop; 122 } 123 124 lldb::SearchDepth GetDepth() override { 125 if (SetActualResolver()) 126 return m_actual_resolver_sp->GetDepth(); 127 else 128 return lldb::eSearchDepthTarget; 129 } 130 131 void GetDescription(Stream *s) override { 132 Language *language_plugin = Language::FindPlugin(m_language); 133 if (language_plugin) 134 language_plugin->GetExceptionResolverDescription(m_catch_bp, m_throw_bp, 135 *s); 136 else 137 Language::GetDefaultExceptionResolverDescription(m_catch_bp, m_throw_bp, 138 *s); 139 140 SetActualResolver(); 141 if (m_actual_resolver_sp) { 142 s->Printf(" using: "); 143 m_actual_resolver_sp->GetDescription(s); 144 } else 145 s->Printf(" the correct runtime exception handler will be determined " 146 "when you run"); 147 } 148 149 void Dump(Stream *s) const override {} 150 151 /// Methods for support type inquiry through isa, cast, and dyn_cast: 152 static inline bool classof(const BreakpointResolverName *) { return true; } 153 static inline bool classof(const BreakpointResolver *V) { 154 return V->getResolverID() == BreakpointResolver::ExceptionResolver; 155 } 156 157 protected: 158 BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override { 159 return BreakpointResolverSP( 160 new ExceptionBreakpointResolver(m_language, m_catch_bp, m_throw_bp)); 161 } 162 163 bool SetActualResolver() { 164 ProcessSP process_sp; 165 if (m_breakpoint) { 166 process_sp = m_breakpoint->GetTarget().GetProcessSP(); 167 if (process_sp) { 168 bool refreash_resolver = !m_actual_resolver_sp; 169 if (m_language_runtime == nullptr) { 170 m_language_runtime = process_sp->GetLanguageRuntime(m_language); 171 refreash_resolver = true; 172 } else { 173 LanguageRuntime *language_runtime = 174 process_sp->GetLanguageRuntime(m_language); 175 if (m_language_runtime != language_runtime) { 176 m_language_runtime = language_runtime; 177 refreash_resolver = true; 178 } 179 } 180 181 if (refreash_resolver && m_language_runtime) { 182 m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver( 183 m_breakpoint, m_catch_bp, m_throw_bp); 184 } 185 } else { 186 m_actual_resolver_sp.reset(); 187 m_language_runtime = nullptr; 188 } 189 } else { 190 m_actual_resolver_sp.reset(); 191 m_language_runtime = nullptr; 192 } 193 return (bool)m_actual_resolver_sp; 194 } 195 196 lldb::BreakpointResolverSP m_actual_resolver_sp; 197 lldb::LanguageType m_language; 198 LanguageRuntime *m_language_runtime; 199 bool m_catch_bp; 200 bool m_throw_bp; 201 }; 202 203 LanguageRuntime *LanguageRuntime::FindPlugin(Process *process, 204 lldb::LanguageType language) { 205 std::unique_ptr<LanguageRuntime> language_runtime_up; 206 LanguageRuntimeCreateInstance create_callback; 207 208 for (uint32_t idx = 0; 209 (create_callback = 210 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != 211 nullptr; 212 ++idx) { 213 language_runtime_up.reset(create_callback(process, language)); 214 215 if (language_runtime_up) 216 return language_runtime_up.release(); 217 } 218 219 return nullptr; 220 } 221 222 LanguageRuntime::LanguageRuntime(Process *process) : m_process(process) {} 223 224 LanguageRuntime::~LanguageRuntime() = default; 225 226 BreakpointPreconditionSP 227 LanguageRuntime::GetExceptionPrecondition(LanguageType language, 228 bool throw_bp) { 229 LanguageRuntimeCreateInstance create_callback; 230 for (uint32_t idx = 0; 231 (create_callback = 232 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != 233 nullptr; 234 idx++) { 235 if (auto precondition_callback = 236 PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex( 237 idx)) { 238 if (BreakpointPreconditionSP precond = 239 precondition_callback(language, throw_bp)) 240 return precond; 241 } 242 } 243 return BreakpointPreconditionSP(); 244 } 245 246 BreakpointSP LanguageRuntime::CreateExceptionBreakpoint( 247 Target &target, lldb::LanguageType language, bool catch_bp, bool throw_bp, 248 bool is_internal) { 249 BreakpointResolverSP resolver_sp( 250 new ExceptionBreakpointResolver(language, catch_bp, throw_bp)); 251 SearchFilterSP filter_sp( 252 new ExceptionSearchFilter(target.shared_from_this(), language)); 253 bool hardware = false; 254 bool resolve_indirect_functions = false; 255 BreakpointSP exc_breakpt_sp( 256 target.CreateBreakpoint(filter_sp, resolver_sp, is_internal, hardware, 257 resolve_indirect_functions)); 258 if (exc_breakpt_sp) { 259 if (auto precond = GetExceptionPrecondition(language, throw_bp)) 260 exc_breakpt_sp->SetPrecondition(precond); 261 262 if (is_internal) 263 exc_breakpt_sp->SetBreakpointKind("exception"); 264 } 265 266 return exc_breakpt_sp; 267 } 268 269 void LanguageRuntime::InitializeCommands(CommandObject *parent) { 270 if (!parent) 271 return; 272 273 if (!parent->IsMultiwordObject()) 274 return; 275 276 LanguageRuntimeCreateInstance create_callback; 277 278 for (uint32_t idx = 0; 279 (create_callback = 280 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != 281 nullptr; 282 ++idx) { 283 if (LanguageRuntimeGetCommandObject command_callback = 284 PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(idx)) { 285 CommandObjectSP command = 286 command_callback(parent->GetCommandInterpreter()); 287 if (command) { 288 // the CommandObject vended by a Language plugin cannot be created once 289 // and cached because we may create multiple debuggers and need one 290 // instance of the command each - the implementing function is meant to 291 // create a new instance of the command each time it is invoked. 292 parent->LoadSubCommand(command->GetCommandName().str().c_str(), command); 293 } 294 } 295 } 296 } 297