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_language_runtime(nullptr), m_catch_bp(catch_bp), 108 m_throw_bp(throw_bp) {} 109 110 ~ExceptionBreakpointResolver() override = default; 111 112 Searcher::CallbackReturn SearchCallback(SearchFilter &filter, 113 SymbolContext &context, 114 Address *addr) override { 115 116 if (SetActualResolver()) 117 return m_actual_resolver_sp->SearchCallback(filter, context, addr); 118 else 119 return eCallbackReturnStop; 120 } 121 122 lldb::SearchDepth GetDepth() override { 123 if (SetActualResolver()) 124 return m_actual_resolver_sp->GetDepth(); 125 else 126 return lldb::eSearchDepthTarget; 127 } 128 129 void GetDescription(Stream *s) override { 130 Language *language_plugin = Language::FindPlugin(m_language); 131 if (language_plugin) 132 language_plugin->GetExceptionResolverDescription(m_catch_bp, m_throw_bp, 133 *s); 134 else 135 Language::GetDefaultExceptionResolverDescription(m_catch_bp, m_throw_bp, 136 *s); 137 138 SetActualResolver(); 139 if (m_actual_resolver_sp) { 140 s->Printf(" using: "); 141 m_actual_resolver_sp->GetDescription(s); 142 } else 143 s->Printf(" the correct runtime exception handler will be determined " 144 "when you run"); 145 } 146 147 void Dump(Stream *s) const override {} 148 149 /// Methods for support type inquiry through isa, cast, and dyn_cast: 150 static inline bool classof(const BreakpointResolverName *) { return true; } 151 static inline bool classof(const BreakpointResolver *V) { 152 return V->getResolverID() == BreakpointResolver::ExceptionResolver; 153 } 154 155 protected: 156 BreakpointResolverSP CopyForBreakpoint(BreakpointSP &breakpoint) override { 157 BreakpointResolverSP ret_sp( 158 new ExceptionBreakpointResolver(m_language, m_catch_bp, m_throw_bp)); 159 ret_sp->SetBreakpoint(breakpoint); 160 return ret_sp; 161 } 162 163 bool SetActualResolver() { 164 BreakpointSP breakpoint_sp = GetBreakpoint(); 165 if (breakpoint_sp) { 166 ProcessSP process_sp = breakpoint_sp->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 breakpoint_sp, 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