blob: 80b64fb832fa4b9e358998761aa6a33c51e0da54 [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001//===-- PluginManager.cpp ---------------------------------------*- C++ -*-===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// 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
Chris Lattner30fdc8d2010-06-08 16:52:24 +00006//
7//===----------------------------------------------------------------------===//
8
9#include "lldb/Core/PluginManager.h"
10
Greg Claytone8cd0c92012-10-19 18:02:49 +000011#include "lldb/Core/Debugger.h"
Jonas Devlieghere35e4c842018-11-01 00:33:27 +000012#include "lldb/Host/FileSystem.h"
Zachary Turner42ff0ad2014-08-21 17:29:12 +000013#include "lldb/Host/HostInfo.h"
Greg Claytone8cd0c92012-10-19 18:02:49 +000014#include "lldb/Interpreter/OptionValueProperties.h"
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000015#include "lldb/Utility/ConstString.h"
Zachary Turner5713a052017-03-22 18:40:07 +000016#include "lldb/Utility/FileSpec.h"
Zachary Turner97206d52017-05-12 04:51:55 +000017#include "lldb/Utility/Status.h"
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000018#include "lldb/Utility/StringList.h"
Zachary Turner2f3df612017-04-06 21:28:29 +000019
Nico Weberb1cb0b792018-04-10 13:33:45 +000020#if defined(_WIN32)
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000021#include "lldb/Host/windows/PosixApi.h"
Zachary Turner2f3df612017-04-06 21:28:29 +000022#endif
23
24#include "llvm/ADT/StringRef.h"
25#include "llvm/Support/DynamicLibrary.h"
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000026#include "llvm/Support/FileSystem.h"
27#include "llvm/Support/raw_ostream.h"
Zachary Turner2f3df612017-04-06 21:28:29 +000028
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000029#include <map>
30#include <memory>
Zachary Turner2f3df612017-04-06 21:28:29 +000031#include <mutex>
32#include <string>
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000033#include <utility>
Zachary Turner2f3df612017-04-06 21:28:29 +000034#include <vector>
35
Jonas Devlieghere672d2c12018-11-11 23:16:43 +000036#include <assert.h>
Zachary Turner2f3df612017-04-06 21:28:29 +000037
38namespace lldb_private {
39class CommandInterpreter;
40}
Greg Clayton4272cc72011-02-02 02:24:04 +000041
42using namespace lldb;
Chris Lattner30fdc8d2010-06-08 16:52:24 +000043using namespace lldb_private;
44
Kate Stoneb9c1b512016-09-06 20:57:50 +000045enum PluginAction {
46 ePluginRegisterInstance,
47 ePluginUnregisterInstance,
48 ePluginGetInstanceAtIndex
Chris Lattner30fdc8d2010-06-08 16:52:24 +000049};
50
Eugene Zelenko89183722016-03-11 21:55:47 +000051typedef bool (*PluginInitCallback)();
52typedef void (*PluginTermCallback)();
Greg Clayton03da4cc2013-04-19 21:31:16 +000053
Kate Stoneb9c1b512016-09-06 20:57:50 +000054struct PluginInfo {
55 PluginInfo() : plugin_init_callback(nullptr), plugin_term_callback(nullptr) {}
Zachary Turner58a559c2014-08-27 20:15:09 +000056
Kate Stoneb9c1b512016-09-06 20:57:50 +000057 llvm::sys::DynamicLibrary library;
58 PluginInitCallback plugin_init_callback;
59 PluginTermCallback plugin_term_callback;
Greg Clayton4272cc72011-02-02 02:24:04 +000060};
61
62typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
63
Kate Stoneb9c1b512016-09-06 20:57:50 +000064static std::recursive_mutex &GetPluginMapMutex() {
65 static std::recursive_mutex g_plugin_map_mutex;
66 return g_plugin_map_mutex;
Greg Clayton4272cc72011-02-02 02:24:04 +000067}
68
Kate Stoneb9c1b512016-09-06 20:57:50 +000069static PluginTerminateMap &GetPluginMap() {
70 static PluginTerminateMap g_plugin_map;
71 return g_plugin_map;
Greg Clayton4272cc72011-02-02 02:24:04 +000072}
73
Kate Stoneb9c1b512016-09-06 20:57:50 +000074static bool PluginIsLoaded(const FileSpec &plugin_file_spec) {
75 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
76 PluginTerminateMap &plugin_map = GetPluginMap();
77 return plugin_map.find(plugin_file_spec) != plugin_map.end();
Greg Clayton4272cc72011-02-02 02:24:04 +000078}
79
Kate Stoneb9c1b512016-09-06 20:57:50 +000080static void SetPluginInfo(const FileSpec &plugin_file_spec,
81 const PluginInfo &plugin_info) {
82 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
83 PluginTerminateMap &plugin_map = GetPluginMap();
84 assert(plugin_map.find(plugin_file_spec) == plugin_map.end());
85 plugin_map[plugin_file_spec] = plugin_info;
David Majnemer5ff02782014-07-22 21:59:22 +000086}
Greg Clayton4272cc72011-02-02 02:24:04 +000087
Kate Stoneb9c1b512016-09-06 20:57:50 +000088template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
89 return reinterpret_cast<FPtrTy>(reinterpret_cast<intptr_t>(VPtr));
90}
Greg Clayton45319462011-02-08 00:35:34 +000091
Jonas Devlieghere35e4c842018-11-01 00:33:27 +000092static FileSystem::EnumerateDirectoryResult
Zachary Turner7d86ee52017-03-08 17:56:08 +000093LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
Jonas Devlieghere35e4c842018-11-01 00:33:27 +000094 llvm::StringRef path) {
Kate Stoneb9c1b512016-09-06 20:57:50 +000095 // PluginManager *plugin_manager = (PluginManager *)baton;
Zachary Turner97206d52017-05-12 04:51:55 +000096 Status error;
Greg Clayton4272cc72011-02-02 02:24:04 +000097
Zachary Turner7d86ee52017-03-08 17:56:08 +000098 namespace fs = llvm::sys::fs;
Adrian Prantl05097242018-04-30 16:49:04 +000099 // If we have a regular file, a symbolic link or unknown file type, try and
100 // process the file. We must handle unknown as sometimes the directory
Kate Stoneb9c1b512016-09-06 20:57:50 +0000101 // enumeration might be enumerating a file system that doesn't have correct
102 // file type information.
Zachary Turner7d86ee52017-03-08 17:56:08 +0000103 if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
104 ft == fs::file_type::type_unknown) {
Jonas Devlieghere8f3be7a2018-11-01 21:05:36 +0000105 FileSpec plugin_file_spec(path);
106 FileSystem::Instance().Resolve(plugin_file_spec);
Greg Clayton4272cc72011-02-02 02:24:04 +0000107
Kate Stoneb9c1b512016-09-06 20:57:50 +0000108 if (PluginIsLoaded(plugin_file_spec))
Jonas Devlieghere35e4c842018-11-01 00:33:27 +0000109 return FileSystem::eEnumerateDirectoryResultNext;
Kate Stoneb9c1b512016-09-06 20:57:50 +0000110 else {
111 PluginInfo plugin_info;
Greg Clayton4272cc72011-02-02 02:24:04 +0000112
Kate Stoneb9c1b512016-09-06 20:57:50 +0000113 std::string pluginLoadError;
114 plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
115 plugin_file_spec.GetPath().c_str(), &pluginLoadError);
116 if (plugin_info.library.isValid()) {
117 bool success = false;
118 plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
119 plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
120 if (plugin_info.plugin_init_callback) {
121 // Call the plug-in "bool LLDBPluginInitialize(void)" function
122 success = plugin_info.plugin_init_callback();
Greg Clayton4272cc72011-02-02 02:24:04 +0000123 }
Greg Clayton4272cc72011-02-02 02:24:04 +0000124
Kate Stoneb9c1b512016-09-06 20:57:50 +0000125 if (success) {
126 // It is ok for the "LLDBPluginTerminate" symbol to be nullptr
127 plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
128 plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
129 } else {
130 // The initialize function returned FALSE which means the plug-in
Adrian Prantl05097242018-04-30 16:49:04 +0000131 // might not be compatible, or might be too new or too old, or might
132 // not want to run on this machine. Set it to a default-constructed
133 // instance to invalidate it.
Kate Stoneb9c1b512016-09-06 20:57:50 +0000134 plugin_info = PluginInfo();
135 }
136
Adrian Prantl05097242018-04-30 16:49:04 +0000137 // Regardless of success or failure, cache the plug-in load in our
138 // plug-in info so we don't try to load it again and again.
Kate Stoneb9c1b512016-09-06 20:57:50 +0000139 SetPluginInfo(plugin_file_spec, plugin_info);
140
Jonas Devlieghere35e4c842018-11-01 00:33:27 +0000141 return FileSystem::eEnumerateDirectoryResultNext;
Kate Stoneb9c1b512016-09-06 20:57:50 +0000142 }
143 }
144 }
145
Zachary Turner7d86ee52017-03-08 17:56:08 +0000146 if (ft == fs::file_type::directory_file ||
147 ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
Adrian Prantl05097242018-04-30 16:49:04 +0000148 // Try and recurse into anything that a directory or symbolic link. We must
149 // also do this for unknown as sometimes the directory enumeration might be
150 // enumerating a file system that doesn't have correct file type
Kate Stoneb9c1b512016-09-06 20:57:50 +0000151 // information.
Jonas Devlieghere35e4c842018-11-01 00:33:27 +0000152 return FileSystem::eEnumerateDirectoryResultEnter;
Kate Stoneb9c1b512016-09-06 20:57:50 +0000153 }
154
Jonas Devlieghere35e4c842018-11-01 00:33:27 +0000155 return FileSystem::eEnumerateDirectoryResultNext;
Greg Clayton4272cc72011-02-02 02:24:04 +0000156}
157
Kate Stoneb9c1b512016-09-06 20:57:50 +0000158void PluginManager::Initialize() {
Greg Clayton1cb64962011-03-24 04:28:38 +0000159#if 1
Kate Stoneb9c1b512016-09-06 20:57:50 +0000160 const bool find_directories = true;
161 const bool find_files = true;
162 const bool find_other = true;
163 char dir_path[PATH_MAX];
Pavel Labath60f028f2018-06-19 15:09:07 +0000164 if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
Jonas Devliegheredbd7fab2018-11-01 17:09:25 +0000165 if (FileSystem::Instance().Exists(dir_spec) &&
166 dir_spec.GetPath(dir_path, sizeof(dir_path))) {
Jonas Devlieghere35e4c842018-11-01 00:33:27 +0000167 FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
168 find_files, find_other,
169 LoadPluginCallback, nullptr);
Greg Clayton4272cc72011-02-02 02:24:04 +0000170 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000171 }
Greg Clayton4272cc72011-02-02 02:24:04 +0000172
Pavel Labath60f028f2018-06-19 15:09:07 +0000173 if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
Jonas Devliegheredbd7fab2018-11-01 17:09:25 +0000174 if (FileSystem::Instance().Exists(dir_spec) &&
175 dir_spec.GetPath(dir_path, sizeof(dir_path))) {
Jonas Devlieghere35e4c842018-11-01 00:33:27 +0000176 FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
177 find_files, find_other,
178 LoadPluginCallback, nullptr);
Greg Clayton4272cc72011-02-02 02:24:04 +0000179 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000180 }
Greg Clayton1cb64962011-03-24 04:28:38 +0000181#endif
Greg Clayton4272cc72011-02-02 02:24:04 +0000182}
183
Kate Stoneb9c1b512016-09-06 20:57:50 +0000184void PluginManager::Terminate() {
185 std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
186 PluginTerminateMap &plugin_map = GetPluginMap();
187
188 PluginTerminateMap::const_iterator pos, end = plugin_map.end();
189 for (pos = plugin_map.begin(); pos != end; ++pos) {
Adrian Prantl05097242018-04-30 16:49:04 +0000190 // Call the plug-in "void LLDBPluginTerminate (void)" function if there is
191 // one (if the symbol was not nullptr).
Kate Stoneb9c1b512016-09-06 20:57:50 +0000192 if (pos->second.library.isValid()) {
193 if (pos->second.plugin_term_callback)
194 pos->second.plugin_term_callback();
Greg Clayton4272cc72011-02-02 02:24:04 +0000195 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000196 }
197 plugin_map.clear();
Greg Clayton4272cc72011-02-02 02:24:04 +0000198}
199
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000200#pragma mark ABI
201
Kate Stoneb9c1b512016-09-06 20:57:50 +0000202struct ABIInstance {
203 ABIInstance() : name(), description(), create_callback(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000204
Kate Stoneb9c1b512016-09-06 20:57:50 +0000205 ConstString name;
206 std::string description;
207 ABICreateInstance create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000208};
209
210typedef std::vector<ABIInstance> ABIInstances;
211
Kate Stoneb9c1b512016-09-06 20:57:50 +0000212static std::recursive_mutex &GetABIInstancesMutex() {
213 static std::recursive_mutex g_instances_mutex;
214 return g_instances_mutex;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000215}
216
Kate Stoneb9c1b512016-09-06 20:57:50 +0000217static ABIInstances &GetABIInstances() {
218 static ABIInstances g_instances;
219 return g_instances;
Greg Claytonded470d2011-03-19 01:12:21 +0000220}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000221
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000222bool PluginManager::RegisterPlugin(ConstString name,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000223 const char *description,
224 ABICreateInstance create_callback) {
225 if (create_callback) {
226 ABIInstance instance;
227 assert((bool)name);
228 instance.name = name;
229 if (description && description[0])
230 instance.description = description;
231 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000232 std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000233 GetABIInstances().push_back(instance);
234 return true;
235 }
236 return false;
237}
238
239bool PluginManager::UnregisterPlugin(ABICreateInstance create_callback) {
240 if (create_callback) {
241 std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
242 ABIInstances &instances = GetABIInstances();
243
244 ABIInstances::iterator pos, end = instances.end();
245 for (pos = instances.begin(); pos != end; ++pos) {
246 if (pos->create_callback == create_callback) {
247 instances.erase(pos);
248 return true;
249 }
250 }
251 }
252 return false;
253}
254
255ABICreateInstance PluginManager::GetABICreateCallbackAtIndex(uint32_t idx) {
256 std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
257 ABIInstances &instances = GetABIInstances();
258 if (idx < instances.size())
259 return instances[idx].create_callback;
260 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000261}
262
263ABICreateInstance
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000264PluginManager::GetABICreateCallbackForPluginName(ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000265 if (name) {
266 std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
267 ABIInstances &instances = GetABIInstances();
Greg Claytonded470d2011-03-19 01:12:21 +0000268
Kate Stoneb9c1b512016-09-06 20:57:50 +0000269 ABIInstances::iterator pos, end = instances.end();
270 for (pos = instances.begin(); pos != end; ++pos) {
271 if (name == pos->name)
272 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000273 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000274 }
275 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000276}
277
Pavel Labath13e37d42017-10-25 21:05:31 +0000278#pragma mark Architecture
279
280struct ArchitectureInstance {
281 ConstString name;
282 std::string description;
283 PluginManager::ArchitectureCreateInstance create_callback;
284};
285
286typedef std::vector<ArchitectureInstance> ArchitectureInstances;
287
Kuba Mracekb2413ea2018-11-12 16:52:58 +0000288static std::mutex &GetArchitectureMutex() {
289 static std::mutex g_architecture_mutex;
290 return g_architecture_mutex;
291}
Pavel Labath13e37d42017-10-25 21:05:31 +0000292
293static ArchitectureInstances &GetArchitectureInstances() {
294 static ArchitectureInstances g_instances;
295 return g_instances;
296}
297
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000298void PluginManager::RegisterPlugin(ConstString name,
Pavel Labath13e37d42017-10-25 21:05:31 +0000299 llvm::StringRef description,
300 ArchitectureCreateInstance create_callback) {
Kuba Mracekb2413ea2018-11-12 16:52:58 +0000301 std::lock_guard<std::mutex> guard(GetArchitectureMutex());
Pavel Labath13e37d42017-10-25 21:05:31 +0000302 GetArchitectureInstances().push_back({name, description, create_callback});
303}
304
305void PluginManager::UnregisterPlugin(
306 ArchitectureCreateInstance create_callback) {
Kuba Mracekb2413ea2018-11-12 16:52:58 +0000307 std::lock_guard<std::mutex> guard(GetArchitectureMutex());
Pavel Labath13e37d42017-10-25 21:05:31 +0000308 auto &instances = GetArchitectureInstances();
309
310 for (auto pos = instances.begin(), end = instances.end(); pos != end; ++pos) {
311 if (pos->create_callback == create_callback) {
312 instances.erase(pos);
313 return;
314 }
315 }
316 llvm_unreachable("Plugin not found");
317}
318
319std::unique_ptr<Architecture>
320PluginManager::CreateArchitectureInstance(const ArchSpec &arch) {
Kuba Mracekb2413ea2018-11-12 16:52:58 +0000321 std::lock_guard<std::mutex> guard(GetArchitectureMutex());
Pavel Labath13e37d42017-10-25 21:05:31 +0000322 for (const auto &instances : GetArchitectureInstances()) {
323 if (auto plugin_up = instances.create_callback(arch))
324 return plugin_up;
325 }
326 return nullptr;
327}
328
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000329#pragma mark Disassembler
330
Kate Stoneb9c1b512016-09-06 20:57:50 +0000331struct DisassemblerInstance {
332 DisassemblerInstance() : name(), description(), create_callback(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000333
Kate Stoneb9c1b512016-09-06 20:57:50 +0000334 ConstString name;
335 std::string description;
336 DisassemblerCreateInstance create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000337};
338
339typedef std::vector<DisassemblerInstance> DisassemblerInstances;
340
Kate Stoneb9c1b512016-09-06 20:57:50 +0000341static std::recursive_mutex &GetDisassemblerMutex() {
342 static std::recursive_mutex g_instances_mutex;
343 return g_instances_mutex;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000344}
345
Kate Stoneb9c1b512016-09-06 20:57:50 +0000346static DisassemblerInstances &GetDisassemblerInstances() {
347 static DisassemblerInstances g_instances;
348 return g_instances;
Greg Claytonab65b342011-04-13 22:47:15 +0000349}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000350
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000351bool PluginManager::RegisterPlugin(ConstString name,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000352 const char *description,
353 DisassemblerCreateInstance create_callback) {
354 if (create_callback) {
355 DisassemblerInstance instance;
356 assert((bool)name);
357 instance.name = name;
358 if (description && description[0])
359 instance.description = description;
360 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000361 std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000362 GetDisassemblerInstances().push_back(instance);
363 return true;
364 }
365 return false;
366}
367
368bool PluginManager::UnregisterPlugin(
369 DisassemblerCreateInstance create_callback) {
370 if (create_callback) {
371 std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
372 DisassemblerInstances &instances = GetDisassemblerInstances();
373
374 DisassemblerInstances::iterator pos, end = instances.end();
375 for (pos = instances.begin(); pos != end; ++pos) {
376 if (pos->create_callback == create_callback) {
377 instances.erase(pos);
378 return true;
379 }
380 }
381 }
382 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000383}
384
385DisassemblerCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000386PluginManager::GetDisassemblerCreateCallbackAtIndex(uint32_t idx) {
387 std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
388 DisassemblerInstances &instances = GetDisassemblerInstances();
389 if (idx < instances.size())
390 return instances[idx].create_callback;
391 return nullptr;
392}
393
394DisassemblerCreateInstance
395PluginManager::GetDisassemblerCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000396 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000397 if (name) {
398 std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
399 DisassemblerInstances &instances = GetDisassemblerInstances();
400
401 DisassemblerInstances::iterator pos, end = instances.end();
402 for (pos = instances.begin(); pos != end; ++pos) {
403 if (name == pos->name)
404 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000405 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000406 }
407 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000408}
409
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000410#pragma mark DynamicLoader
411
Kate Stoneb9c1b512016-09-06 20:57:50 +0000412struct DynamicLoaderInstance {
413 DynamicLoaderInstance()
414 : name(), description(), create_callback(nullptr),
415 debugger_init_callback(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000416
Kate Stoneb9c1b512016-09-06 20:57:50 +0000417 ConstString name;
418 std::string description;
419 DynamicLoaderCreateInstance create_callback;
420 DebuggerInitializeCallback debugger_init_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000421};
422
423typedef std::vector<DynamicLoaderInstance> DynamicLoaderInstances;
424
Kate Stoneb9c1b512016-09-06 20:57:50 +0000425static std::recursive_mutex &GetDynamicLoaderMutex() {
426 static std::recursive_mutex g_instances_mutex;
427 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +0000428}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000429
Kate Stoneb9c1b512016-09-06 20:57:50 +0000430static DynamicLoaderInstances &GetDynamicLoaderInstances() {
431 static DynamicLoaderInstances g_instances;
432 return g_instances;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000433}
434
Kate Stoneb9c1b512016-09-06 20:57:50 +0000435bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000436 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000437 DynamicLoaderCreateInstance create_callback,
438 DebuggerInitializeCallback debugger_init_callback) {
439 if (create_callback) {
440 DynamicLoaderInstance instance;
441 assert((bool)name);
442 instance.name = name;
443 if (description && description[0])
444 instance.description = description;
445 instance.create_callback = create_callback;
446 instance.debugger_init_callback = debugger_init_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000447 std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000448 GetDynamicLoaderInstances().push_back(instance);
449 }
450 return false;
451}
452
453bool PluginManager::UnregisterPlugin(
454 DynamicLoaderCreateInstance create_callback) {
455 if (create_callback) {
456 std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
457 DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
458
459 DynamicLoaderInstances::iterator pos, end = instances.end();
460 for (pos = instances.begin(); pos != end; ++pos) {
461 if (pos->create_callback == create_callback) {
462 instances.erase(pos);
463 return true;
464 }
465 }
466 }
467 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000468}
469
470DynamicLoaderCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000471PluginManager::GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx) {
472 std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
473 DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
474 if (idx < instances.size())
475 return instances[idx].create_callback;
476 return nullptr;
477}
478
479DynamicLoaderCreateInstance
480PluginManager::GetDynamicLoaderCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000481 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000482 if (name) {
483 std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
484 DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
485
486 DynamicLoaderInstances::iterator pos, end = instances.end();
487 for (pos = instances.begin(); pos != end; ++pos) {
488 if (name == pos->name)
489 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000490 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000491 }
492 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000493}
494
Andrew MacPherson17220c12014-03-05 10:12:43 +0000495#pragma mark JITLoader
496
Kate Stoneb9c1b512016-09-06 20:57:50 +0000497struct JITLoaderInstance {
498 JITLoaderInstance()
499 : name(), description(), create_callback(nullptr),
500 debugger_init_callback(nullptr) {}
Andrew MacPherson17220c12014-03-05 10:12:43 +0000501
Kate Stoneb9c1b512016-09-06 20:57:50 +0000502 ConstString name;
503 std::string description;
504 JITLoaderCreateInstance create_callback;
505 DebuggerInitializeCallback debugger_init_callback;
Andrew MacPherson17220c12014-03-05 10:12:43 +0000506};
507
508typedef std::vector<JITLoaderInstance> JITLoaderInstances;
509
Kate Stoneb9c1b512016-09-06 20:57:50 +0000510static std::recursive_mutex &GetJITLoaderMutex() {
511 static std::recursive_mutex g_instances_mutex;
512 return g_instances_mutex;
Andrew MacPherson17220c12014-03-05 10:12:43 +0000513}
514
Kate Stoneb9c1b512016-09-06 20:57:50 +0000515static JITLoaderInstances &GetJITLoaderInstances() {
516 static JITLoaderInstances g_instances;
517 return g_instances;
Andrew MacPherson17220c12014-03-05 10:12:43 +0000518}
519
Kate Stoneb9c1b512016-09-06 20:57:50 +0000520bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000521 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000522 JITLoaderCreateInstance create_callback,
523 DebuggerInitializeCallback debugger_init_callback) {
524 if (create_callback) {
525 JITLoaderInstance instance;
526 assert((bool)name);
527 instance.name = name;
528 if (description && description[0])
529 instance.description = description;
530 instance.create_callback = create_callback;
531 instance.debugger_init_callback = debugger_init_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000532 std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000533 GetJITLoaderInstances().push_back(instance);
534 }
535 return false;
536}
537
538bool PluginManager::UnregisterPlugin(JITLoaderCreateInstance create_callback) {
539 if (create_callback) {
540 std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
541 JITLoaderInstances &instances = GetJITLoaderInstances();
542
543 JITLoaderInstances::iterator pos, end = instances.end();
544 for (pos = instances.begin(); pos != end; ++pos) {
545 if (pos->create_callback == create_callback) {
546 instances.erase(pos);
547 return true;
548 }
549 }
550 }
551 return false;
Andrew MacPherson17220c12014-03-05 10:12:43 +0000552}
553
554JITLoaderCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000555PluginManager::GetJITLoaderCreateCallbackAtIndex(uint32_t idx) {
556 std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
557 JITLoaderInstances &instances = GetJITLoaderInstances();
558 if (idx < instances.size())
559 return instances[idx].create_callback;
560 return nullptr;
561}
562
563JITLoaderCreateInstance PluginManager::GetJITLoaderCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000564 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000565 if (name) {
566 std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
567 JITLoaderInstances &instances = GetJITLoaderInstances();
568
569 JITLoaderInstances::iterator pos, end = instances.end();
570 for (pos = instances.begin(); pos != end; ++pos) {
571 if (name == pos->name)
572 return pos->create_callback;
Andrew MacPherson17220c12014-03-05 10:12:43 +0000573 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000574 }
575 return nullptr;
Andrew MacPherson17220c12014-03-05 10:12:43 +0000576}
577
Greg Claytonf03bbe22011-02-01 01:37:45 +0000578#pragma mark EmulateInstruction
579
Kate Stoneb9c1b512016-09-06 20:57:50 +0000580struct EmulateInstructionInstance {
581 EmulateInstructionInstance()
582 : name(), description(), create_callback(nullptr) {}
583
584 ConstString name;
585 std::string description;
586 EmulateInstructionCreateInstance create_callback;
Greg Claytonf03bbe22011-02-01 01:37:45 +0000587};
588
589typedef std::vector<EmulateInstructionInstance> EmulateInstructionInstances;
590
Kate Stoneb9c1b512016-09-06 20:57:50 +0000591static std::recursive_mutex &GetEmulateInstructionMutex() {
592 static std::recursive_mutex g_instances_mutex;
593 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +0000594}
595
Kate Stoneb9c1b512016-09-06 20:57:50 +0000596static EmulateInstructionInstances &GetEmulateInstructionInstances() {
597 static EmulateInstructionInstances g_instances;
598 return g_instances;
Greg Claytonf03bbe22011-02-01 01:37:45 +0000599}
600
Kate Stoneb9c1b512016-09-06 20:57:50 +0000601bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000602 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000603 EmulateInstructionCreateInstance create_callback) {
604 if (create_callback) {
605 EmulateInstructionInstance instance;
606 assert((bool)name);
607 instance.name = name;
608 if (description && description[0])
609 instance.description = description;
610 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000611 std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000612 GetEmulateInstructionInstances().push_back(instance);
613 }
614 return false;
615}
616
617bool PluginManager::UnregisterPlugin(
618 EmulateInstructionCreateInstance create_callback) {
619 if (create_callback) {
620 std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
621 EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
622
623 EmulateInstructionInstances::iterator pos, end = instances.end();
624 for (pos = instances.begin(); pos != end; ++pos) {
625 if (pos->create_callback == create_callback) {
626 instances.erase(pos);
627 return true;
628 }
629 }
630 }
631 return false;
Greg Claytonf03bbe22011-02-01 01:37:45 +0000632}
633
634EmulateInstructionCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000635PluginManager::GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx) {
636 std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
637 EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
638 if (idx < instances.size())
639 return instances[idx].create_callback;
640 return nullptr;
641}
642
643EmulateInstructionCreateInstance
644PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000645 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000646 if (name) {
647 std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
648 EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
649
650 EmulateInstructionInstances::iterator pos, end = instances.end();
651 for (pos = instances.begin(); pos != end; ++pos) {
652 if (name == pos->name)
653 return pos->create_callback;
Greg Claytonf03bbe22011-02-01 01:37:45 +0000654 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000655 }
656 return nullptr;
Greg Claytonf03bbe22011-02-01 01:37:45 +0000657}
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000658
Eugene Zelenko89183722016-03-11 21:55:47 +0000659#pragma mark OperatingSystem
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000660
Kate Stoneb9c1b512016-09-06 20:57:50 +0000661struct OperatingSystemInstance {
662 OperatingSystemInstance()
663 : name(), description(), create_callback(nullptr),
664 debugger_init_callback(nullptr) {}
665
666 ConstString name;
667 std::string description;
668 OperatingSystemCreateInstance create_callback;
669 DebuggerInitializeCallback debugger_init_callback;
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000670};
671
672typedef std::vector<OperatingSystemInstance> OperatingSystemInstances;
673
Kate Stoneb9c1b512016-09-06 20:57:50 +0000674static std::recursive_mutex &GetOperatingSystemMutex() {
675 static std::recursive_mutex g_instances_mutex;
676 return g_instances_mutex;
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000677}
678
Kate Stoneb9c1b512016-09-06 20:57:50 +0000679static OperatingSystemInstances &GetOperatingSystemInstances() {
680 static OperatingSystemInstances g_instances;
681 return g_instances;
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000682}
683
Kate Stoneb9c1b512016-09-06 20:57:50 +0000684bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000685 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000686 OperatingSystemCreateInstance create_callback,
687 DebuggerInitializeCallback debugger_init_callback) {
688 if (create_callback) {
689 OperatingSystemInstance instance;
690 assert((bool)name);
691 instance.name = name;
692 if (description && description[0])
693 instance.description = description;
694 instance.create_callback = create_callback;
695 instance.debugger_init_callback = debugger_init_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000696 std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000697 GetOperatingSystemInstances().push_back(instance);
698 }
699 return false;
700}
701
702bool PluginManager::UnregisterPlugin(
703 OperatingSystemCreateInstance create_callback) {
704 if (create_callback) {
705 std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
706 OperatingSystemInstances &instances = GetOperatingSystemInstances();
707
708 OperatingSystemInstances::iterator pos, end = instances.end();
709 for (pos = instances.begin(); pos != end; ++pos) {
710 if (pos->create_callback == create_callback) {
711 instances.erase(pos);
712 return true;
713 }
714 }
715 }
716 return false;
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000717}
718
719OperatingSystemCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000720PluginManager::GetOperatingSystemCreateCallbackAtIndex(uint32_t idx) {
721 std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
722 OperatingSystemInstances &instances = GetOperatingSystemInstances();
723 if (idx < instances.size())
724 return instances[idx].create_callback;
725 return nullptr;
726}
727
728OperatingSystemCreateInstance
729PluginManager::GetOperatingSystemCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000730 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000731 if (name) {
732 std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
733 OperatingSystemInstances &instances = GetOperatingSystemInstances();
734
735 OperatingSystemInstances::iterator pos, end = instances.end();
736 for (pos = instances.begin(); pos != end; ++pos) {
737 if (name == pos->name)
738 return pos->create_callback;
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000739 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000740 }
741 return nullptr;
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000742}
Greg Claytonf03bbe22011-02-01 01:37:45 +0000743
Enrico Granata5f9d3102015-08-27 21:33:50 +0000744#pragma mark Language
745
Kate Stoneb9c1b512016-09-06 20:57:50 +0000746struct LanguageInstance {
747 LanguageInstance() : name(), description(), create_callback(nullptr) {}
748
749 ConstString name;
750 std::string description;
751 LanguageCreateInstance create_callback;
Enrico Granata5f9d3102015-08-27 21:33:50 +0000752};
753
754typedef std::vector<LanguageInstance> LanguageInstances;
755
Kate Stoneb9c1b512016-09-06 20:57:50 +0000756static std::recursive_mutex &GetLanguageMutex() {
757 static std::recursive_mutex g_instances_mutex;
758 return g_instances_mutex;
Enrico Granata5f9d3102015-08-27 21:33:50 +0000759}
760
Kate Stoneb9c1b512016-09-06 20:57:50 +0000761static LanguageInstances &GetLanguageInstances() {
762 static LanguageInstances g_instances;
763 return g_instances;
Enrico Granata5f9d3102015-08-27 21:33:50 +0000764}
765
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000766bool PluginManager::RegisterPlugin(ConstString name,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000767 const char *description,
768 LanguageCreateInstance create_callback) {
769 if (create_callback) {
770 LanguageInstance instance;
771 assert((bool)name);
772 instance.name = name;
773 if (description && description[0])
774 instance.description = description;
775 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000776 std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000777 GetLanguageInstances().push_back(instance);
778 }
779 return false;
780}
781
782bool PluginManager::UnregisterPlugin(LanguageCreateInstance create_callback) {
783 if (create_callback) {
784 std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
785 LanguageInstances &instances = GetLanguageInstances();
786
787 LanguageInstances::iterator pos, end = instances.end();
788 for (pos = instances.begin(); pos != end; ++pos) {
789 if (pos->create_callback == create_callback) {
790 instances.erase(pos);
791 return true;
792 }
793 }
794 }
795 return false;
Enrico Granata5f9d3102015-08-27 21:33:50 +0000796}
797
798LanguageCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000799PluginManager::GetLanguageCreateCallbackAtIndex(uint32_t idx) {
800 std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
801 LanguageInstances &instances = GetLanguageInstances();
802 if (idx < instances.size())
803 return instances[idx].create_callback;
804 return nullptr;
805}
806
807LanguageCreateInstance
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000808PluginManager::GetLanguageCreateCallbackForPluginName(ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000809 if (name) {
810 std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
811 LanguageInstances &instances = GetLanguageInstances();
812
813 LanguageInstances::iterator pos, end = instances.end();
814 for (pos = instances.begin(); pos != end; ++pos) {
815 if (name == pos->name)
816 return pos->create_callback;
Enrico Granata5f9d3102015-08-27 21:33:50 +0000817 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000818 }
819 return nullptr;
Enrico Granata5f9d3102015-08-27 21:33:50 +0000820}
821
Jim Ingham22777012010-09-23 02:01:19 +0000822#pragma mark LanguageRuntime
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000823
Kate Stoneb9c1b512016-09-06 20:57:50 +0000824struct LanguageRuntimeInstance {
825 LanguageRuntimeInstance() : name(), description(), create_callback(nullptr) {}
Jim Ingham22777012010-09-23 02:01:19 +0000826
Kate Stoneb9c1b512016-09-06 20:57:50 +0000827 ConstString name;
828 std::string description;
829 LanguageRuntimeCreateInstance create_callback;
830 LanguageRuntimeGetCommandObject command_callback;
Alex Langford7f9c9f22019-06-21 19:43:07 +0000831 LanguageRuntimeGetExceptionPrecondition precondition_callback;
Jim Ingham22777012010-09-23 02:01:19 +0000832};
833
834typedef std::vector<LanguageRuntimeInstance> LanguageRuntimeInstances;
835
Kate Stoneb9c1b512016-09-06 20:57:50 +0000836static std::recursive_mutex &GetLanguageRuntimeMutex() {
837 static std::recursive_mutex g_instances_mutex;
838 return g_instances_mutex;
Jim Ingham22777012010-09-23 02:01:19 +0000839}
840
Kate Stoneb9c1b512016-09-06 20:57:50 +0000841static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {
842 static LanguageRuntimeInstances g_instances;
843 return g_instances;
Greg Claytonab65b342011-04-13 22:47:15 +0000844}
Jim Ingham22777012010-09-23 02:01:19 +0000845
Kate Stoneb9c1b512016-09-06 20:57:50 +0000846bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000847 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000848 LanguageRuntimeCreateInstance create_callback,
Alex Langford7f9c9f22019-06-21 19:43:07 +0000849 LanguageRuntimeGetCommandObject command_callback,
850 LanguageRuntimeGetExceptionPrecondition precondition_callback) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000851 if (create_callback) {
852 LanguageRuntimeInstance instance;
853 assert((bool)name);
854 instance.name = name;
855 if (description && description[0])
856 instance.description = description;
857 instance.create_callback = create_callback;
858 instance.command_callback = command_callback;
Alex Langford7f9c9f22019-06-21 19:43:07 +0000859 instance.precondition_callback = precondition_callback;
Kate Stoneb9c1b512016-09-06 20:57:50 +0000860 std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
861 GetLanguageRuntimeInstances().push_back(instance);
862 }
863 return false;
864}
865
866bool PluginManager::UnregisterPlugin(
867 LanguageRuntimeCreateInstance create_callback) {
868 if (create_callback) {
869 std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
870 LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
871
872 LanguageRuntimeInstances::iterator pos, end = instances.end();
873 for (pos = instances.begin(); pos != end; ++pos) {
874 if (pos->create_callback == create_callback) {
875 instances.erase(pos);
876 return true;
877 }
Jim Ingham22777012010-09-23 02:01:19 +0000878 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000879 }
880 return false;
Jim Ingham22777012010-09-23 02:01:19 +0000881}
882
883LanguageRuntimeCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000884PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx) {
885 std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
886 LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
887 if (idx < instances.size())
888 return instances[idx].create_callback;
889 return nullptr;
Jim Ingham22777012010-09-23 02:01:19 +0000890}
891
Colin Rileyc9c55a22015-05-04 18:39:38 +0000892LanguageRuntimeGetCommandObject
Kate Stoneb9c1b512016-09-06 20:57:50 +0000893PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {
894 std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
895 LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
896 if (idx < instances.size())
897 return instances[idx].command_callback;
898 return nullptr;
Colin Rileyc9c55a22015-05-04 18:39:38 +0000899}
900
Alex Langford7f9c9f22019-06-21 19:43:07 +0000901LanguageRuntimeGetExceptionPrecondition
902PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx) {
903 std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
904 LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
905 if (idx < instances.size())
906 return instances[idx].precondition_callback;
907 return nullptr;
908}
909
Jim Ingham22777012010-09-23 02:01:19 +0000910LanguageRuntimeCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000911PluginManager::GetLanguageRuntimeCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000912 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000913 if (name) {
914 std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
915 LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
916
917 LanguageRuntimeInstances::iterator pos, end = instances.end();
918 for (pos = instances.begin(); pos != end; ++pos) {
919 if (name == pos->name)
920 return pos->create_callback;
Jim Ingham22777012010-09-23 02:01:19 +0000921 }
Kate Stoneb9c1b512016-09-06 20:57:50 +0000922 }
923 return nullptr;
Jim Ingham22777012010-09-23 02:01:19 +0000924}
925
Jason Molendaeef51062013-11-05 03:57:19 +0000926#pragma mark SystemRuntime
927
Kate Stoneb9c1b512016-09-06 20:57:50 +0000928struct SystemRuntimeInstance {
929 SystemRuntimeInstance() : name(), description(), create_callback(nullptr) {}
Jason Molendaeef51062013-11-05 03:57:19 +0000930
Kate Stoneb9c1b512016-09-06 20:57:50 +0000931 ConstString name;
932 std::string description;
933 SystemRuntimeCreateInstance create_callback;
Jason Molendaeef51062013-11-05 03:57:19 +0000934};
935
936typedef std::vector<SystemRuntimeInstance> SystemRuntimeInstances;
937
Kate Stoneb9c1b512016-09-06 20:57:50 +0000938static std::recursive_mutex &GetSystemRuntimeMutex() {
939 static std::recursive_mutex g_instances_mutex;
940 return g_instances_mutex;
Jason Molendaeef51062013-11-05 03:57:19 +0000941}
942
Kate Stoneb9c1b512016-09-06 20:57:50 +0000943static SystemRuntimeInstances &GetSystemRuntimeInstances() {
944 static SystemRuntimeInstances g_instances;
945 return g_instances;
Jason Molendaeef51062013-11-05 03:57:19 +0000946}
947
Kate Stoneb9c1b512016-09-06 20:57:50 +0000948bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000949 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +0000950 SystemRuntimeCreateInstance create_callback) {
951 if (create_callback) {
952 SystemRuntimeInstance instance;
953 assert((bool)name);
954 instance.name = name;
955 if (description && description[0])
956 instance.description = description;
957 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +0000958 std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +0000959 GetSystemRuntimeInstances().push_back(instance);
960 }
961 return false;
962}
963
964bool PluginManager::UnregisterPlugin(
965 SystemRuntimeCreateInstance create_callback) {
966 if (create_callback) {
967 std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
968 SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
969
970 SystemRuntimeInstances::iterator pos, end = instances.end();
971 for (pos = instances.begin(); pos != end; ++pos) {
972 if (pos->create_callback == create_callback) {
973 instances.erase(pos);
974 return true;
975 }
976 }
977 }
978 return false;
Jason Molendaeef51062013-11-05 03:57:19 +0000979}
980
981SystemRuntimeCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +0000982PluginManager::GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx) {
983 std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
984 SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
985 if (idx < instances.size())
986 return instances[idx].create_callback;
987 return nullptr;
988}
989
990SystemRuntimeCreateInstance
991PluginManager::GetSystemRuntimeCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +0000992 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +0000993 if (name) {
994 std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
995 SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
996
997 SystemRuntimeInstances::iterator pos, end = instances.end();
998 for (pos = instances.begin(); pos != end; ++pos) {
999 if (name == pos->name)
1000 return pos->create_callback;
Jason Molendaeef51062013-11-05 03:57:19 +00001001 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001002 }
1003 return nullptr;
Jason Molendaeef51062013-11-05 03:57:19 +00001004}
1005
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001006#pragma mark ObjectFile
1007
Kate Stoneb9c1b512016-09-06 20:57:50 +00001008struct ObjectFileInstance {
1009 ObjectFileInstance()
1010 : name(), description(), create_callback(nullptr),
1011 create_memory_callback(nullptr), get_module_specifications(nullptr),
1012 save_core(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001013
Kate Stoneb9c1b512016-09-06 20:57:50 +00001014 ConstString name;
1015 std::string description;
1016 ObjectFileCreateInstance create_callback;
1017 ObjectFileCreateMemoryInstance create_memory_callback;
1018 ObjectFileGetModuleSpecifications get_module_specifications;
1019 ObjectFileSaveCore save_core;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001020};
1021
1022typedef std::vector<ObjectFileInstance> ObjectFileInstances;
1023
Kate Stoneb9c1b512016-09-06 20:57:50 +00001024static std::recursive_mutex &GetObjectFileMutex() {
1025 static std::recursive_mutex g_instances_mutex;
1026 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +00001027}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001028
Kate Stoneb9c1b512016-09-06 20:57:50 +00001029static ObjectFileInstances &GetObjectFileInstances() {
1030 static ObjectFileInstances g_instances;
1031 return g_instances;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001032}
1033
Kate Stoneb9c1b512016-09-06 20:57:50 +00001034bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001035 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001036 ObjectFileCreateInstance create_callback,
1037 ObjectFileCreateMemoryInstance create_memory_callback,
1038 ObjectFileGetModuleSpecifications get_module_specifications,
1039 ObjectFileSaveCore save_core) {
1040 if (create_callback) {
1041 ObjectFileInstance instance;
1042 assert((bool)name);
1043 instance.name = name;
1044 if (description && description[0])
1045 instance.description = description;
1046 instance.create_callback = create_callback;
1047 instance.create_memory_callback = create_memory_callback;
1048 instance.save_core = save_core;
1049 instance.get_module_specifications = get_module_specifications;
1050 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1051 GetObjectFileInstances().push_back(instance);
1052 }
1053 return false;
1054}
1055
1056bool PluginManager::UnregisterPlugin(ObjectFileCreateInstance create_callback) {
1057 if (create_callback) {
1058 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1059 ObjectFileInstances &instances = GetObjectFileInstances();
1060
1061 ObjectFileInstances::iterator pos, end = instances.end();
1062 for (pos = instances.begin(); pos != end; ++pos) {
1063 if (pos->create_callback == create_callback) {
1064 instances.erase(pos);
1065 return true;
1066 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001067 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001068 }
1069 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001070}
1071
1072ObjectFileCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001073PluginManager::GetObjectFileCreateCallbackAtIndex(uint32_t idx) {
1074 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1075 ObjectFileInstances &instances = GetObjectFileInstances();
1076 if (idx < instances.size())
1077 return instances[idx].create_callback;
1078 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001079}
Greg Claytonab65b342011-04-13 22:47:15 +00001080
Greg Claytonc9660542012-02-05 02:38:54 +00001081ObjectFileCreateMemoryInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001082PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx) {
1083 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1084 ObjectFileInstances &instances = GetObjectFileInstances();
1085 if (idx < instances.size())
1086 return instances[idx].create_memory_callback;
1087 return nullptr;
Greg Claytonc9660542012-02-05 02:38:54 +00001088}
1089
Greg Claytonf4d6de62013-04-24 22:29:28 +00001090ObjectFileGetModuleSpecifications
Kate Stoneb9c1b512016-09-06 20:57:50 +00001091PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
1092 uint32_t idx) {
1093 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1094 ObjectFileInstances &instances = GetObjectFileInstances();
1095 if (idx < instances.size())
1096 return instances[idx].get_module_specifications;
1097 return nullptr;
Greg Claytonf4d6de62013-04-24 22:29:28 +00001098}
1099
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001100ObjectFileCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001101PluginManager::GetObjectFileCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001102 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001103 if (name) {
1104 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1105 ObjectFileInstances &instances = GetObjectFileInstances();
1106
1107 ObjectFileInstances::iterator pos, end = instances.end();
1108 for (pos = instances.begin(); pos != end; ++pos) {
1109 if (name == pos->name)
1110 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001111 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001112 }
1113 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001114}
1115
Greg Claytonc9660542012-02-05 02:38:54 +00001116ObjectFileCreateMemoryInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001117PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001118 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001119 if (name) {
1120 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1121 ObjectFileInstances &instances = GetObjectFileInstances();
1122
1123 ObjectFileInstances::iterator pos, end = instances.end();
1124 for (pos = instances.begin(); pos != end; ++pos) {
1125 if (name == pos->name)
1126 return pos->create_memory_callback;
Greg Claytonc9660542012-02-05 02:38:54 +00001127 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001128 }
1129 return nullptr;
Greg Claytonc9660542012-02-05 02:38:54 +00001130}
1131
Zachary Turner97206d52017-05-12 04:51:55 +00001132Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
1133 const FileSpec &outfile) {
1134 Status error;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001135 std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
1136 ObjectFileInstances &instances = GetObjectFileInstances();
1137
1138 ObjectFileInstances::iterator pos, end = instances.end();
1139 for (pos = instances.begin(); pos != end; ++pos) {
1140 if (pos->save_core && pos->save_core(process_sp, outfile, error))
1141 return error;
1142 }
1143 error.SetErrorString(
1144 "no ObjectFile plugins were able to save a core for this process");
1145 return error;
Greg Claytona2715cf2014-06-13 00:54:12 +00001146}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001147
1148#pragma mark ObjectContainer
1149
Kate Stoneb9c1b512016-09-06 20:57:50 +00001150struct ObjectContainerInstance {
1151 ObjectContainerInstance()
1152 : name(), description(), create_callback(nullptr),
1153 get_module_specifications(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001154
Kate Stoneb9c1b512016-09-06 20:57:50 +00001155 ConstString name;
1156 std::string description;
1157 ObjectContainerCreateInstance create_callback;
1158 ObjectFileGetModuleSpecifications get_module_specifications;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001159};
1160
1161typedef std::vector<ObjectContainerInstance> ObjectContainerInstances;
1162
Kate Stoneb9c1b512016-09-06 20:57:50 +00001163static std::recursive_mutex &GetObjectContainerMutex() {
1164 static std::recursive_mutex g_instances_mutex;
1165 return g_instances_mutex;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001166}
1167
Kate Stoneb9c1b512016-09-06 20:57:50 +00001168static ObjectContainerInstances &GetObjectContainerInstances() {
1169 static ObjectContainerInstances g_instances;
1170 return g_instances;
Greg Claytonab65b342011-04-13 22:47:15 +00001171}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001172
Kate Stoneb9c1b512016-09-06 20:57:50 +00001173bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001174 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001175 ObjectContainerCreateInstance create_callback,
1176 ObjectFileGetModuleSpecifications get_module_specifications) {
1177 if (create_callback) {
1178 ObjectContainerInstance instance;
1179 assert((bool)name);
1180 instance.name = name;
1181 if (description && description[0])
1182 instance.description = description;
1183 instance.create_callback = create_callback;
1184 instance.get_module_specifications = get_module_specifications;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001185 std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001186 GetObjectContainerInstances().push_back(instance);
1187 }
1188 return false;
1189}
1190
1191bool PluginManager::UnregisterPlugin(
1192 ObjectContainerCreateInstance create_callback) {
1193 if (create_callback) {
1194 std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1195 ObjectContainerInstances &instances = GetObjectContainerInstances();
1196
1197 ObjectContainerInstances::iterator pos, end = instances.end();
1198 for (pos = instances.begin(); pos != end; ++pos) {
1199 if (pos->create_callback == create_callback) {
1200 instances.erase(pos);
1201 return true;
1202 }
1203 }
1204 }
1205 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001206}
Greg Claytonab65b342011-04-13 22:47:15 +00001207
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001208ObjectContainerCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001209PluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {
1210 std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1211 ObjectContainerInstances &instances = GetObjectContainerInstances();
1212 if (idx < instances.size())
1213 return instances[idx].create_callback;
1214 return nullptr;
1215}
1216
1217ObjectContainerCreateInstance
1218PluginManager::GetObjectContainerCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001219 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001220 if (name) {
1221 std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1222 ObjectContainerInstances &instances = GetObjectContainerInstances();
1223
1224 ObjectContainerInstances::iterator pos, end = instances.end();
1225 for (pos = instances.begin(); pos != end; ++pos) {
1226 if (name == pos->name)
1227 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001228 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001229 }
1230 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001231}
1232
Greg Claytonf4d6de62013-04-24 22:29:28 +00001233ObjectFileGetModuleSpecifications
Kate Stoneb9c1b512016-09-06 20:57:50 +00001234PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(
1235 uint32_t idx) {
1236 std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
1237 ObjectContainerInstances &instances = GetObjectContainerInstances();
1238 if (idx < instances.size())
1239 return instances[idx].get_module_specifications;
1240 return nullptr;
Greg Claytonf4d6de62013-04-24 22:29:28 +00001241}
1242
Greg Claytone996fd32011-03-08 22:40:15 +00001243#pragma mark Platform
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001244
Kate Stoneb9c1b512016-09-06 20:57:50 +00001245struct PlatformInstance {
1246 PlatformInstance()
1247 : name(), description(), create_callback(nullptr),
1248 debugger_init_callback(nullptr) {}
1249
1250 ConstString name;
1251 std::string description;
1252 PlatformCreateInstance create_callback;
1253 DebuggerInitializeCallback debugger_init_callback;
Greg Claytone996fd32011-03-08 22:40:15 +00001254};
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001255
Greg Claytone996fd32011-03-08 22:40:15 +00001256typedef std::vector<PlatformInstance> PlatformInstances;
1257
Kate Stoneb9c1b512016-09-06 20:57:50 +00001258static std::recursive_mutex &GetPlatformInstancesMutex() {
1259 static std::recursive_mutex g_platform_instances_mutex;
1260 return g_platform_instances_mutex;
Greg Claytone996fd32011-03-08 22:40:15 +00001261}
1262
Kate Stoneb9c1b512016-09-06 20:57:50 +00001263static PlatformInstances &GetPlatformInstances() {
1264 static PlatformInstances g_platform_instances;
1265 return g_platform_instances;
Greg Claytonded470d2011-03-19 01:12:21 +00001266}
Greg Claytone996fd32011-03-08 22:40:15 +00001267
Kate Stoneb9c1b512016-09-06 20:57:50 +00001268bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001269 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001270 PlatformCreateInstance create_callback,
1271 DebuggerInitializeCallback debugger_init_callback) {
1272 if (create_callback) {
1273 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001274
Kate Stoneb9c1b512016-09-06 20:57:50 +00001275 PlatformInstance instance;
1276 assert((bool)name);
1277 instance.name = name;
1278 if (description && description[0])
1279 instance.description = description;
1280 instance.create_callback = create_callback;
1281 instance.debugger_init_callback = debugger_init_callback;
1282 GetPlatformInstances().push_back(instance);
1283 return true;
1284 }
1285 return false;
1286}
1287
1288const char *PluginManager::GetPlatformPluginNameAtIndex(uint32_t idx) {
1289 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1290 PlatformInstances &instances = GetPlatformInstances();
1291 if (idx < instances.size())
1292 return instances[idx].name.GetCString();
1293 return nullptr;
1294}
1295
1296const char *PluginManager::GetPlatformPluginDescriptionAtIndex(uint32_t idx) {
1297 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1298 PlatformInstances &instances = GetPlatformInstances();
1299 if (idx < instances.size())
1300 return instances[idx].description.c_str();
1301 return nullptr;
1302}
1303
1304bool PluginManager::UnregisterPlugin(PlatformCreateInstance create_callback) {
1305 if (create_callback) {
1306 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1307 PlatformInstances &instances = GetPlatformInstances();
1308
1309 PlatformInstances::iterator pos, end = instances.end();
1310 for (pos = instances.begin(); pos != end; ++pos) {
1311 if (pos->create_callback == create_callback) {
1312 instances.erase(pos);
Greg Claytonded470d2011-03-19 01:12:21 +00001313 return true;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001314 }
Greg Claytone996fd32011-03-08 22:40:15 +00001315 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001316 }
1317 return false;
Greg Claytone996fd32011-03-08 22:40:15 +00001318}
1319
1320PlatformCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001321PluginManager::GetPlatformCreateCallbackAtIndex(uint32_t idx) {
1322 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1323 PlatformInstances &instances = GetPlatformInstances();
1324 if (idx < instances.size())
1325 return instances[idx].create_callback;
1326 return nullptr;
Greg Claytone996fd32011-03-08 22:40:15 +00001327}
1328
1329PlatformCreateInstance
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001330PluginManager::GetPlatformCreateCallbackForPluginName(ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001331 if (name) {
1332 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1333 PlatformInstances &instances = GetPlatformInstances();
Greg Claytonded470d2011-03-19 01:12:21 +00001334
Kate Stoneb9c1b512016-09-06 20:57:50 +00001335 PlatformInstances::iterator pos, end = instances.end();
1336 for (pos = instances.begin(); pos != end; ++pos) {
1337 if (name == pos->name)
1338 return pos->create_callback;
Greg Claytone996fd32011-03-08 22:40:15 +00001339 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001340 }
1341 return nullptr;
Greg Claytone996fd32011-03-08 22:40:15 +00001342}
1343
Raphael Isemannae34ed22019-08-22 07:41:23 +00001344void PluginManager::AutoCompletePlatformName(llvm::StringRef name,
1345 CompletionRequest &request) {
Zachary Turner4aa87532016-11-17 01:37:42 +00001346 if (name.empty())
Raphael Isemannae34ed22019-08-22 07:41:23 +00001347 return;
Greg Claytonab65b342011-04-13 22:47:15 +00001348
Zachary Turner4aa87532016-11-17 01:37:42 +00001349 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
1350 PlatformInstances &instances = GetPlatformInstances();
1351 llvm::StringRef name_sref(name);
1352
1353 PlatformInstances::iterator pos, end = instances.end();
1354 for (pos = instances.begin(); pos != end; ++pos) {
1355 llvm::StringRef plugin_name(pos->name.GetCString());
1356 if (plugin_name.startswith(name_sref))
Raphael Isemannae34ed22019-08-22 07:41:23 +00001357 request.AddCompletion(plugin_name.data());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001358 }
Greg Claytonab65b342011-04-13 22:47:15 +00001359}
Eugene Zelenko89183722016-03-11 21:55:47 +00001360
Greg Claytone996fd32011-03-08 22:40:15 +00001361#pragma mark Process
1362
Kate Stoneb9c1b512016-09-06 20:57:50 +00001363struct ProcessInstance {
1364 ProcessInstance()
1365 : name(), description(), create_callback(nullptr),
1366 debugger_init_callback(nullptr) {}
1367
1368 ConstString name;
1369 std::string description;
1370 ProcessCreateInstance create_callback;
1371 DebuggerInitializeCallback debugger_init_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001372};
1373
1374typedef std::vector<ProcessInstance> ProcessInstances;
1375
Kate Stoneb9c1b512016-09-06 20:57:50 +00001376static std::recursive_mutex &GetProcessMutex() {
1377 static std::recursive_mutex g_instances_mutex;
1378 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +00001379}
1380
Kate Stoneb9c1b512016-09-06 20:57:50 +00001381static ProcessInstances &GetProcessInstances() {
1382 static ProcessInstances g_instances;
1383 return g_instances;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001384}
1385
Kate Stoneb9c1b512016-09-06 20:57:50 +00001386bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001387 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001388 ProcessCreateInstance create_callback,
1389 DebuggerInitializeCallback debugger_init_callback) {
1390 if (create_callback) {
1391 ProcessInstance instance;
1392 assert((bool)name);
1393 instance.name = name;
1394 if (description && description[0])
1395 instance.description = description;
1396 instance.create_callback = create_callback;
1397 instance.debugger_init_callback = debugger_init_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001398 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001399 GetProcessInstances().push_back(instance);
1400 }
1401 return false;
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00001402}
1403
Kate Stoneb9c1b512016-09-06 20:57:50 +00001404const char *PluginManager::GetProcessPluginNameAtIndex(uint32_t idx) {
1405 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1406 ProcessInstances &instances = GetProcessInstances();
1407 if (idx < instances.size())
1408 return instances[idx].name.GetCString();
1409 return nullptr;
1410}
1411
1412const char *PluginManager::GetProcessPluginDescriptionAtIndex(uint32_t idx) {
1413 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1414 ProcessInstances &instances = GetProcessInstances();
1415 if (idx < instances.size())
1416 return instances[idx].description.c_str();
1417 return nullptr;
1418}
1419
1420bool PluginManager::UnregisterPlugin(ProcessCreateInstance create_callback) {
1421 if (create_callback) {
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001422 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001423 ProcessInstances &instances = GetProcessInstances();
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00001424
Kate Stoneb9c1b512016-09-06 20:57:50 +00001425 ProcessInstances::iterator pos, end = instances.end();
1426 for (pos = instances.begin(); pos != end; ++pos) {
1427 if (pos->create_callback == create_callback) {
1428 instances.erase(pos);
1429 return true;
1430 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001431 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001432 }
1433 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001434}
1435
1436ProcessCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001437PluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {
1438 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1439 ProcessInstances &instances = GetProcessInstances();
1440 if (idx < instances.size())
1441 return instances[idx].create_callback;
1442 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001443}
1444
1445ProcessCreateInstance
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001446PluginManager::GetProcessCreateCallbackForPluginName(ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001447 if (name) {
1448 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
1449 ProcessInstances &instances = GetProcessInstances();
1450
1451 ProcessInstances::iterator pos, end = instances.end();
1452 for (pos = instances.begin(); pos != end; ++pos) {
1453 if (name == pos->name)
1454 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001455 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001456 }
1457 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001458}
1459
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001460#pragma mark ScriptInterpreter
1461
Kate Stoneb9c1b512016-09-06 20:57:50 +00001462struct ScriptInterpreterInstance {
1463 ScriptInterpreterInstance()
1464 : name(), language(lldb::eScriptLanguageNone), description(),
1465 create_callback(nullptr) {}
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001466
Kate Stoneb9c1b512016-09-06 20:57:50 +00001467 ConstString name;
1468 lldb::ScriptLanguage language;
1469 std::string description;
1470 ScriptInterpreterCreateInstance create_callback;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001471};
1472
1473typedef std::vector<ScriptInterpreterInstance> ScriptInterpreterInstances;
1474
Kate Stoneb9c1b512016-09-06 20:57:50 +00001475static std::recursive_mutex &GetScriptInterpreterMutex() {
1476 static std::recursive_mutex g_instances_mutex;
1477 return g_instances_mutex;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001478}
1479
Kate Stoneb9c1b512016-09-06 20:57:50 +00001480static ScriptInterpreterInstances &GetScriptInterpreterInstances() {
1481 static ScriptInterpreterInstances g_instances;
1482 return g_instances;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001483}
1484
Kate Stoneb9c1b512016-09-06 20:57:50 +00001485bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001486 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001487 lldb::ScriptLanguage script_language,
1488 ScriptInterpreterCreateInstance create_callback) {
1489 if (!create_callback)
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001490 return false;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001491 ScriptInterpreterInstance instance;
1492 assert((bool)name);
1493 instance.name = name;
1494 if (description && description[0])
1495 instance.description = description;
1496 instance.create_callback = create_callback;
1497 instance.language = script_language;
1498 std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1499 GetScriptInterpreterInstances().push_back(instance);
1500 return false;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001501}
1502
Kate Stoneb9c1b512016-09-06 20:57:50 +00001503bool PluginManager::UnregisterPlugin(
1504 ScriptInterpreterCreateInstance create_callback) {
1505 if (!create_callback)
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001506 return false;
Kate Stoneb9c1b512016-09-06 20:57:50 +00001507 std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1508 ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
1509
1510 ScriptInterpreterInstances::iterator pos, end = instances.end();
1511 for (pos = instances.begin(); pos != end; ++pos) {
1512 if (pos->create_callback != create_callback)
1513 continue;
1514
1515 instances.erase(pos);
1516 return true;
1517 }
1518 return false;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001519}
1520
1521ScriptInterpreterCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001522PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx) {
1523 std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1524 ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
1525 if (idx < instances.size())
1526 return instances[idx].create_callback;
1527 return nullptr;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001528}
1529
Jonas Devlieghere8d1fb842019-04-26 17:58:19 +00001530lldb::ScriptInterpreterSP
1531PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang,
1532 Debugger &debugger) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001533 std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
1534 ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001535
Kate Stoneb9c1b512016-09-06 20:57:50 +00001536 ScriptInterpreterInstances::iterator pos, end = instances.end();
1537 ScriptInterpreterCreateInstance none_instance = nullptr;
1538 for (pos = instances.begin(); pos != end; ++pos) {
1539 if (pos->language == lldb::eScriptLanguageNone)
1540 none_instance = pos->create_callback;
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001541
Kate Stoneb9c1b512016-09-06 20:57:50 +00001542 if (script_lang == pos->language)
Jonas Devlieghere8d1fb842019-04-26 17:58:19 +00001543 return pos->create_callback(debugger);
Kate Stoneb9c1b512016-09-06 20:57:50 +00001544 }
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001545
Kate Stoneb9c1b512016-09-06 20:57:50 +00001546 // If we didn't find one, return the ScriptInterpreter for the null language.
1547 assert(none_instance != nullptr);
Jonas Devlieghere8d1fb842019-04-26 17:58:19 +00001548 return none_instance(debugger);
Zachary Turner2c1f46d2015-07-30 20:28:07 +00001549}
1550
Todd Fiala75930012016-08-19 04:21:48 +00001551#pragma mark -
1552#pragma mark StructuredDataPlugin
1553
Todd Fiala75930012016-08-19 04:21:48 +00001554// StructuredDataPlugin
Todd Fiala75930012016-08-19 04:21:48 +00001555
Kate Stoneb9c1b512016-09-06 20:57:50 +00001556struct StructuredDataPluginInstance {
1557 StructuredDataPluginInstance()
1558 : name(), description(), create_callback(nullptr),
1559 debugger_init_callback(nullptr), filter_callback(nullptr) {}
Todd Fiala75930012016-08-19 04:21:48 +00001560
Kate Stoneb9c1b512016-09-06 20:57:50 +00001561 ConstString name;
1562 std::string description;
1563 StructuredDataPluginCreateInstance create_callback;
1564 DebuggerInitializeCallback debugger_init_callback;
1565 StructuredDataFilterLaunchInfo filter_callback;
Todd Fiala75930012016-08-19 04:21:48 +00001566};
1567
1568typedef std::vector<StructuredDataPluginInstance> StructuredDataPluginInstances;
1569
Kate Stoneb9c1b512016-09-06 20:57:50 +00001570static std::recursive_mutex &GetStructuredDataPluginMutex() {
1571 static std::recursive_mutex g_instances_mutex;
1572 return g_instances_mutex;
Todd Fiala75930012016-08-19 04:21:48 +00001573}
1574
Kate Stoneb9c1b512016-09-06 20:57:50 +00001575static StructuredDataPluginInstances &GetStructuredDataPluginInstances() {
1576 static StructuredDataPluginInstances g_instances;
1577 return g_instances;
Todd Fiala75930012016-08-19 04:21:48 +00001578}
1579
Kate Stoneb9c1b512016-09-06 20:57:50 +00001580bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001581 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001582 StructuredDataPluginCreateInstance create_callback,
1583 DebuggerInitializeCallback debugger_init_callback,
1584 StructuredDataFilterLaunchInfo filter_callback) {
1585 if (create_callback) {
1586 StructuredDataPluginInstance instance;
1587 assert((bool)name);
1588 instance.name = name;
1589 if (description && description[0])
1590 instance.description = description;
1591 instance.create_callback = create_callback;
1592 instance.debugger_init_callback = debugger_init_callback;
1593 instance.filter_callback = filter_callback;
1594 std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1595 GetStructuredDataPluginInstances().push_back(instance);
1596 }
1597 return false;
Todd Fiala75930012016-08-19 04:21:48 +00001598}
1599
Kate Stoneb9c1b512016-09-06 20:57:50 +00001600bool PluginManager::UnregisterPlugin(
1601 StructuredDataPluginCreateInstance create_callback) {
1602 if (create_callback) {
Todd Fiala75930012016-08-19 04:21:48 +00001603 std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1604 StructuredDataPluginInstances &instances =
1605 GetStructuredDataPluginInstances();
Kate Stoneb9c1b512016-09-06 20:57:50 +00001606
1607 StructuredDataPluginInstances::iterator pos, end = instances.end();
1608 for (pos = instances.begin(); pos != end; ++pos) {
1609 if (pos->create_callback == create_callback) {
1610 instances.erase(pos);
1611 return true;
1612 }
1613 }
1614 }
1615 return false;
1616}
1617
1618StructuredDataPluginCreateInstance
1619PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx) {
1620 std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1621 StructuredDataPluginInstances &instances = GetStructuredDataPluginInstances();
1622 if (idx < instances.size())
1623 return instances[idx].create_callback;
1624 return nullptr;
Todd Fiala75930012016-08-19 04:21:48 +00001625}
1626
1627StructuredDataPluginCreateInstance
1628PluginManager::GetStructuredDataPluginCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001629 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001630 if (name) {
Todd Fiala75930012016-08-19 04:21:48 +00001631 std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1632 StructuredDataPluginInstances &instances =
1633 GetStructuredDataPluginInstances();
Kate Stoneb9c1b512016-09-06 20:57:50 +00001634
1635 StructuredDataPluginInstances::iterator pos, end = instances.end();
1636 for (pos = instances.begin(); pos != end; ++pos) {
1637 if (name == pos->name)
1638 return pos->create_callback;
Todd Fiala75930012016-08-19 04:21:48 +00001639 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001640 }
1641 return nullptr;
1642}
1643
1644StructuredDataFilterLaunchInfo
1645PluginManager::GetStructuredDataFilterCallbackAtIndex(
1646 uint32_t idx, bool &iteration_complete) {
1647 std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
1648 StructuredDataPluginInstances &instances = GetStructuredDataPluginInstances();
1649 if (idx < instances.size()) {
1650 iteration_complete = false;
1651 return instances[idx].filter_callback;
1652 } else {
1653 iteration_complete = true;
1654 }
1655 return nullptr;
Todd Fiala75930012016-08-19 04:21:48 +00001656}
1657
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001658#pragma mark SymbolFile
1659
Kate Stoneb9c1b512016-09-06 20:57:50 +00001660struct SymbolFileInstance {
1661 SymbolFileInstance()
1662 : name(), description(), create_callback(nullptr),
1663 debugger_init_callback(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001664
Kate Stoneb9c1b512016-09-06 20:57:50 +00001665 ConstString name;
1666 std::string description;
1667 SymbolFileCreateInstance create_callback;
1668 DebuggerInitializeCallback debugger_init_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001669};
1670
1671typedef std::vector<SymbolFileInstance> SymbolFileInstances;
1672
Kate Stoneb9c1b512016-09-06 20:57:50 +00001673static std::recursive_mutex &GetSymbolFileMutex() {
1674 static std::recursive_mutex g_instances_mutex;
1675 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +00001676}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001677
Kate Stoneb9c1b512016-09-06 20:57:50 +00001678static SymbolFileInstances &GetSymbolFileInstances() {
1679 static SymbolFileInstances g_instances;
1680 return g_instances;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001681}
1682
Kate Stoneb9c1b512016-09-06 20:57:50 +00001683bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001684 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001685 SymbolFileCreateInstance create_callback,
1686 DebuggerInitializeCallback debugger_init_callback) {
1687 if (create_callback) {
1688 SymbolFileInstance instance;
1689 assert((bool)name);
1690 instance.name = name;
1691 if (description && description[0])
1692 instance.description = description;
1693 instance.create_callback = create_callback;
1694 instance.debugger_init_callback = debugger_init_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001695 std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001696 GetSymbolFileInstances().push_back(instance);
1697 }
1698 return false;
1699}
1700
1701bool PluginManager::UnregisterPlugin(SymbolFileCreateInstance create_callback) {
1702 if (create_callback) {
1703 std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1704 SymbolFileInstances &instances = GetSymbolFileInstances();
1705
1706 SymbolFileInstances::iterator pos, end = instances.end();
1707 for (pos = instances.begin(); pos != end; ++pos) {
1708 if (pos->create_callback == create_callback) {
1709 instances.erase(pos);
1710 return true;
1711 }
1712 }
1713 }
1714 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001715}
Greg Claytonab65b342011-04-13 22:47:15 +00001716
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001717SymbolFileCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001718PluginManager::GetSymbolFileCreateCallbackAtIndex(uint32_t idx) {
1719 std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1720 SymbolFileInstances &instances = GetSymbolFileInstances();
1721 if (idx < instances.size())
1722 return instances[idx].create_callback;
1723 return nullptr;
1724}
1725
1726SymbolFileCreateInstance
1727PluginManager::GetSymbolFileCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001728 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001729 if (name) {
1730 std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
1731 SymbolFileInstances &instances = GetSymbolFileInstances();
1732
1733 SymbolFileInstances::iterator pos, end = instances.end();
1734 for (pos = instances.begin(); pos != end; ++pos) {
1735 if (name == pos->name)
1736 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001737 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001738 }
1739 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001740}
1741
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001742#pragma mark SymbolVendor
1743
Kate Stoneb9c1b512016-09-06 20:57:50 +00001744struct SymbolVendorInstance {
1745 SymbolVendorInstance() : name(), description(), create_callback(nullptr) {}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001746
Kate Stoneb9c1b512016-09-06 20:57:50 +00001747 ConstString name;
1748 std::string description;
1749 SymbolVendorCreateInstance create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001750};
1751
1752typedef std::vector<SymbolVendorInstance> SymbolVendorInstances;
1753
Kate Stoneb9c1b512016-09-06 20:57:50 +00001754static std::recursive_mutex &GetSymbolVendorMutex() {
1755 static std::recursive_mutex g_instances_mutex;
1756 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +00001757}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001758
Kate Stoneb9c1b512016-09-06 20:57:50 +00001759static SymbolVendorInstances &GetSymbolVendorInstances() {
1760 static SymbolVendorInstances g_instances;
1761 return g_instances;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001762}
1763
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001764bool PluginManager::RegisterPlugin(ConstString name,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001765 const char *description,
1766 SymbolVendorCreateInstance create_callback) {
1767 if (create_callback) {
1768 SymbolVendorInstance instance;
1769 assert((bool)name);
1770 instance.name = name;
1771 if (description && description[0])
1772 instance.description = description;
1773 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001774 std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001775 GetSymbolVendorInstances().push_back(instance);
1776 }
1777 return false;
1778}
1779
1780bool PluginManager::UnregisterPlugin(
1781 SymbolVendorCreateInstance create_callback) {
1782 if (create_callback) {
1783 std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1784 SymbolVendorInstances &instances = GetSymbolVendorInstances();
1785
1786 SymbolVendorInstances::iterator pos, end = instances.end();
1787 for (pos = instances.begin(); pos != end; ++pos) {
1788 if (pos->create_callback == create_callback) {
1789 instances.erase(pos);
1790 return true;
1791 }
1792 }
1793 }
1794 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001795}
1796
1797SymbolVendorCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001798PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
1799 std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1800 SymbolVendorInstances &instances = GetSymbolVendorInstances();
1801 if (idx < instances.size())
1802 return instances[idx].create_callback;
1803 return nullptr;
1804}
1805
1806SymbolVendorCreateInstance
1807PluginManager::GetSymbolVendorCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001808 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001809 if (name) {
1810 std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
1811 SymbolVendorInstances &instances = GetSymbolVendorInstances();
1812
1813 SymbolVendorInstances::iterator pos, end = instances.end();
1814 for (pos = instances.begin(); pos != end; ++pos) {
1815 if (name == pos->name)
1816 return pos->create_callback;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001817 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001818 }
1819 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001820}
1821
Greg Clayton7be25422011-04-25 21:14:26 +00001822#pragma mark UnwindAssembly
Jason Molendafbcb7f22010-09-10 07:49:16 +00001823
Kate Stoneb9c1b512016-09-06 20:57:50 +00001824struct UnwindAssemblyInstance {
1825 UnwindAssemblyInstance() : name(), description(), create_callback(nullptr) {}
Jason Molendafbcb7f22010-09-10 07:49:16 +00001826
Kate Stoneb9c1b512016-09-06 20:57:50 +00001827 ConstString name;
1828 std::string description;
1829 UnwindAssemblyCreateInstance create_callback;
Jason Molendafbcb7f22010-09-10 07:49:16 +00001830};
1831
Greg Clayton7be25422011-04-25 21:14:26 +00001832typedef std::vector<UnwindAssemblyInstance> UnwindAssemblyInstances;
Jason Molendafbcb7f22010-09-10 07:49:16 +00001833
Kate Stoneb9c1b512016-09-06 20:57:50 +00001834static std::recursive_mutex &GetUnwindAssemblyMutex() {
1835 static std::recursive_mutex g_instances_mutex;
1836 return g_instances_mutex;
Greg Claytonab65b342011-04-13 22:47:15 +00001837}
Jason Molendafbcb7f22010-09-10 07:49:16 +00001838
Kate Stoneb9c1b512016-09-06 20:57:50 +00001839static UnwindAssemblyInstances &GetUnwindAssemblyInstances() {
1840 static UnwindAssemblyInstances g_instances;
1841 return g_instances;
Jason Molendafbcb7f22010-09-10 07:49:16 +00001842}
1843
Kate Stoneb9c1b512016-09-06 20:57:50 +00001844bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001845 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001846 UnwindAssemblyCreateInstance create_callback) {
1847 if (create_callback) {
1848 UnwindAssemblyInstance instance;
1849 assert((bool)name);
1850 instance.name = name;
1851 if (description && description[0])
1852 instance.description = description;
1853 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001854 std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001855 GetUnwindAssemblyInstances().push_back(instance);
1856 }
1857 return false;
1858}
1859
1860bool PluginManager::UnregisterPlugin(
1861 UnwindAssemblyCreateInstance create_callback) {
1862 if (create_callback) {
1863 std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1864 UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
1865
1866 UnwindAssemblyInstances::iterator pos, end = instances.end();
1867 for (pos = instances.begin(); pos != end; ++pos) {
1868 if (pos->create_callback == create_callback) {
1869 instances.erase(pos);
1870 return true;
1871 }
1872 }
1873 }
1874 return false;
Jason Molendafbcb7f22010-09-10 07:49:16 +00001875}
1876
Greg Clayton7be25422011-04-25 21:14:26 +00001877UnwindAssemblyCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001878PluginManager::GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx) {
1879 std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1880 UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
1881 if (idx < instances.size())
1882 return instances[idx].create_callback;
1883 return nullptr;
1884}
1885
1886UnwindAssemblyCreateInstance
1887PluginManager::GetUnwindAssemblyCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001888 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001889 if (name) {
1890 std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
1891 UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
1892
1893 UnwindAssemblyInstances::iterator pos, end = instances.end();
1894 for (pos = instances.begin(); pos != end; ++pos) {
1895 if (name == pos->name)
1896 return pos->create_callback;
Jason Molendafbcb7f22010-09-10 07:49:16 +00001897 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001898 }
1899 return nullptr;
Jason Molendafbcb7f22010-09-10 07:49:16 +00001900}
1901
Kuba Breckabeed8212014-09-04 01:03:18 +00001902#pragma mark MemoryHistory
1903
Kate Stoneb9c1b512016-09-06 20:57:50 +00001904struct MemoryHistoryInstance {
1905 MemoryHistoryInstance() : name(), description(), create_callback(nullptr) {}
1906
1907 ConstString name;
1908 std::string description;
1909 MemoryHistoryCreateInstance create_callback;
Kuba Breckabeed8212014-09-04 01:03:18 +00001910};
1911
1912typedef std::vector<MemoryHistoryInstance> MemoryHistoryInstances;
1913
Kate Stoneb9c1b512016-09-06 20:57:50 +00001914static std::recursive_mutex &GetMemoryHistoryMutex() {
1915 static std::recursive_mutex g_instances_mutex;
1916 return g_instances_mutex;
Kuba Breckabeed8212014-09-04 01:03:18 +00001917}
1918
Kate Stoneb9c1b512016-09-06 20:57:50 +00001919static MemoryHistoryInstances &GetMemoryHistoryInstances() {
1920 static MemoryHistoryInstances g_instances;
1921 return g_instances;
Kuba Breckabeed8212014-09-04 01:03:18 +00001922}
1923
Kate Stoneb9c1b512016-09-06 20:57:50 +00001924bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001925 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00001926 MemoryHistoryCreateInstance create_callback) {
1927 if (create_callback) {
1928 MemoryHistoryInstance instance;
1929 assert((bool)name);
1930 instance.name = name;
1931 if (description && description[0])
1932 instance.description = description;
1933 instance.create_callback = create_callback;
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001934 std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00001935 GetMemoryHistoryInstances().push_back(instance);
1936 }
1937 return false;
1938}
1939
1940bool PluginManager::UnregisterPlugin(
1941 MemoryHistoryCreateInstance create_callback) {
1942 if (create_callback) {
1943 std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1944 MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
1945
1946 MemoryHistoryInstances::iterator pos, end = instances.end();
1947 for (pos = instances.begin(); pos != end; ++pos) {
1948 if (pos->create_callback == create_callback) {
1949 instances.erase(pos);
1950 return true;
1951 }
1952 }
1953 }
1954 return false;
Kuba Breckabeed8212014-09-04 01:03:18 +00001955}
1956
Kuba Breckabeed8212014-09-04 01:03:18 +00001957MemoryHistoryCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00001958PluginManager::GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx) {
1959 std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1960 MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
1961 if (idx < instances.size())
1962 return instances[idx].create_callback;
1963 return nullptr;
1964}
1965
1966MemoryHistoryCreateInstance
1967PluginManager::GetMemoryHistoryCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00001968 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00001969 if (name) {
1970 std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
1971 MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
1972
1973 MemoryHistoryInstances::iterator pos, end = instances.end();
1974 for (pos = instances.begin(); pos != end; ++pos) {
1975 if (name == pos->name)
1976 return pos->create_callback;
Kuba Breckabeed8212014-09-04 01:03:18 +00001977 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00001978 }
1979 return nullptr;
Kuba Breckabeed8212014-09-04 01:03:18 +00001980}
1981
Kuba Breckaafdf8422014-10-10 23:43:03 +00001982#pragma mark InstrumentationRuntime
1983
Kate Stoneb9c1b512016-09-06 20:57:50 +00001984struct InstrumentationRuntimeInstance {
1985 InstrumentationRuntimeInstance()
1986 : name(), description(), create_callback(nullptr) {}
1987
1988 ConstString name;
1989 std::string description;
1990 InstrumentationRuntimeCreateInstance create_callback;
1991 InstrumentationRuntimeGetType get_type_callback;
Kuba Breckaafdf8422014-10-10 23:43:03 +00001992};
1993
Kate Stoneb9c1b512016-09-06 20:57:50 +00001994typedef std::vector<InstrumentationRuntimeInstance>
1995 InstrumentationRuntimeInstances;
Kuba Breckaafdf8422014-10-10 23:43:03 +00001996
Kate Stoneb9c1b512016-09-06 20:57:50 +00001997static std::recursive_mutex &GetInstrumentationRuntimeMutex() {
1998 static std::recursive_mutex g_instances_mutex;
1999 return g_instances_mutex;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002000}
2001
Kate Stoneb9c1b512016-09-06 20:57:50 +00002002static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() {
2003 static InstrumentationRuntimeInstances g_instances;
2004 return g_instances;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002005}
2006
Kate Stoneb9c1b512016-09-06 20:57:50 +00002007bool PluginManager::RegisterPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002008 ConstString name, const char *description,
Kate Stoneb9c1b512016-09-06 20:57:50 +00002009 InstrumentationRuntimeCreateInstance create_callback,
2010 InstrumentationRuntimeGetType get_type_callback) {
2011 if (create_callback) {
2012 InstrumentationRuntimeInstance instance;
2013 assert((bool)name);
2014 instance.name = name;
2015 if (description && description[0])
2016 instance.description = description;
2017 instance.create_callback = create_callback;
2018 instance.get_type_callback = get_type_callback;
2019 std::lock_guard<std::recursive_mutex> guard(
2020 GetInstrumentationRuntimeMutex());
2021 GetInstrumentationRuntimeInstances().push_back(instance);
2022 }
2023 return false;
2024}
2025
2026bool PluginManager::UnregisterPlugin(
2027 InstrumentationRuntimeCreateInstance create_callback) {
2028 if (create_callback) {
2029 std::lock_guard<std::recursive_mutex> guard(
2030 GetInstrumentationRuntimeMutex());
2031 InstrumentationRuntimeInstances &instances =
2032 GetInstrumentationRuntimeInstances();
2033
2034 InstrumentationRuntimeInstances::iterator pos, end = instances.end();
2035 for (pos = instances.begin(); pos != end; ++pos) {
2036 if (pos->create_callback == create_callback) {
2037 instances.erase(pos);
2038 return true;
2039 }
Kuba Breckaafdf8422014-10-10 23:43:03 +00002040 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002041 }
2042 return false;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002043}
2044
2045InstrumentationRuntimeGetType
Kate Stoneb9c1b512016-09-06 20:57:50 +00002046PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx) {
2047 std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
2048 InstrumentationRuntimeInstances &instances =
2049 GetInstrumentationRuntimeInstances();
2050 if (idx < instances.size())
2051 return instances[idx].get_type_callback;
2052 return nullptr;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002053}
2054
2055InstrumentationRuntimeCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00002056PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx) {
2057 std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
2058 InstrumentationRuntimeInstances &instances =
2059 GetInstrumentationRuntimeInstances();
2060 if (idx < instances.size())
2061 return instances[idx].create_callback;
2062 return nullptr;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002063}
2064
Kuba Breckaafdf8422014-10-10 23:43:03 +00002065InstrumentationRuntimeCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00002066PluginManager::GetInstrumentationRuntimeCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002067 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002068 if (name) {
2069 std::lock_guard<std::recursive_mutex> guard(
2070 GetInstrumentationRuntimeMutex());
2071 InstrumentationRuntimeInstances &instances =
2072 GetInstrumentationRuntimeInstances();
2073
2074 InstrumentationRuntimeInstances::iterator pos, end = instances.end();
2075 for (pos = instances.begin(); pos != end; ++pos) {
2076 if (name == pos->name)
2077 return pos->create_callback;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002078 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002079 }
2080 return nullptr;
Kuba Breckaafdf8422014-10-10 23:43:03 +00002081}
2082
Greg Clayton56939cb2015-09-17 22:23:34 +00002083#pragma mark TypeSystem
2084
Kate Stoneb9c1b512016-09-06 20:57:50 +00002085struct TypeSystemInstance {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002086 ConstString name;
2087 std::string description;
2088 TypeSystemCreateInstance create_callback;
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002089 LanguageSet supported_languages_for_types;
2090 LanguageSet supported_languages_for_expressions;
Greg Clayton56939cb2015-09-17 22:23:34 +00002091};
2092
2093typedef std::vector<TypeSystemInstance> TypeSystemInstances;
2094
Kate Stoneb9c1b512016-09-06 20:57:50 +00002095static std::recursive_mutex &GetTypeSystemMutex() {
2096 static std::recursive_mutex g_instances_mutex;
2097 return g_instances_mutex;
Greg Clayton56939cb2015-09-17 22:23:34 +00002098}
2099
Kate Stoneb9c1b512016-09-06 20:57:50 +00002100static TypeSystemInstances &GetTypeSystemInstances() {
2101 static TypeSystemInstances g_instances;
2102 return g_instances;
Greg Clayton56939cb2015-09-17 22:23:34 +00002103}
2104
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002105bool PluginManager::RegisterPlugin(
2106 ConstString name, const char *description,
2107 TypeSystemCreateInstance create_callback,
2108 LanguageSet supported_languages_for_types,
2109 LanguageSet supported_languages_for_expressions) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002110 if (create_callback) {
2111 TypeSystemInstance instance;
2112 assert((bool)name);
2113 instance.name = name;
2114 if (description && description[0])
2115 instance.description = description;
2116 instance.create_callback = create_callback;
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002117 instance.supported_languages_for_types = supported_languages_for_types;
2118 instance.supported_languages_for_expressions = supported_languages_for_expressions;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002119 std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2120 GetTypeSystemInstances().push_back(instance);
2121 }
2122 return false;
2123}
2124
2125bool PluginManager::UnregisterPlugin(TypeSystemCreateInstance create_callback) {
2126 if (create_callback) {
2127 std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2128 TypeSystemInstances &instances = GetTypeSystemInstances();
2129
2130 TypeSystemInstances::iterator pos, end = instances.end();
2131 for (pos = instances.begin(); pos != end; ++pos) {
2132 if (pos->create_callback == create_callback) {
2133 instances.erase(pos);
2134 return true;
2135 }
Greg Clayton56939cb2015-09-17 22:23:34 +00002136 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002137 }
2138 return false;
Greg Clayton56939cb2015-09-17 22:23:34 +00002139}
2140
2141TypeSystemCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00002142PluginManager::GetTypeSystemCreateCallbackAtIndex(uint32_t idx) {
2143 std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2144 TypeSystemInstances &instances = GetTypeSystemInstances();
2145 if (idx < instances.size())
2146 return instances[idx].create_callback;
2147 return nullptr;
Greg Clayton56939cb2015-09-17 22:23:34 +00002148}
2149
2150TypeSystemCreateInstance
Kate Stoneb9c1b512016-09-06 20:57:50 +00002151PluginManager::GetTypeSystemCreateCallbackForPluginName(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002152 ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002153 if (name) {
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00002154 std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00002155 TypeSystemInstances &instances = GetTypeSystemInstances();
2156
2157 TypeSystemInstances::iterator pos, end = instances.end();
2158 for (pos = instances.begin(); pos != end; ++pos) {
2159 if (name == pos->name)
2160 return pos->create_callback;
2161 }
2162 }
2163 return nullptr;
Sean Callananfe38c852015-10-08 23:07:53 +00002164}
2165
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002166LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForTypes() {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002167 std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002168 LanguageSet all;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002169 TypeSystemInstances &instances = GetTypeSystemInstances();
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002170 for (unsigned i = 0; i < instances.size(); ++i)
2171 all.bitvector |= instances[i].supported_languages_for_types.bitvector;
2172 return all;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002173}
2174
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002175LanguageSet PluginManager::GetAllTypeSystemSupportedLanguagesForExpressions() {
2176 std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
2177 LanguageSet all;
2178 TypeSystemInstances &instances = GetTypeSystemInstances();
2179 for (unsigned i = 0; i < instances.size(); ++i)
2180 all.bitvector |= instances[i].supported_languages_for_expressions.bitvector;
2181 return all;
Sean Callananfe38c852015-10-08 23:07:53 +00002182}
Greg Clayton56939cb2015-09-17 22:23:34 +00002183
Sean Callanan66810412015-10-19 23:11:07 +00002184#pragma mark REPL
2185
Kate Stoneb9c1b512016-09-06 20:57:50 +00002186struct REPLInstance {
2187 REPLInstance() : name(), description(), create_callback(nullptr) {}
2188
2189 ConstString name;
2190 std::string description;
2191 REPLCreateInstance create_callback;
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002192 LanguageSet supported_languages;
Sean Callanan66810412015-10-19 23:11:07 +00002193};
2194
2195typedef std::vector<REPLInstance> REPLInstances;
2196
Kate Stoneb9c1b512016-09-06 20:57:50 +00002197static std::recursive_mutex &GetREPLMutex() {
2198 static std::recursive_mutex g_instances_mutex;
2199 return g_instances_mutex;
Sean Callanan66810412015-10-19 23:11:07 +00002200}
2201
Kate Stoneb9c1b512016-09-06 20:57:50 +00002202static REPLInstances &GetREPLInstances() {
2203 static REPLInstances g_instances;
2204 return g_instances;
Sean Callanan66810412015-10-19 23:11:07 +00002205}
2206
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002207bool PluginManager::RegisterPlugin(ConstString name, const char *description,
2208 REPLCreateInstance create_callback,
2209 LanguageSet supported_languages) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002210 if (create_callback) {
2211 REPLInstance instance;
2212 assert((bool)name);
2213 instance.name = name;
2214 if (description && description[0])
2215 instance.description = description;
2216 instance.create_callback = create_callback;
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002217 instance.supported_languages = supported_languages;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002218 std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2219 GetREPLInstances().push_back(instance);
2220 }
2221 return false;
2222}
2223
2224bool PluginManager::UnregisterPlugin(REPLCreateInstance create_callback) {
2225 if (create_callback) {
2226 std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2227 REPLInstances &instances = GetREPLInstances();
2228
2229 REPLInstances::iterator pos, end = instances.end();
2230 for (pos = instances.begin(); pos != end; ++pos) {
2231 if (pos->create_callback == create_callback) {
2232 instances.erase(pos);
2233 return true;
2234 }
Sean Callanan66810412015-10-19 23:11:07 +00002235 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002236 }
2237 return false;
Sean Callanan66810412015-10-19 23:11:07 +00002238}
2239
Kate Stoneb9c1b512016-09-06 20:57:50 +00002240REPLCreateInstance PluginManager::GetREPLCreateCallbackAtIndex(uint32_t idx) {
2241 std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
2242 REPLInstances &instances = GetREPLInstances();
2243 if (idx < instances.size())
2244 return instances[idx].create_callback;
2245 return nullptr;
Sean Callanan66810412015-10-19 23:11:07 +00002246}
2247
2248REPLCreateInstance
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002249PluginManager::GetREPLCreateCallbackForPluginName(ConstString name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002250 if (name) {
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00002251 std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
Kate Stoneb9c1b512016-09-06 20:57:50 +00002252 REPLInstances &instances = GetREPLInstances();
Sean Callanan66810412015-10-19 23:11:07 +00002253
Kate Stoneb9c1b512016-09-06 20:57:50 +00002254 REPLInstances::iterator pos, end = instances.end();
2255 for (pos = instances.begin(); pos != end; ++pos) {
2256 if (name == pos->name)
2257 return pos->create_callback;
Sean Callanan66810412015-10-19 23:11:07 +00002258 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002259 }
2260 return nullptr;
Sean Callanan66810412015-10-19 23:11:07 +00002261}
2262
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002263LanguageSet PluginManager::GetREPLAllTypeSystemSupportedLanguages() {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002264 std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002265 LanguageSet all;
Kate Stoneb9c1b512016-09-06 20:57:50 +00002266 REPLInstances &instances = GetREPLInstances();
Adrian Prantlaa3a5642019-08-22 19:24:55 +00002267 for (unsigned i = 0; i < instances.size(); ++i)
2268 all.bitvector |= instances[i].supported_languages.bitvector;
2269 return all;
Sean Callanan93c0b002015-10-21 19:14:33 +00002270}
2271
Kuba Breckaafdf8422014-10-10 23:43:03 +00002272#pragma mark PluginManager
2273
Kate Stoneb9c1b512016-09-06 20:57:50 +00002274void PluginManager::DebuggerInitialize(Debugger &debugger) {
2275 // Initialize the DynamicLoader plugins
2276 {
2277 std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
2278 DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
Jason Molenda9b837a12013-04-05 05:06:39 +00002279
Kate Stoneb9c1b512016-09-06 20:57:50 +00002280 DynamicLoaderInstances::iterator pos, end = instances.end();
2281 for (pos = instances.begin(); pos != end; ++pos) {
2282 if (pos->debugger_init_callback)
2283 pos->debugger_init_callback(debugger);
Andrew MacPherson17220c12014-03-05 10:12:43 +00002284 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002285 }
Andrew MacPherson17220c12014-03-05 10:12:43 +00002286
Kate Stoneb9c1b512016-09-06 20:57:50 +00002287 // Initialize the JITLoader plugins
2288 {
2289 std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
2290 JITLoaderInstances &instances = GetJITLoaderInstances();
Oleksiy Vyalovabb5a352015-07-29 22:18:16 +00002291
Kate Stoneb9c1b512016-09-06 20:57:50 +00002292 JITLoaderInstances::iterator pos, end = instances.end();
2293 for (pos = instances.begin(); pos != end; ++pos) {
2294 if (pos->debugger_init_callback)
2295 pos->debugger_init_callback(debugger);
Greg Clayton7f982402013-07-15 22:54:20 +00002296 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002297 }
Greg Clayton7f982402013-07-15 22:54:20 +00002298
Kate Stoneb9c1b512016-09-06 20:57:50 +00002299 // Initialize the Platform plugins
2300 {
2301 std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
2302 PlatformInstances &instances = GetPlatformInstances();
Ryan Brown65d4d5c2015-09-16 21:20:44 +00002303
Kate Stoneb9c1b512016-09-06 20:57:50 +00002304 PlatformInstances::iterator pos, end = instances.end();
2305 for (pos = instances.begin(); pos != end; ++pos) {
2306 if (pos->debugger_init_callback)
2307 pos->debugger_init_callback(debugger);
Ryan Brown65d4d5c2015-09-16 21:20:44 +00002308 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002309 }
Todd Fiala75930012016-08-19 04:21:48 +00002310
Kate Stoneb9c1b512016-09-06 20:57:50 +00002311 // Initialize the Process plugins
2312 {
2313 std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
2314 ProcessInstances &instances = GetProcessInstances();
2315
2316 ProcessInstances::iterator pos, end = instances.end();
2317 for (pos = instances.begin(); pos != end; ++pos) {
2318 if (pos->debugger_init_callback)
2319 pos->debugger_init_callback(debugger);
Todd Fiala75930012016-08-19 04:21:48 +00002320 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002321 }
2322
2323 // Initialize the SymbolFile plugins
2324 {
2325 std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
2326 for (auto &sym_file : GetSymbolFileInstances()) {
2327 if (sym_file.debugger_init_callback)
2328 sym_file.debugger_init_callback(debugger);
2329 }
2330 }
2331
2332 // Initialize the OperatingSystem plugins
2333 {
2334 std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
2335 for (auto &os : GetOperatingSystemInstances()) {
2336 if (os.debugger_init_callback)
2337 os.debugger_init_callback(debugger);
2338 }
2339 }
2340
2341 // Initialize the StructuredDataPlugin plugins
2342 {
2343 std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
2344 for (auto &plugin : GetStructuredDataPluginInstances()) {
2345 if (plugin.debugger_init_callback)
2346 plugin.debugger_init_callback(debugger);
2347 }
2348 }
Greg Claytone8cd0c92012-10-19 18:02:49 +00002349}
2350
Greg Clayton7f982402013-07-15 22:54:20 +00002351// This is the preferred new way to register plugin specific settings. e.g.
Kate Stoneb9c1b512016-09-06 20:57:50 +00002352// This will put a plugin's settings under e.g.
2353// "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
2354static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002355 Debugger &debugger, ConstString plugin_type_name,
2356 ConstString plugin_type_desc, bool can_create) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002357 lldb::OptionValuePropertiesSP parent_properties_sp(
2358 debugger.GetValueProperties());
2359 if (parent_properties_sp) {
2360 static ConstString g_property_name("plugin");
2361
2362 OptionValuePropertiesSP plugin_properties_sp =
2363 parent_properties_sp->GetSubProperty(nullptr, g_property_name);
2364 if (!plugin_properties_sp && can_create) {
Zachary Turner2f3df612017-04-06 21:28:29 +00002365 plugin_properties_sp =
2366 std::make_shared<OptionValueProperties>(g_property_name);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002367 parent_properties_sp->AppendProperty(
2368 g_property_name, ConstString("Settings specify to plugins."), true,
2369 plugin_properties_sp);
Greg Claytone8cd0c92012-10-19 18:02:49 +00002370 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002371
2372 if (plugin_properties_sp) {
2373 lldb::OptionValuePropertiesSP plugin_type_properties_sp =
2374 plugin_properties_sp->GetSubProperty(nullptr, plugin_type_name);
2375 if (!plugin_type_properties_sp && can_create) {
Zachary Turner2f3df612017-04-06 21:28:29 +00002376 plugin_type_properties_sp =
2377 std::make_shared<OptionValueProperties>(plugin_type_name);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002378 plugin_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
2379 true, plugin_type_properties_sp);
2380 }
2381 return plugin_type_properties_sp;
2382 }
2383 }
2384 return lldb::OptionValuePropertiesSP();
Greg Claytone8cd0c92012-10-19 18:02:49 +00002385}
2386
Greg Clayton7f982402013-07-15 22:54:20 +00002387// This is deprecated way to register plugin specific settings. e.g.
Adrian Prantl05097242018-04-30 16:49:04 +00002388// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
2389// generic settings would be under "platform.SETTINGNAME".
Kate Stoneb9c1b512016-09-06 20:57:50 +00002390static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002391 Debugger &debugger, ConstString plugin_type_name,
2392 ConstString plugin_type_desc, bool can_create) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002393 static ConstString g_property_name("plugin");
2394 lldb::OptionValuePropertiesSP parent_properties_sp(
2395 debugger.GetValueProperties());
2396 if (parent_properties_sp) {
2397 OptionValuePropertiesSP plugin_properties_sp =
2398 parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
2399 if (!plugin_properties_sp && can_create) {
Zachary Turner2f3df612017-04-06 21:28:29 +00002400 plugin_properties_sp =
2401 std::make_shared<OptionValueProperties>(plugin_type_name);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002402 parent_properties_sp->AppendProperty(plugin_type_name, plugin_type_desc,
2403 true, plugin_properties_sp);
Jason Molenda3b59f5c2013-04-05 22:40:42 +00002404 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002405
2406 if (plugin_properties_sp) {
2407 lldb::OptionValuePropertiesSP plugin_type_properties_sp =
2408 plugin_properties_sp->GetSubProperty(nullptr, g_property_name);
2409 if (!plugin_type_properties_sp && can_create) {
Zachary Turner2f3df612017-04-06 21:28:29 +00002410 plugin_type_properties_sp =
2411 std::make_shared<OptionValueProperties>(g_property_name);
Kate Stoneb9c1b512016-09-06 20:57:50 +00002412 plugin_properties_sp->AppendProperty(
2413 g_property_name, ConstString("Settings specific to plugins"), true,
2414 plugin_type_properties_sp);
2415 }
2416 return plugin_type_properties_sp;
2417 }
2418 }
2419 return lldb::OptionValuePropertiesSP();
Jason Molenda3b59f5c2013-04-05 22:40:42 +00002420}
2421
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002422namespace {
2423
2424typedef lldb::OptionValuePropertiesSP
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002425GetDebuggerPropertyForPluginsPtr(Debugger &, ConstString ,
2426 ConstString , bool can_create);
Jason Molenda3b59f5c2013-04-05 22:40:42 +00002427
Greg Claytone8cd0c92012-10-19 18:02:49 +00002428lldb::OptionValuePropertiesSP
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002429GetSettingForPlugin(Debugger &debugger, ConstString setting_name,
2430 ConstString plugin_type_name,
Kate Stoneb9c1b512016-09-06 20:57:50 +00002431 GetDebuggerPropertyForPluginsPtr get_debugger_property =
2432 GetDebuggerPropertyForPlugins) {
2433 lldb::OptionValuePropertiesSP properties_sp;
2434 lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(
2435 debugger, plugin_type_name,
2436 ConstString(), // not creating to so we don't need the description
2437 false));
2438 if (plugin_type_properties_sp)
2439 properties_sp =
2440 plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
2441 return properties_sp;
Greg Claytone8cd0c92012-10-19 18:02:49 +00002442}
2443
Kate Stoneb9c1b512016-09-06 20:57:50 +00002444bool CreateSettingForPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002445 Debugger &debugger, ConstString plugin_type_name,
2446 ConstString plugin_type_desc,
Kate Stoneb9c1b512016-09-06 20:57:50 +00002447 const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002448 ConstString description, bool is_global_property,
Kate Stoneb9c1b512016-09-06 20:57:50 +00002449 GetDebuggerPropertyForPluginsPtr get_debugger_property =
2450 GetDebuggerPropertyForPlugins) {
2451 if (properties_sp) {
2452 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
2453 get_debugger_property(debugger, plugin_type_name, plugin_type_desc,
2454 true));
2455 if (plugin_type_properties_sp) {
2456 plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
2457 description, is_global_property,
2458 properties_sp);
2459 return true;
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002460 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002461 }
2462 return false;
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002463}
2464
Kate Stoneb9c1b512016-09-06 20:57:50 +00002465const char *kDynamicLoaderPluginName("dynamic-loader");
2466const char *kPlatformPluginName("platform");
2467const char *kProcessPluginName("process");
2468const char *kSymbolFilePluginName("symbol-file");
2469const char *kJITLoaderPluginName("jit-loader");
2470const char *kStructuredDataPluginName("structured-data");
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002471
Eugene Zelenko89183722016-03-11 21:55:47 +00002472} // anonymous namespace
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002473
Kate Stoneb9c1b512016-09-06 20:57:50 +00002474lldb::OptionValuePropertiesSP PluginManager::GetSettingForDynamicLoaderPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002475 Debugger &debugger, ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002476 return GetSettingForPlugin(debugger, setting_name,
2477 ConstString(kDynamicLoaderPluginName));
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002478}
2479
Kate Stoneb9c1b512016-09-06 20:57:50 +00002480bool PluginManager::CreateSettingForDynamicLoaderPlugin(
2481 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002482 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002483 return CreateSettingForPlugin(
2484 debugger, ConstString(kDynamicLoaderPluginName),
2485 ConstString("Settings for dynamic loader plug-ins"), properties_sp,
2486 description, is_global_property);
Greg Claytone8cd0c92012-10-19 18:02:49 +00002487}
2488
Jason Molenda9b837a12013-04-05 05:06:39 +00002489lldb::OptionValuePropertiesSP
Kate Stoneb9c1b512016-09-06 20:57:50 +00002490PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002491 ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002492 return GetSettingForPlugin(debugger, setting_name,
2493 ConstString(kPlatformPluginName),
2494 GetDebuggerPropertyForPluginsOldStyle);
Jason Molenda9b837a12013-04-05 05:06:39 +00002495}
2496
Kate Stoneb9c1b512016-09-06 20:57:50 +00002497bool PluginManager::CreateSettingForPlatformPlugin(
2498 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002499 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002500 return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName),
2501 ConstString("Settings for platform plug-ins"),
2502 properties_sp, description, is_global_property,
2503 GetDebuggerPropertyForPluginsOldStyle);
Greg Clayton7f982402013-07-15 22:54:20 +00002504}
2505
Greg Clayton7f982402013-07-15 22:54:20 +00002506lldb::OptionValuePropertiesSP
Kate Stoneb9c1b512016-09-06 20:57:50 +00002507PluginManager::GetSettingForProcessPlugin(Debugger &debugger,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002508 ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002509 return GetSettingForPlugin(debugger, setting_name,
2510 ConstString(kProcessPluginName));
Greg Clayton7f982402013-07-15 22:54:20 +00002511}
2512
Kate Stoneb9c1b512016-09-06 20:57:50 +00002513bool PluginManager::CreateSettingForProcessPlugin(
2514 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002515 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002516 return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName),
2517 ConstString("Settings for process plug-ins"),
2518 properties_sp, description, is_global_property);
Jason Molenda9b837a12013-04-05 05:06:39 +00002519}
2520
Oleksiy Vyalovabb5a352015-07-29 22:18:16 +00002521lldb::OptionValuePropertiesSP
Kate Stoneb9c1b512016-09-06 20:57:50 +00002522PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002523 ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002524 return GetSettingForPlugin(debugger, setting_name,
2525 ConstString(kSymbolFilePluginName));
Oleksiy Vyalovabb5a352015-07-29 22:18:16 +00002526}
2527
Kate Stoneb9c1b512016-09-06 20:57:50 +00002528bool PluginManager::CreateSettingForSymbolFilePlugin(
2529 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002530 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002531 return CreateSettingForPlugin(
2532 debugger, ConstString(kSymbolFilePluginName),
2533 ConstString("Settings for symbol file plug-ins"), properties_sp,
2534 description, is_global_property);
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002535}
2536
2537lldb::OptionValuePropertiesSP
Kate Stoneb9c1b512016-09-06 20:57:50 +00002538PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002539 ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002540 return GetSettingForPlugin(debugger, setting_name,
2541 ConstString(kJITLoaderPluginName));
Oleksiy Vyaloveff9ad22015-09-16 17:38:36 +00002542}
2543
Kate Stoneb9c1b512016-09-06 20:57:50 +00002544bool PluginManager::CreateSettingForJITLoaderPlugin(
2545 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002546 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002547 return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName),
2548 ConstString("Settings for JIT loader plug-ins"),
2549 properties_sp, description, is_global_property);
Oleksiy Vyalovabb5a352015-07-29 22:18:16 +00002550}
Ryan Brown65d4d5c2015-09-16 21:20:44 +00002551
2552static const char *kOperatingSystemPluginName("os");
2553
Kate Stoneb9c1b512016-09-06 20:57:50 +00002554lldb::OptionValuePropertiesSP PluginManager::GetSettingForOperatingSystemPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002555 Debugger &debugger, ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002556 lldb::OptionValuePropertiesSP properties_sp;
2557 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
2558 GetDebuggerPropertyForPlugins(
2559 debugger, ConstString(kOperatingSystemPluginName),
2560 ConstString(), // not creating to so we don't need the description
2561 false));
2562 if (plugin_type_properties_sp)
2563 properties_sp =
2564 plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
2565 return properties_sp;
2566}
2567
2568bool PluginManager::CreateSettingForOperatingSystemPlugin(
2569 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002570 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002571 if (properties_sp) {
Ryan Brown65d4d5c2015-09-16 21:20:44 +00002572 lldb::OptionValuePropertiesSP plugin_type_properties_sp(
Kate Stoneb9c1b512016-09-06 20:57:50 +00002573 GetDebuggerPropertyForPlugins(
2574 debugger, ConstString(kOperatingSystemPluginName),
2575 ConstString("Settings for operating system plug-ins"), true));
2576 if (plugin_type_properties_sp) {
2577 plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
2578 description, is_global_property,
2579 properties_sp);
2580 return true;
Ryan Brown65d4d5c2015-09-16 21:20:44 +00002581 }
Kate Stoneb9c1b512016-09-06 20:57:50 +00002582 }
2583 return false;
Ryan Brown65d4d5c2015-09-16 21:20:44 +00002584}
Todd Fiala75930012016-08-19 04:21:48 +00002585
Kate Stoneb9c1b512016-09-06 20:57:50 +00002586lldb::OptionValuePropertiesSP PluginManager::GetSettingForStructuredDataPlugin(
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002587 Debugger &debugger, ConstString setting_name) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002588 return GetSettingForPlugin(debugger, setting_name,
2589 ConstString(kStructuredDataPluginName));
Todd Fiala75930012016-08-19 04:21:48 +00002590}
2591
Kate Stoneb9c1b512016-09-06 20:57:50 +00002592bool PluginManager::CreateSettingForStructuredDataPlugin(
2593 Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
Adrian Prantl0e4c4822019-03-06 21:22:25 +00002594 ConstString description, bool is_global_property) {
Kate Stoneb9c1b512016-09-06 20:57:50 +00002595 return CreateSettingForPlugin(
2596 debugger, ConstString(kStructuredDataPluginName),
2597 ConstString("Settings for structured data plug-ins"), properties_sp,
2598 description, is_global_property);
Todd Fiala75930012016-08-19 04:21:48 +00002599}