1 //===-- SBTarget.cpp ------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "lldb/API/SBTarget.h"
10 #include "SBReproducerPrivate.h"
11
12 #include "lldb/lldb-public.h"
13
14 #include "lldb/API/SBBreakpoint.h"
15 #include "lldb/API/SBDebugger.h"
16 #include "lldb/API/SBEnvironment.h"
17 #include "lldb/API/SBEvent.h"
18 #include "lldb/API/SBExpressionOptions.h"
19 #include "lldb/API/SBFileSpec.h"
20 #include "lldb/API/SBListener.h"
21 #include "lldb/API/SBModule.h"
22 #include "lldb/API/SBModuleSpec.h"
23 #include "lldb/API/SBProcess.h"
24 #include "lldb/API/SBSourceManager.h"
25 #include "lldb/API/SBStream.h"
26 #include "lldb/API/SBStringList.h"
27 #include "lldb/API/SBStructuredData.h"
28 #include "lldb/API/SBSymbolContextList.h"
29 #include "lldb/Breakpoint/BreakpointID.h"
30 #include "lldb/Breakpoint/BreakpointIDList.h"
31 #include "lldb/Breakpoint/BreakpointList.h"
32 #include "lldb/Breakpoint/BreakpointLocation.h"
33 #include "lldb/Core/Address.h"
34 #include "lldb/Core/AddressResolver.h"
35 #include "lldb/Core/AddressResolverName.h"
36 #include "lldb/Core/Debugger.h"
37 #include "lldb/Core/Disassembler.h"
38 #include "lldb/Core/Module.h"
39 #include "lldb/Core/ModuleSpec.h"
40 #include "lldb/Core/SearchFilter.h"
41 #include "lldb/Core/Section.h"
42 #include "lldb/Core/StructuredDataImpl.h"
43 #include "lldb/Core/ValueObjectConstResult.h"
44 #include "lldb/Core/ValueObjectList.h"
45 #include "lldb/Core/ValueObjectVariable.h"
46 #include "lldb/Host/Host.h"
47 #include "lldb/Symbol/DeclVendor.h"
48 #include "lldb/Symbol/ObjectFile.h"
49 #include "lldb/Symbol/SymbolFile.h"
50 #include "lldb/Symbol/SymbolVendor.h"
51 #include "lldb/Symbol/TypeSystem.h"
52 #include "lldb/Symbol/VariableList.h"
53 #include "lldb/Target/ABI.h"
54 #include "lldb/Target/Language.h"
55 #include "lldb/Target/LanguageRuntime.h"
56 #include "lldb/Target/Process.h"
57 #include "lldb/Target/StackFrame.h"
58 #include "lldb/Target/Target.h"
59 #include "lldb/Target/TargetList.h"
60 #include "lldb/Utility/ArchSpec.h"
61 #include "lldb/Utility/Args.h"
62 #include "lldb/Utility/FileSpec.h"
63 #include "lldb/Utility/ProcessInfo.h"
64 #include "lldb/Utility/RegularExpression.h"
65
66 #include "Commands/CommandObjectBreakpoint.h"
67 #include "lldb/Interpreter/CommandReturnObject.h"
68 #include "llvm/Support/PrettyStackTrace.h"
69 #include "llvm/Support/Regex.h"
70
71 using namespace lldb;
72 using namespace lldb_private;
73
74 #define DEFAULT_DISASM_BYTE_SIZE 32
75
76 namespace {
77
AttachToProcess(ProcessAttachInfo & attach_info,Target & target)78 Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
79 std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
80
81 auto process_sp = target.GetProcessSP();
82 if (process_sp) {
83 const auto state = process_sp->GetState();
84 if (process_sp->IsAlive() && state == eStateConnected) {
85 // If we are already connected, then we have already specified the
86 // listener, so if a valid listener is supplied, we need to error out to
87 // let the client know.
88 if (attach_info.GetListener())
89 return Status("process is connected and already has a listener, pass "
90 "empty listener");
91 }
92 }
93
94 return target.Attach(attach_info, nullptr);
95 }
96
97 } // namespace
98
99 // SBTarget constructor
SBTarget()100 SBTarget::SBTarget() : m_opaque_sp() {
101 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget);
102 }
103
SBTarget(const SBTarget & rhs)104 SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
105 LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs);
106 }
107
SBTarget(const TargetSP & target_sp)108 SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {
109 LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp);
110 }
111
operator =(const SBTarget & rhs)112 const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
113 LLDB_RECORD_METHOD(const lldb::SBTarget &,
114 SBTarget, operator=,(const lldb::SBTarget &), rhs);
115
116 if (this != &rhs)
117 m_opaque_sp = rhs.m_opaque_sp;
118 return LLDB_RECORD_RESULT(*this);
119 }
120
121 // Destructor
122 SBTarget::~SBTarget() = default;
123
EventIsTargetEvent(const SBEvent & event)124 bool SBTarget::EventIsTargetEvent(const SBEvent &event) {
125 LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
126 (const lldb::SBEvent &), event);
127
128 return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr;
129 }
130
GetTargetFromEvent(const SBEvent & event)131 SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) {
132 LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
133 (const lldb::SBEvent &), event);
134
135 return LLDB_RECORD_RESULT(
136 Target::TargetEventData::GetTargetFromEvent(event.get()));
137 }
138
GetNumModulesFromEvent(const SBEvent & event)139 uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) {
140 LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
141 (const lldb::SBEvent &), event);
142
143 const ModuleList module_list =
144 Target::TargetEventData::GetModuleListFromEvent(event.get());
145 return module_list.GetSize();
146 }
147
GetModuleAtIndexFromEvent(const uint32_t idx,const SBEvent & event)148 SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx,
149 const SBEvent &event) {
150 LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent,
151 (const uint32_t, const lldb::SBEvent &), idx,
152 event);
153
154 const ModuleList module_list =
155 Target::TargetEventData::GetModuleListFromEvent(event.get());
156 return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx)));
157 }
158
GetBroadcasterClassName()159 const char *SBTarget::GetBroadcasterClassName() {
160 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget,
161 GetBroadcasterClassName);
162
163 return Target::GetStaticBroadcasterClass().AsCString();
164 }
165
IsValid() const166 bool SBTarget::IsValid() const {
167 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid);
168 return this->operator bool();
169 }
operator bool() const170 SBTarget::operator bool() const {
171 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool);
172
173 return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid();
174 }
175
GetProcess()176 SBProcess SBTarget::GetProcess() {
177 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess);
178
179 SBProcess sb_process;
180 ProcessSP process_sp;
181 TargetSP target_sp(GetSP());
182 if (target_sp) {
183 process_sp = target_sp->GetProcessSP();
184 sb_process.SetSP(process_sp);
185 }
186
187 return LLDB_RECORD_RESULT(sb_process);
188 }
189
GetPlatform()190 SBPlatform SBTarget::GetPlatform() {
191 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
192
193 TargetSP target_sp(GetSP());
194 if (!target_sp)
195 return LLDB_RECORD_RESULT(SBPlatform());
196
197 SBPlatform platform;
198 platform.m_opaque_sp = target_sp->GetPlatform();
199
200 return LLDB_RECORD_RESULT(platform);
201 }
202
GetDebugger() const203 SBDebugger SBTarget::GetDebugger() const {
204 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger);
205
206 SBDebugger debugger;
207 TargetSP target_sp(GetSP());
208 if (target_sp)
209 debugger.reset(target_sp->GetDebugger().shared_from_this());
210 return LLDB_RECORD_RESULT(debugger);
211 }
212
GetStatistics()213 SBStructuredData SBTarget::GetStatistics() {
214 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
215
216 SBStructuredData data;
217 TargetSP target_sp(GetSP());
218 if (!target_sp)
219 return LLDB_RECORD_RESULT(data);
220
221 auto stats_up = std::make_unique<StructuredData::Dictionary>();
222 int i = 0;
223 for (auto &Entry : target_sp->GetStatistics()) {
224 std::string Desc = lldb_private::GetStatDescription(
225 static_cast<lldb_private::StatisticKind>(i));
226 stats_up->AddIntegerItem(Desc, Entry);
227 i += 1;
228 }
229
230 data.m_impl_up->SetObjectSP(std::move(stats_up));
231 return LLDB_RECORD_RESULT(data);
232 }
233
SetCollectingStats(bool v)234 void SBTarget::SetCollectingStats(bool v) {
235 LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
236
237 TargetSP target_sp(GetSP());
238 if (!target_sp)
239 return;
240 return target_sp->SetCollectingStats(v);
241 }
242
GetCollectingStats()243 bool SBTarget::GetCollectingStats() {
244 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats);
245
246 TargetSP target_sp(GetSP());
247 if (!target_sp)
248 return false;
249 return target_sp->GetCollectingStats();
250 }
251
LoadCore(const char * core_file)252 SBProcess SBTarget::LoadCore(const char *core_file) {
253 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *),
254 core_file);
255
256 lldb::SBError error; // Ignored
257 return LLDB_RECORD_RESULT(LoadCore(core_file, error));
258 }
259
LoadCore(const char * core_file,lldb::SBError & error)260 SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
261 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore,
262 (const char *, lldb::SBError &), core_file, error);
263
264 SBProcess sb_process;
265 TargetSP target_sp(GetSP());
266 if (target_sp) {
267 FileSpec filespec(core_file);
268 FileSystem::Instance().Resolve(filespec);
269 ProcessSP process_sp(target_sp->CreateProcess(
270 target_sp->GetDebugger().GetListener(), "", &filespec, false));
271 if (process_sp) {
272 error.SetError(process_sp->LoadCore());
273 if (error.Success())
274 sb_process.SetSP(process_sp);
275 } else {
276 error.SetErrorString("Failed to create the process");
277 }
278 } else {
279 error.SetErrorString("SBTarget is invalid");
280 }
281 return LLDB_RECORD_RESULT(sb_process);
282 }
283
LaunchSimple(char const ** argv,char const ** envp,const char * working_directory)284 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
285 const char *working_directory) {
286 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
287 (const char **, const char **, const char *), argv, envp,
288 working_directory);
289
290 TargetSP target_sp = GetSP();
291 if (!target_sp)
292 return LLDB_RECORD_RESULT(SBProcess());
293
294 SBLaunchInfo launch_info = GetLaunchInfo();
295
296 if (Module *exe_module = target_sp->GetExecutableModulePointer())
297 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(),
298 /*add_as_first_arg*/ true);
299 if (argv)
300 launch_info.SetArguments(argv, /*append*/ true);
301 if (envp)
302 launch_info.SetEnvironmentEntries(envp, /*append*/ false);
303 if (working_directory)
304 launch_info.SetWorkingDirectory(working_directory);
305
306 SBError error;
307 return LLDB_RECORD_RESULT(Launch(launch_info, error));
308 }
309
Install()310 SBError SBTarget::Install() {
311 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install);
312
313 SBError sb_error;
314 TargetSP target_sp(GetSP());
315 if (target_sp) {
316 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
317 sb_error.ref() = target_sp->Install(nullptr);
318 }
319 return LLDB_RECORD_RESULT(sb_error);
320 }
321
Launch(SBListener & listener,char const ** argv,char const ** envp,const char * stdin_path,const char * stdout_path,const char * stderr_path,const char * working_directory,uint32_t launch_flags,bool stop_at_entry,lldb::SBError & error)322 SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
323 char const **envp, const char *stdin_path,
324 const char *stdout_path, const char *stderr_path,
325 const char *working_directory,
326 uint32_t launch_flags, // See LaunchFlags
327 bool stop_at_entry, lldb::SBError &error) {
328 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
329 (lldb::SBListener &, const char **, const char **,
330 const char *, const char *, const char *, const char *,
331 uint32_t, bool, lldb::SBError &),
332 listener, argv, envp, stdin_path, stdout_path, stderr_path,
333 working_directory, launch_flags, stop_at_entry, error);
334
335 SBProcess sb_process;
336 ProcessSP process_sp;
337 TargetSP target_sp(GetSP());
338
339 if (target_sp) {
340 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
341
342 if (stop_at_entry)
343 launch_flags |= eLaunchFlagStopAtEntry;
344
345 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR"))
346 launch_flags |= eLaunchFlagDisableASLR;
347
348 StateType state = eStateInvalid;
349 process_sp = target_sp->GetProcessSP();
350 if (process_sp) {
351 state = process_sp->GetState();
352
353 if (process_sp->IsAlive() && state != eStateConnected) {
354 if (state == eStateAttaching)
355 error.SetErrorString("process attach is in progress");
356 else
357 error.SetErrorString("a process is already being debugged");
358 return LLDB_RECORD_RESULT(sb_process);
359 }
360 }
361
362 if (state == eStateConnected) {
363 // If we are already connected, then we have already specified the
364 // listener, so if a valid listener is supplied, we need to error out to
365 // let the client know.
366 if (listener.IsValid()) {
367 error.SetErrorString("process is connected and already has a listener, "
368 "pass empty listener");
369 return LLDB_RECORD_RESULT(sb_process);
370 }
371 }
372
373 if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO"))
374 launch_flags |= eLaunchFlagDisableSTDIO;
375
376 ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
377 FileSpec(stderr_path),
378 FileSpec(working_directory), launch_flags);
379
380 Module *exe_module = target_sp->GetExecutableModulePointer();
381 if (exe_module)
382 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
383 if (argv) {
384 launch_info.GetArguments().AppendArguments(argv);
385 } else {
386 auto default_launch_info = target_sp->GetProcessLaunchInfo();
387 launch_info.GetArguments().AppendArguments(
388 default_launch_info.GetArguments());
389 }
390 if (envp) {
391 launch_info.GetEnvironment() = Environment(envp);
392 } else {
393 auto default_launch_info = target_sp->GetProcessLaunchInfo();
394 launch_info.GetEnvironment() = default_launch_info.GetEnvironment();
395 }
396
397 if (listener.IsValid())
398 launch_info.SetListener(listener.GetSP());
399
400 error.SetError(target_sp->Launch(launch_info, nullptr));
401
402 sb_process.SetSP(target_sp->GetProcessSP());
403 } else {
404 error.SetErrorString("SBTarget is invalid");
405 }
406
407 return LLDB_RECORD_RESULT(sb_process);
408 }
409
Launch(SBLaunchInfo & sb_launch_info,SBError & error)410 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
411 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch,
412 (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
413 error);
414
415
416 SBProcess sb_process;
417 TargetSP target_sp(GetSP());
418
419 if (target_sp) {
420 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
421 StateType state = eStateInvalid;
422 {
423 ProcessSP process_sp = target_sp->GetProcessSP();
424 if (process_sp) {
425 state = process_sp->GetState();
426
427 if (process_sp->IsAlive() && state != eStateConnected) {
428 if (state == eStateAttaching)
429 error.SetErrorString("process attach is in progress");
430 else
431 error.SetErrorString("a process is already being debugged");
432 return LLDB_RECORD_RESULT(sb_process);
433 }
434 }
435 }
436
437 lldb_private::ProcessLaunchInfo launch_info = sb_launch_info.ref();
438
439 if (!launch_info.GetExecutableFile()) {
440 Module *exe_module = target_sp->GetExecutableModulePointer();
441 if (exe_module)
442 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
443 }
444
445 const ArchSpec &arch_spec = target_sp->GetArchitecture();
446 if (arch_spec.IsValid())
447 launch_info.GetArchitecture() = arch_spec;
448
449 error.SetError(target_sp->Launch(launch_info, nullptr));
450 sb_launch_info.set_ref(launch_info);
451 sb_process.SetSP(target_sp->GetProcessSP());
452 } else {
453 error.SetErrorString("SBTarget is invalid");
454 }
455
456 return LLDB_RECORD_RESULT(sb_process);
457 }
458
Attach(SBAttachInfo & sb_attach_info,SBError & error)459 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
460 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach,
461 (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
462 error);
463
464 SBProcess sb_process;
465 TargetSP target_sp(GetSP());
466
467 if (target_sp) {
468 ProcessAttachInfo &attach_info = sb_attach_info.ref();
469 if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) {
470 PlatformSP platform_sp = target_sp->GetPlatform();
471 // See if we can pre-verify if a process exists or not
472 if (platform_sp && platform_sp->IsConnected()) {
473 lldb::pid_t attach_pid = attach_info.GetProcessID();
474 ProcessInstanceInfo instance_info;
475 if (platform_sp->GetProcessInfo(attach_pid, instance_info)) {
476 attach_info.SetUserID(instance_info.GetEffectiveUserID());
477 } else {
478 error.ref().SetErrorStringWithFormat(
479 "no process found with process ID %" PRIu64, attach_pid);
480 return LLDB_RECORD_RESULT(sb_process);
481 }
482 }
483 }
484 error.SetError(AttachToProcess(attach_info, *target_sp));
485 if (error.Success())
486 sb_process.SetSP(target_sp->GetProcessSP());
487 } else {
488 error.SetErrorString("SBTarget is invalid");
489 }
490
491 return LLDB_RECORD_RESULT(sb_process);
492 }
493
AttachToProcessWithID(SBListener & listener,lldb::pid_t pid,SBError & error)494 lldb::SBProcess SBTarget::AttachToProcessWithID(
495 SBListener &listener,
496 lldb::pid_t pid, // The process ID to attach to
497 SBError &error // An error explaining what went wrong if attach fails
498 ) {
499 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
500 (lldb::SBListener &, lldb::pid_t, lldb::SBError &),
501 listener, pid, error);
502
503 SBProcess sb_process;
504 TargetSP target_sp(GetSP());
505
506 if (target_sp) {
507 ProcessAttachInfo attach_info;
508 attach_info.SetProcessID(pid);
509 if (listener.IsValid())
510 attach_info.SetListener(listener.GetSP());
511
512 ProcessInstanceInfo instance_info;
513 if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info))
514 attach_info.SetUserID(instance_info.GetEffectiveUserID());
515
516 error.SetError(AttachToProcess(attach_info, *target_sp));
517 if (error.Success())
518 sb_process.SetSP(target_sp->GetProcessSP());
519 } else
520 error.SetErrorString("SBTarget is invalid");
521
522 return LLDB_RECORD_RESULT(sb_process);
523 }
524
AttachToProcessWithName(SBListener & listener,const char * name,bool wait_for,SBError & error)525 lldb::SBProcess SBTarget::AttachToProcessWithName(
526 SBListener &listener,
527 const char *name, // basename of process to attach to
528 bool wait_for, // if true wait for a new instance of "name" to be launched
529 SBError &error // An error explaining what went wrong if attach fails
530 ) {
531 LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName,
532 (lldb::SBListener &, const char *, bool, lldb::SBError &),
533 listener, name, wait_for, error);
534
535 SBProcess sb_process;
536 TargetSP target_sp(GetSP());
537
538 if (name && target_sp) {
539 ProcessAttachInfo attach_info;
540 attach_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
541 attach_info.SetWaitForLaunch(wait_for);
542 if (listener.IsValid())
543 attach_info.SetListener(listener.GetSP());
544
545 error.SetError(AttachToProcess(attach_info, *target_sp));
546 if (error.Success())
547 sb_process.SetSP(target_sp->GetProcessSP());
548 } else
549 error.SetErrorString("SBTarget is invalid");
550
551 return LLDB_RECORD_RESULT(sb_process);
552 }
553
ConnectRemote(SBListener & listener,const char * url,const char * plugin_name,SBError & error)554 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
555 const char *plugin_name,
556 SBError &error) {
557 LLDB_RECORD_METHOD(
558 lldb::SBProcess, SBTarget, ConnectRemote,
559 (lldb::SBListener &, const char *, const char *, lldb::SBError &),
560 listener, url, plugin_name, error);
561
562 SBProcess sb_process;
563 ProcessSP process_sp;
564 TargetSP target_sp(GetSP());
565
566 if (target_sp) {
567 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
568 if (listener.IsValid())
569 process_sp =
570 target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr,
571 true);
572 else
573 process_sp = target_sp->CreateProcess(
574 target_sp->GetDebugger().GetListener(), plugin_name, nullptr, true);
575
576 if (process_sp) {
577 sb_process.SetSP(process_sp);
578 error.SetError(process_sp->ConnectRemote(url));
579 } else {
580 error.SetErrorString("unable to create lldb_private::Process");
581 }
582 } else {
583 error.SetErrorString("SBTarget is invalid");
584 }
585
586 return LLDB_RECORD_RESULT(sb_process);
587 }
588
GetExecutable()589 SBFileSpec SBTarget::GetExecutable() {
590 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable);
591
592 SBFileSpec exe_file_spec;
593 TargetSP target_sp(GetSP());
594 if (target_sp) {
595 Module *exe_module = target_sp->GetExecutableModulePointer();
596 if (exe_module)
597 exe_file_spec.SetFileSpec(exe_module->GetFileSpec());
598 }
599
600 return LLDB_RECORD_RESULT(exe_file_spec);
601 }
602
operator ==(const SBTarget & rhs) const603 bool SBTarget::operator==(const SBTarget &rhs) const {
604 LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
605 rhs);
606
607 return m_opaque_sp.get() == rhs.m_opaque_sp.get();
608 }
609
operator !=(const SBTarget & rhs) const610 bool SBTarget::operator!=(const SBTarget &rhs) const {
611 LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &),
612 rhs);
613
614 return m_opaque_sp.get() != rhs.m_opaque_sp.get();
615 }
616
GetSP() const617 lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; }
618
SetSP(const lldb::TargetSP & target_sp)619 void SBTarget::SetSP(const lldb::TargetSP &target_sp) {
620 m_opaque_sp = target_sp;
621 }
622
ResolveLoadAddress(lldb::addr_t vm_addr)623 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
624 LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
625 (lldb::addr_t), vm_addr);
626
627 lldb::SBAddress sb_addr;
628 Address &addr = sb_addr.ref();
629 TargetSP target_sp(GetSP());
630 if (target_sp) {
631 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
632 if (target_sp->ResolveLoadAddress(vm_addr, addr))
633 return LLDB_RECORD_RESULT(sb_addr);
634 }
635
636 // We have a load address that isn't in a section, just return an address
637 // with the offset filled in (the address) and the section set to NULL
638 addr.SetRawAddress(vm_addr);
639 return LLDB_RECORD_RESULT(sb_addr);
640 }
641
ResolveFileAddress(lldb::addr_t file_addr)642 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
643 LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
644 (lldb::addr_t), file_addr);
645
646 lldb::SBAddress sb_addr;
647 Address &addr = sb_addr.ref();
648 TargetSP target_sp(GetSP());
649 if (target_sp) {
650 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
651 if (target_sp->ResolveFileAddress(file_addr, addr))
652 return LLDB_RECORD_RESULT(sb_addr);
653 }
654
655 addr.SetRawAddress(file_addr);
656 return LLDB_RECORD_RESULT(sb_addr);
657 }
658
ResolvePastLoadAddress(uint32_t stop_id,lldb::addr_t vm_addr)659 lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
660 lldb::addr_t vm_addr) {
661 LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
662 (uint32_t, lldb::addr_t), stop_id, vm_addr);
663
664 lldb::SBAddress sb_addr;
665 Address &addr = sb_addr.ref();
666 TargetSP target_sp(GetSP());
667 if (target_sp) {
668 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
669 if (target_sp->ResolveLoadAddress(vm_addr, addr))
670 return LLDB_RECORD_RESULT(sb_addr);
671 }
672
673 // We have a load address that isn't in a section, just return an address
674 // with the offset filled in (the address) and the section set to NULL
675 addr.SetRawAddress(vm_addr);
676 return LLDB_RECORD_RESULT(sb_addr);
677 }
678
679 SBSymbolContext
ResolveSymbolContextForAddress(const SBAddress & addr,uint32_t resolve_scope)680 SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
681 uint32_t resolve_scope) {
682 LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget,
683 ResolveSymbolContextForAddress,
684 (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
685
686 SBSymbolContext sc;
687 SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
688 if (addr.IsValid()) {
689 TargetSP target_sp(GetSP());
690 if (target_sp)
691 target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
692 sc.ref());
693 }
694 return LLDB_RECORD_RESULT(sc);
695 }
696
ReadMemory(const SBAddress addr,void * buf,size_t size,lldb::SBError & error)697 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
698 lldb::SBError &error) {
699 LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory,
700 (const lldb::SBAddress, void *, size_t, lldb::SBError &),
701 addr, buf, size, error);
702
703 SBError sb_error;
704 size_t bytes_read = 0;
705 TargetSP target_sp(GetSP());
706 if (target_sp) {
707 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
708 bytes_read =
709 target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref());
710 } else {
711 sb_error.SetErrorString("invalid target");
712 }
713
714 return bytes_read;
715 }
716
BreakpointCreateByLocation(const char * file,uint32_t line)717 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
718 uint32_t line) {
719 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
720 (const char *, uint32_t), file, line);
721
722 return LLDB_RECORD_RESULT(
723 SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line)));
724 }
725
726 SBBreakpoint
BreakpointCreateByLocation(const SBFileSpec & sb_file_spec,uint32_t line)727 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
728 uint32_t line) {
729 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
730 (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
731
732 return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0));
733 }
734
735 SBBreakpoint
BreakpointCreateByLocation(const SBFileSpec & sb_file_spec,uint32_t line,lldb::addr_t offset)736 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
737 uint32_t line, lldb::addr_t offset) {
738 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
739 (const lldb::SBFileSpec &, uint32_t, lldb::addr_t),
740 sb_file_spec, line, offset);
741
742 SBFileSpecList empty_list;
743 return LLDB_RECORD_RESULT(
744 BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list));
745 }
746
747 SBBreakpoint
BreakpointCreateByLocation(const SBFileSpec & sb_file_spec,uint32_t line,lldb::addr_t offset,SBFileSpecList & sb_module_list)748 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
749 uint32_t line, lldb::addr_t offset,
750 SBFileSpecList &sb_module_list) {
751 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
752 (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
753 lldb::SBFileSpecList &),
754 sb_file_spec, line, offset, sb_module_list);
755
756 return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0,
757 offset, sb_module_list));
758 }
759
BreakpointCreateByLocation(const SBFileSpec & sb_file_spec,uint32_t line,uint32_t column,lldb::addr_t offset,SBFileSpecList & sb_module_list)760 SBBreakpoint SBTarget::BreakpointCreateByLocation(
761 const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
762 lldb::addr_t offset, SBFileSpecList &sb_module_list) {
763 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
764 (const lldb::SBFileSpec &, uint32_t, uint32_t,
765 lldb::addr_t, lldb::SBFileSpecList &),
766 sb_file_spec, line, column, offset, sb_module_list);
767
768 SBBreakpoint sb_bp;
769 TargetSP target_sp(GetSP());
770 if (target_sp && line != 0) {
771 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
772
773 const LazyBool check_inlines = eLazyBoolCalculate;
774 const LazyBool skip_prologue = eLazyBoolCalculate;
775 const bool internal = false;
776 const bool hardware = false;
777 const LazyBool move_to_nearest_code = eLazyBoolCalculate;
778 const FileSpecList *module_list = nullptr;
779 if (sb_module_list.GetSize() > 0) {
780 module_list = sb_module_list.get();
781 }
782 sb_bp = target_sp->CreateBreakpoint(
783 module_list, *sb_file_spec, line, column, offset, check_inlines,
784 skip_prologue, internal, hardware, move_to_nearest_code);
785 }
786
787 return LLDB_RECORD_RESULT(sb_bp);
788 }
789
BreakpointCreateByName(const char * symbol_name,const char * module_name)790 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
791 const char *module_name) {
792 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
793 (const char *, const char *), symbol_name, module_name);
794
795 SBBreakpoint sb_bp;
796 TargetSP target_sp(GetSP());
797 if (target_sp.get()) {
798 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
799
800 const bool internal = false;
801 const bool hardware = false;
802 const LazyBool skip_prologue = eLazyBoolCalculate;
803 const lldb::addr_t offset = 0;
804 if (module_name && module_name[0]) {
805 FileSpecList module_spec_list;
806 module_spec_list.Append(FileSpec(module_name));
807 sb_bp = target_sp->CreateBreakpoint(
808 &module_spec_list, nullptr, symbol_name, eFunctionNameTypeAuto,
809 eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
810 } else {
811 sb_bp = target_sp->CreateBreakpoint(
812 nullptr, nullptr, symbol_name, eFunctionNameTypeAuto,
813 eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
814 }
815 }
816
817 return LLDB_RECORD_RESULT(sb_bp);
818 }
819
820 lldb::SBBreakpoint
BreakpointCreateByName(const char * symbol_name,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)821 SBTarget::BreakpointCreateByName(const char *symbol_name,
822 const SBFileSpecList &module_list,
823 const SBFileSpecList &comp_unit_list) {
824 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
825 (const char *, const lldb::SBFileSpecList &,
826 const lldb::SBFileSpecList &),
827 symbol_name, module_list, comp_unit_list);
828
829 lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
830 return LLDB_RECORD_RESULT(
831 BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
832 module_list, comp_unit_list));
833 }
834
BreakpointCreateByName(const char * symbol_name,uint32_t name_type_mask,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)835 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
836 const char *symbol_name, uint32_t name_type_mask,
837 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
838 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
839 (const char *, uint32_t, const lldb::SBFileSpecList &,
840 const lldb::SBFileSpecList &),
841 symbol_name, name_type_mask, module_list, comp_unit_list);
842
843 return LLDB_RECORD_RESULT(
844 BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
845 module_list, comp_unit_list));
846 }
847
BreakpointCreateByName(const char * symbol_name,uint32_t name_type_mask,LanguageType symbol_language,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)848 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
849 const char *symbol_name, uint32_t name_type_mask,
850 LanguageType symbol_language, const SBFileSpecList &module_list,
851 const SBFileSpecList &comp_unit_list) {
852 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
853 (const char *, uint32_t, lldb::LanguageType,
854 const lldb::SBFileSpecList &,
855 const lldb::SBFileSpecList &),
856 symbol_name, name_type_mask, symbol_language, module_list,
857 comp_unit_list);
858
859 SBBreakpoint sb_bp;
860 TargetSP target_sp(GetSP());
861 if (target_sp && symbol_name && symbol_name[0]) {
862 const bool internal = false;
863 const bool hardware = false;
864 const LazyBool skip_prologue = eLazyBoolCalculate;
865 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
866 FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
867 sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(),
868 symbol_name, mask, symbol_language, 0,
869 skip_prologue, internal, hardware);
870 }
871
872 return LLDB_RECORD_RESULT(sb_bp);
873 }
874
BreakpointCreateByNames(const char * symbol_names[],uint32_t num_names,uint32_t name_type_mask,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)875 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
876 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
877 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
878 LLDB_RECORD_METHOD(
879 lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
880 (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &,
881 const lldb::SBFileSpecList &),
882 symbol_names, num_names, name_type_mask, module_list, comp_unit_list);
883
884 return LLDB_RECORD_RESULT(BreakpointCreateByNames(
885 symbol_names, num_names, name_type_mask, eLanguageTypeUnknown,
886 module_list, comp_unit_list));
887 }
888
BreakpointCreateByNames(const char * symbol_names[],uint32_t num_names,uint32_t name_type_mask,LanguageType symbol_language,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)889 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
890 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
891 LanguageType symbol_language, const SBFileSpecList &module_list,
892 const SBFileSpecList &comp_unit_list) {
893 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
894 (const char **, uint32_t, uint32_t, lldb::LanguageType,
895 const lldb::SBFileSpecList &,
896 const lldb::SBFileSpecList &),
897 symbol_names, num_names, name_type_mask, symbol_language,
898 module_list, comp_unit_list);
899
900 return LLDB_RECORD_RESULT(BreakpointCreateByNames(
901 symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0,
902 module_list, comp_unit_list));
903 }
904
BreakpointCreateByNames(const char * symbol_names[],uint32_t num_names,uint32_t name_type_mask,LanguageType symbol_language,lldb::addr_t offset,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)905 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
906 const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
907 LanguageType symbol_language, lldb::addr_t offset,
908 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
909 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
910 (const char **, uint32_t, uint32_t, lldb::LanguageType,
911 lldb::addr_t, const lldb::SBFileSpecList &,
912 const lldb::SBFileSpecList &),
913 symbol_names, num_names, name_type_mask, symbol_language,
914 offset, module_list, comp_unit_list);
915
916 SBBreakpoint sb_bp;
917 TargetSP target_sp(GetSP());
918 if (target_sp && num_names > 0) {
919 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
920 const bool internal = false;
921 const bool hardware = false;
922 FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
923 const LazyBool skip_prologue = eLazyBoolCalculate;
924 sb_bp = target_sp->CreateBreakpoint(
925 module_list.get(), comp_unit_list.get(), symbol_names, num_names, mask,
926 symbol_language, offset, skip_prologue, internal, hardware);
927 }
928
929 return LLDB_RECORD_RESULT(sb_bp);
930 }
931
BreakpointCreateByRegex(const char * symbol_name_regex,const char * module_name)932 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
933 const char *module_name) {
934 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
935 (const char *, const char *), symbol_name_regex,
936 module_name);
937
938 SBFileSpecList module_spec_list;
939 SBFileSpecList comp_unit_list;
940 if (module_name && module_name[0]) {
941 module_spec_list.Append(FileSpec(module_name));
942 }
943 return LLDB_RECORD_RESULT(
944 BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown,
945 module_spec_list, comp_unit_list));
946 }
947
948 lldb::SBBreakpoint
BreakpointCreateByRegex(const char * symbol_name_regex,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)949 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
950 const SBFileSpecList &module_list,
951 const SBFileSpecList &comp_unit_list) {
952 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
953 (const char *, const lldb::SBFileSpecList &,
954 const lldb::SBFileSpecList &),
955 symbol_name_regex, module_list, comp_unit_list);
956
957 return LLDB_RECORD_RESULT(BreakpointCreateByRegex(
958 symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list));
959 }
960
BreakpointCreateByRegex(const char * symbol_name_regex,LanguageType symbol_language,const SBFileSpecList & module_list,const SBFileSpecList & comp_unit_list)961 lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
962 const char *symbol_name_regex, LanguageType symbol_language,
963 const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
964 LLDB_RECORD_METHOD(
965 lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
966 (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
967 const lldb::SBFileSpecList &),
968 symbol_name_regex, symbol_language, module_list, comp_unit_list);
969
970
971 SBBreakpoint sb_bp;
972 TargetSP target_sp(GetSP());
973 if (target_sp && symbol_name_regex && symbol_name_regex[0]) {
974 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
975 RegularExpression regexp((llvm::StringRef(symbol_name_regex)));
976 const bool internal = false;
977 const bool hardware = false;
978 const LazyBool skip_prologue = eLazyBoolCalculate;
979
980 sb_bp = target_sp->CreateFuncRegexBreakpoint(
981 module_list.get(), comp_unit_list.get(), std::move(regexp),
982 symbol_language, skip_prologue, internal, hardware);
983 }
984
985 return LLDB_RECORD_RESULT(sb_bp);
986 }
987
BreakpointCreateByAddress(addr_t address)988 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
989 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
990 (lldb::addr_t), address);
991
992 SBBreakpoint sb_bp;
993 TargetSP target_sp(GetSP());
994 if (target_sp) {
995 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
996 const bool hardware = false;
997 sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
998 }
999
1000 return LLDB_RECORD_RESULT(sb_bp);
1001 }
1002
BreakpointCreateBySBAddress(SBAddress & sb_address)1003 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
1004 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress,
1005 (lldb::SBAddress &), sb_address);
1006
1007 SBBreakpoint sb_bp;
1008 TargetSP target_sp(GetSP());
1009 if (!sb_address.IsValid()) {
1010 return LLDB_RECORD_RESULT(sb_bp);
1011 }
1012
1013 if (target_sp) {
1014 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1015 const bool hardware = false;
1016 sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
1017 }
1018
1019 return LLDB_RECORD_RESULT(sb_bp);
1020 }
1021
1022 lldb::SBBreakpoint
BreakpointCreateBySourceRegex(const char * source_regex,const lldb::SBFileSpec & source_file,const char * module_name)1023 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
1024 const lldb::SBFileSpec &source_file,
1025 const char *module_name) {
1026 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
1027 BreakpointCreateBySourceRegex,
1028 (const char *, const lldb::SBFileSpec &, const char *),
1029 source_regex, source_file, module_name);
1030
1031 SBFileSpecList module_spec_list;
1032
1033 if (module_name && module_name[0]) {
1034 module_spec_list.Append(FileSpec(module_name));
1035 }
1036
1037 SBFileSpecList source_file_list;
1038 if (source_file.IsValid()) {
1039 source_file_list.Append(source_file);
1040 }
1041
1042 return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex(
1043 source_regex, module_spec_list, source_file_list));
1044 }
1045
BreakpointCreateBySourceRegex(const char * source_regex,const SBFileSpecList & module_list,const lldb::SBFileSpecList & source_file_list)1046 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
1047 const char *source_regex, const SBFileSpecList &module_list,
1048 const lldb::SBFileSpecList &source_file_list) {
1049 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
1050 BreakpointCreateBySourceRegex,
1051 (const char *, const lldb::SBFileSpecList &,
1052 const lldb::SBFileSpecList &),
1053 source_regex, module_list, source_file_list);
1054
1055 return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex(
1056 source_regex, module_list, source_file_list, SBStringList()));
1057 }
1058
BreakpointCreateBySourceRegex(const char * source_regex,const SBFileSpecList & module_list,const lldb::SBFileSpecList & source_file_list,const SBStringList & func_names)1059 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
1060 const char *source_regex, const SBFileSpecList &module_list,
1061 const lldb::SBFileSpecList &source_file_list,
1062 const SBStringList &func_names) {
1063 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget,
1064 BreakpointCreateBySourceRegex,
1065 (const char *, const lldb::SBFileSpecList &,
1066 const lldb::SBFileSpecList &, const lldb::SBStringList &),
1067 source_regex, module_list, source_file_list, func_names);
1068
1069 SBBreakpoint sb_bp;
1070 TargetSP target_sp(GetSP());
1071 if (target_sp && source_regex && source_regex[0]) {
1072 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1073 const bool hardware = false;
1074 const LazyBool move_to_nearest_code = eLazyBoolCalculate;
1075 RegularExpression regexp((llvm::StringRef(source_regex)));
1076 std::unordered_set<std::string> func_names_set;
1077 for (size_t i = 0; i < func_names.GetSize(); i++) {
1078 func_names_set.insert(func_names.GetStringAtIndex(i));
1079 }
1080
1081 sb_bp = target_sp->CreateSourceRegexBreakpoint(
1082 module_list.get(), source_file_list.get(), func_names_set,
1083 std::move(regexp), false, hardware, move_to_nearest_code);
1084 }
1085
1086 return LLDB_RECORD_RESULT(sb_bp);
1087 }
1088
1089 lldb::SBBreakpoint
BreakpointCreateForException(lldb::LanguageType language,bool catch_bp,bool throw_bp)1090 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
1091 bool catch_bp, bool throw_bp) {
1092 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException,
1093 (lldb::LanguageType, bool, bool), language, catch_bp,
1094 throw_bp);
1095
1096 SBBreakpoint sb_bp;
1097 TargetSP target_sp(GetSP());
1098 if (target_sp) {
1099 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1100 const bool hardware = false;
1101 sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
1102 hardware);
1103 }
1104
1105 return LLDB_RECORD_RESULT(sb_bp);
1106 }
1107
BreakpointCreateFromScript(const char * class_name,SBStructuredData & extra_args,const SBFileSpecList & module_list,const SBFileSpecList & file_list,bool request_hardware)1108 lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
1109 const char *class_name, SBStructuredData &extra_args,
1110 const SBFileSpecList &module_list, const SBFileSpecList &file_list,
1111 bool request_hardware) {
1112 LLDB_RECORD_METHOD(
1113 lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
1114 (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
1115 const lldb::SBFileSpecList &, bool),
1116 class_name, extra_args, module_list, file_list, request_hardware);
1117
1118 SBBreakpoint sb_bp;
1119 TargetSP target_sp(GetSP());
1120 if (target_sp) {
1121 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1122 Status error;
1123
1124 StructuredData::ObjectSP obj_sp = extra_args.m_impl_up->GetObjectSP();
1125 sb_bp =
1126 target_sp->CreateScriptedBreakpoint(class_name,
1127 module_list.get(),
1128 file_list.get(),
1129 false, /* internal */
1130 request_hardware,
1131 obj_sp,
1132 &error);
1133 }
1134
1135 return LLDB_RECORD_RESULT(sb_bp);
1136 }
1137
GetNumBreakpoints() const1138 uint32_t SBTarget::GetNumBreakpoints() const {
1139 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints);
1140
1141 TargetSP target_sp(GetSP());
1142 if (target_sp) {
1143 // The breakpoint list is thread safe, no need to lock
1144 return target_sp->GetBreakpointList().GetSize();
1145 }
1146 return 0;
1147 }
1148
GetBreakpointAtIndex(uint32_t idx) const1149 SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const {
1150 LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex,
1151 (uint32_t), idx);
1152
1153 SBBreakpoint sb_breakpoint;
1154 TargetSP target_sp(GetSP());
1155 if (target_sp) {
1156 // The breakpoint list is thread safe, no need to lock
1157 sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
1158 }
1159 return LLDB_RECORD_RESULT(sb_breakpoint);
1160 }
1161
BreakpointDelete(break_id_t bp_id)1162 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
1163 LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t),
1164 bp_id);
1165
1166 bool result = false;
1167 TargetSP target_sp(GetSP());
1168 if (target_sp) {
1169 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1170 result = target_sp->RemoveBreakpointByID(bp_id);
1171 }
1172
1173 return result;
1174 }
1175
FindBreakpointByID(break_id_t bp_id)1176 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
1177 LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
1178 (lldb::break_id_t), bp_id);
1179
1180 SBBreakpoint sb_breakpoint;
1181 TargetSP target_sp(GetSP());
1182 if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) {
1183 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1184 sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
1185 }
1186
1187 return LLDB_RECORD_RESULT(sb_breakpoint);
1188 }
1189
FindBreakpointsByName(const char * name,SBBreakpointList & bkpts)1190 bool SBTarget::FindBreakpointsByName(const char *name,
1191 SBBreakpointList &bkpts) {
1192 LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName,
1193 (const char *, lldb::SBBreakpointList &), name, bkpts);
1194
1195 TargetSP target_sp(GetSP());
1196 if (target_sp) {
1197 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1198 llvm::Expected<std::vector<BreakpointSP>> expected_vector =
1199 target_sp->GetBreakpointList().FindBreakpointsByName(name);
1200 if (!expected_vector) {
1201 LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS),
1202 "invalid breakpoint name: {}",
1203 llvm::toString(expected_vector.takeError()));
1204 return false;
1205 }
1206 for (BreakpointSP bkpt_sp : *expected_vector) {
1207 bkpts.AppendByID(bkpt_sp->GetID());
1208 }
1209 }
1210 return true;
1211 }
1212
GetBreakpointNames(SBStringList & names)1213 void SBTarget::GetBreakpointNames(SBStringList &names) {
1214 LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &),
1215 names);
1216
1217 names.Clear();
1218
1219 TargetSP target_sp(GetSP());
1220 if (target_sp) {
1221 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1222
1223 std::vector<std::string> name_vec;
1224 target_sp->GetBreakpointNames(name_vec);
1225 for (auto name : name_vec)
1226 names.AppendString(name.c_str());
1227 }
1228 }
1229
DeleteBreakpointName(const char * name)1230 void SBTarget::DeleteBreakpointName(const char *name) {
1231 LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
1232 name);
1233
1234 TargetSP target_sp(GetSP());
1235 if (target_sp) {
1236 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1237 target_sp->DeleteBreakpointName(ConstString(name));
1238 }
1239 }
1240
EnableAllBreakpoints()1241 bool SBTarget::EnableAllBreakpoints() {
1242 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints);
1243
1244 TargetSP target_sp(GetSP());
1245 if (target_sp) {
1246 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1247 target_sp->EnableAllowedBreakpoints();
1248 return true;
1249 }
1250 return false;
1251 }
1252
DisableAllBreakpoints()1253 bool SBTarget::DisableAllBreakpoints() {
1254 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints);
1255
1256 TargetSP target_sp(GetSP());
1257 if (target_sp) {
1258 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1259 target_sp->DisableAllowedBreakpoints();
1260 return true;
1261 }
1262 return false;
1263 }
1264
DeleteAllBreakpoints()1265 bool SBTarget::DeleteAllBreakpoints() {
1266 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints);
1267
1268 TargetSP target_sp(GetSP());
1269 if (target_sp) {
1270 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1271 target_sp->RemoveAllowedBreakpoints();
1272 return true;
1273 }
1274 return false;
1275 }
1276
BreakpointsCreateFromFile(SBFileSpec & source_file,SBBreakpointList & new_bps)1277 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
1278 SBBreakpointList &new_bps) {
1279 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
1280 (lldb::SBFileSpec &, lldb::SBBreakpointList &),
1281 source_file, new_bps);
1282
1283 SBStringList empty_name_list;
1284 return LLDB_RECORD_RESULT(
1285 BreakpointsCreateFromFile(source_file, empty_name_list, new_bps));
1286 }
1287
BreakpointsCreateFromFile(SBFileSpec & source_file,SBStringList & matching_names,SBBreakpointList & new_bps)1288 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
1289 SBStringList &matching_names,
1290 SBBreakpointList &new_bps) {
1291 LLDB_RECORD_METHOD(
1292 lldb::SBError, SBTarget, BreakpointsCreateFromFile,
1293 (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &),
1294 source_file, matching_names, new_bps);
1295
1296 SBError sberr;
1297 TargetSP target_sp(GetSP());
1298 if (!target_sp) {
1299 sberr.SetErrorString(
1300 "BreakpointCreateFromFile called with invalid target.");
1301 return LLDB_RECORD_RESULT(sberr);
1302 }
1303 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1304
1305 BreakpointIDList bp_ids;
1306
1307 std::vector<std::string> name_vector;
1308 size_t num_names = matching_names.GetSize();
1309 for (size_t i = 0; i < num_names; i++)
1310 name_vector.push_back(matching_names.GetStringAtIndex(i));
1311
1312 sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(),
1313 name_vector, bp_ids);
1314 if (sberr.Fail())
1315 return LLDB_RECORD_RESULT(sberr);
1316
1317 size_t num_bkpts = bp_ids.GetSize();
1318 for (size_t i = 0; i < num_bkpts; i++) {
1319 BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i);
1320 new_bps.AppendByID(bp_id.GetBreakpointID());
1321 }
1322 return LLDB_RECORD_RESULT(sberr);
1323 }
1324
BreakpointsWriteToFile(SBFileSpec & dest_file)1325 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
1326 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
1327 (lldb::SBFileSpec &), dest_file);
1328
1329 SBError sberr;
1330 TargetSP target_sp(GetSP());
1331 if (!target_sp) {
1332 sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
1333 return LLDB_RECORD_RESULT(sberr);
1334 }
1335 SBBreakpointList bkpt_list(*this);
1336 return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list));
1337 }
1338
BreakpointsWriteToFile(SBFileSpec & dest_file,SBBreakpointList & bkpt_list,bool append)1339 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
1340 SBBreakpointList &bkpt_list,
1341 bool append) {
1342 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
1343 (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool),
1344 dest_file, bkpt_list, append);
1345
1346 SBError sberr;
1347 TargetSP target_sp(GetSP());
1348 if (!target_sp) {
1349 sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
1350 return LLDB_RECORD_RESULT(sberr);
1351 }
1352
1353 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1354 BreakpointIDList bp_id_list;
1355 bkpt_list.CopyToBreakpointIDList(bp_id_list);
1356 sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
1357 bp_id_list, append);
1358 return LLDB_RECORD_RESULT(sberr);
1359 }
1360
GetNumWatchpoints() const1361 uint32_t SBTarget::GetNumWatchpoints() const {
1362 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints);
1363
1364 TargetSP target_sp(GetSP());
1365 if (target_sp) {
1366 // The watchpoint list is thread safe, no need to lock
1367 return target_sp->GetWatchpointList().GetSize();
1368 }
1369 return 0;
1370 }
1371
GetWatchpointAtIndex(uint32_t idx) const1372 SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const {
1373 LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex,
1374 (uint32_t), idx);
1375
1376 SBWatchpoint sb_watchpoint;
1377 TargetSP target_sp(GetSP());
1378 if (target_sp) {
1379 // The watchpoint list is thread safe, no need to lock
1380 sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
1381 }
1382 return LLDB_RECORD_RESULT(sb_watchpoint);
1383 }
1384
DeleteWatchpoint(watch_id_t wp_id)1385 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
1386 LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t),
1387 wp_id);
1388
1389
1390 bool result = false;
1391 TargetSP target_sp(GetSP());
1392 if (target_sp) {
1393 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1394 std::unique_lock<std::recursive_mutex> lock;
1395 target_sp->GetWatchpointList().GetListMutex(lock);
1396 result = target_sp->RemoveWatchpointByID(wp_id);
1397 }
1398
1399 return result;
1400 }
1401
FindWatchpointByID(lldb::watch_id_t wp_id)1402 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
1403 LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
1404 (lldb::watch_id_t), wp_id);
1405
1406
1407 SBWatchpoint sb_watchpoint;
1408 lldb::WatchpointSP watchpoint_sp;
1409 TargetSP target_sp(GetSP());
1410 if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) {
1411 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1412 std::unique_lock<std::recursive_mutex> lock;
1413 target_sp->GetWatchpointList().GetListMutex(lock);
1414 watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
1415 sb_watchpoint.SetSP(watchpoint_sp);
1416 }
1417
1418 return LLDB_RECORD_RESULT(sb_watchpoint);
1419 }
1420
WatchAddress(lldb::addr_t addr,size_t size,bool read,bool write,SBError & error)1421 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
1422 bool read, bool write,
1423 SBError &error) {
1424 LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
1425 (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
1426 size, read, write, error);
1427
1428 SBWatchpoint sb_watchpoint;
1429 lldb::WatchpointSP watchpoint_sp;
1430 TargetSP target_sp(GetSP());
1431 if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS &&
1432 size > 0) {
1433 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1434 uint32_t watch_type = 0;
1435 if (read)
1436 watch_type |= LLDB_WATCH_TYPE_READ;
1437 if (write)
1438 watch_type |= LLDB_WATCH_TYPE_WRITE;
1439 if (watch_type == 0) {
1440 error.SetErrorString(
1441 "Can't create a watchpoint that is neither read nor write.");
1442 return LLDB_RECORD_RESULT(sb_watchpoint);
1443 }
1444
1445 // Target::CreateWatchpoint() is thread safe.
1446 Status cw_error;
1447 // This API doesn't take in a type, so we can't figure out what it is.
1448 CompilerType *type = nullptr;
1449 watchpoint_sp =
1450 target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error);
1451 error.SetError(cw_error);
1452 sb_watchpoint.SetSP(watchpoint_sp);
1453 }
1454
1455 return LLDB_RECORD_RESULT(sb_watchpoint);
1456 }
1457
EnableAllWatchpoints()1458 bool SBTarget::EnableAllWatchpoints() {
1459 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints);
1460
1461 TargetSP target_sp(GetSP());
1462 if (target_sp) {
1463 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1464 std::unique_lock<std::recursive_mutex> lock;
1465 target_sp->GetWatchpointList().GetListMutex(lock);
1466 target_sp->EnableAllWatchpoints();
1467 return true;
1468 }
1469 return false;
1470 }
1471
DisableAllWatchpoints()1472 bool SBTarget::DisableAllWatchpoints() {
1473 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints);
1474
1475 TargetSP target_sp(GetSP());
1476 if (target_sp) {
1477 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1478 std::unique_lock<std::recursive_mutex> lock;
1479 target_sp->GetWatchpointList().GetListMutex(lock);
1480 target_sp->DisableAllWatchpoints();
1481 return true;
1482 }
1483 return false;
1484 }
1485
CreateValueFromAddress(const char * name,SBAddress addr,SBType type)1486 SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
1487 SBType type) {
1488 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
1489 (const char *, lldb::SBAddress, lldb::SBType), name, addr,
1490 type);
1491
1492 SBValue sb_value;
1493 lldb::ValueObjectSP new_value_sp;
1494 if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) {
1495 lldb::addr_t load_addr(addr.GetLoadAddress(*this));
1496 ExecutionContext exe_ctx(
1497 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
1498 CompilerType ast_type(type.GetSP()->GetCompilerType(true));
1499 new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr,
1500 exe_ctx, ast_type);
1501 }
1502 sb_value.SetSP(new_value_sp);
1503 return LLDB_RECORD_RESULT(sb_value);
1504 }
1505
CreateValueFromData(const char * name,lldb::SBData data,lldb::SBType type)1506 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
1507 lldb::SBType type) {
1508 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
1509 (const char *, lldb::SBData, lldb::SBType), name, data,
1510 type);
1511
1512 SBValue sb_value;
1513 lldb::ValueObjectSP new_value_sp;
1514 if (IsValid() && name && *name && data.IsValid() && type.IsValid()) {
1515 DataExtractorSP extractor(*data);
1516 ExecutionContext exe_ctx(
1517 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
1518 CompilerType ast_type(type.GetSP()->GetCompilerType(true));
1519 new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor,
1520 exe_ctx, ast_type);
1521 }
1522 sb_value.SetSP(new_value_sp);
1523 return LLDB_RECORD_RESULT(sb_value);
1524 }
1525
CreateValueFromExpression(const char * name,const char * expr)1526 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
1527 const char *expr) {
1528 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
1529 (const char *, const char *), name, expr);
1530
1531 SBValue sb_value;
1532 lldb::ValueObjectSP new_value_sp;
1533 if (IsValid() && name && *name && expr && *expr) {
1534 ExecutionContext exe_ctx(
1535 ExecutionContextRef(ExecutionContext(m_opaque_sp.get(), false)));
1536 new_value_sp =
1537 ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
1538 }
1539 sb_value.SetSP(new_value_sp);
1540 return LLDB_RECORD_RESULT(sb_value);
1541 }
1542
DeleteAllWatchpoints()1543 bool SBTarget::DeleteAllWatchpoints() {
1544 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints);
1545
1546 TargetSP target_sp(GetSP());
1547 if (target_sp) {
1548 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1549 std::unique_lock<std::recursive_mutex> lock;
1550 target_sp->GetWatchpointList().GetListMutex(lock);
1551 target_sp->RemoveAllWatchpoints();
1552 return true;
1553 }
1554 return false;
1555 }
1556
AppendImageSearchPath(const char * from,const char * to,lldb::SBError & error)1557 void SBTarget::AppendImageSearchPath(const char *from, const char *to,
1558 lldb::SBError &error) {
1559 LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath,
1560 (const char *, const char *, lldb::SBError &), from, to,
1561 error);
1562
1563 TargetSP target_sp(GetSP());
1564 if (!target_sp)
1565 return error.SetErrorString("invalid target");
1566
1567 const ConstString csFrom(from), csTo(to);
1568 if (!csFrom)
1569 return error.SetErrorString("<from> path can't be empty");
1570 if (!csTo)
1571 return error.SetErrorString("<to> path can't be empty");
1572
1573 target_sp->GetImageSearchPathList().Append(csFrom, csTo, true);
1574 }
1575
AddModule(const char * path,const char * triple,const char * uuid_cstr)1576 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
1577 const char *uuid_cstr) {
1578 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
1579 (const char *, const char *, const char *), path, triple,
1580 uuid_cstr);
1581
1582 return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, nullptr));
1583 }
1584
AddModule(const char * path,const char * triple,const char * uuid_cstr,const char * symfile)1585 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
1586 const char *uuid_cstr, const char *symfile) {
1587 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
1588 (const char *, const char *, const char *, const char *),
1589 path, triple, uuid_cstr, symfile);
1590
1591 lldb::SBModule sb_module;
1592 TargetSP target_sp(GetSP());
1593 if (target_sp) {
1594 ModuleSpec module_spec;
1595 if (path)
1596 module_spec.GetFileSpec().SetFile(path, FileSpec::Style::native);
1597
1598 if (uuid_cstr)
1599 module_spec.GetUUID().SetFromStringRef(uuid_cstr);
1600
1601 if (triple)
1602 module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec(
1603 target_sp->GetPlatform().get(), triple);
1604 else
1605 module_spec.GetArchitecture() = target_sp->GetArchitecture();
1606
1607 if (symfile)
1608 module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native);
1609
1610 sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */));
1611 }
1612 return LLDB_RECORD_RESULT(sb_module);
1613 }
1614
AddModule(const SBModuleSpec & module_spec)1615 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
1616 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
1617 (const lldb::SBModuleSpec &), module_spec);
1618
1619 lldb::SBModule sb_module;
1620 TargetSP target_sp(GetSP());
1621 if (target_sp)
1622 sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up,
1623 true /* notify */));
1624 return LLDB_RECORD_RESULT(sb_module);
1625 }
1626
AddModule(lldb::SBModule & module)1627 bool SBTarget::AddModule(lldb::SBModule &module) {
1628 LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
1629
1630 TargetSP target_sp(GetSP());
1631 if (target_sp) {
1632 target_sp->GetImages().AppendIfNeeded(module.GetSP());
1633 return true;
1634 }
1635 return false;
1636 }
1637
GetNumModules() const1638 uint32_t SBTarget::GetNumModules() const {
1639 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules);
1640
1641 uint32_t num = 0;
1642 TargetSP target_sp(GetSP());
1643 if (target_sp) {
1644 // The module list is thread safe, no need to lock
1645 num = target_sp->GetImages().GetSize();
1646 }
1647
1648 return num;
1649 }
1650
Clear()1651 void SBTarget::Clear() {
1652 LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear);
1653
1654 m_opaque_sp.reset();
1655 }
1656
FindModule(const SBFileSpec & sb_file_spec)1657 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
1658 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule,
1659 (const lldb::SBFileSpec &), sb_file_spec);
1660
1661 SBModule sb_module;
1662 TargetSP target_sp(GetSP());
1663 if (target_sp && sb_file_spec.IsValid()) {
1664 ModuleSpec module_spec(*sb_file_spec);
1665 // The module list is thread safe, no need to lock
1666 sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
1667 }
1668 return LLDB_RECORD_RESULT(sb_module);
1669 }
1670
FindCompileUnits(const SBFileSpec & sb_file_spec)1671 SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
1672 LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
1673 (const lldb::SBFileSpec &), sb_file_spec);
1674
1675 SBSymbolContextList sb_sc_list;
1676 const TargetSP target_sp(GetSP());
1677 if (target_sp && sb_file_spec.IsValid())
1678 target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list);
1679 return LLDB_RECORD_RESULT(sb_sc_list);
1680 }
1681
GetByteOrder()1682 lldb::ByteOrder SBTarget::GetByteOrder() {
1683 LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder);
1684
1685 TargetSP target_sp(GetSP());
1686 if (target_sp)
1687 return target_sp->GetArchitecture().GetByteOrder();
1688 return eByteOrderInvalid;
1689 }
1690
GetTriple()1691 const char *SBTarget::GetTriple() {
1692 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple);
1693
1694 TargetSP target_sp(GetSP());
1695 if (target_sp) {
1696 std::string triple(target_sp->GetArchitecture().GetTriple().str());
1697 // Unique the string so we don't run into ownership issues since the const
1698 // strings put the string into the string pool once and the strings never
1699 // comes out
1700 ConstString const_triple(triple.c_str());
1701 return const_triple.GetCString();
1702 }
1703 return nullptr;
1704 }
1705
GetDataByteSize()1706 uint32_t SBTarget::GetDataByteSize() {
1707 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize);
1708
1709 TargetSP target_sp(GetSP());
1710 if (target_sp) {
1711 return target_sp->GetArchitecture().GetDataByteSize();
1712 }
1713 return 0;
1714 }
1715
GetCodeByteSize()1716 uint32_t SBTarget::GetCodeByteSize() {
1717 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize);
1718
1719 TargetSP target_sp(GetSP());
1720 if (target_sp) {
1721 return target_sp->GetArchitecture().GetCodeByteSize();
1722 }
1723 return 0;
1724 }
1725
GetAddressByteSize()1726 uint32_t SBTarget::GetAddressByteSize() {
1727 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
1728
1729 TargetSP target_sp(GetSP());
1730 if (target_sp)
1731 return target_sp->GetArchitecture().GetAddressByteSize();
1732 return sizeof(void *);
1733 }
1734
GetModuleAtIndex(uint32_t idx)1735 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
1736 LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t),
1737 idx);
1738
1739 SBModule sb_module;
1740 ModuleSP module_sp;
1741 TargetSP target_sp(GetSP());
1742 if (target_sp) {
1743 // The module list is thread safe, no need to lock
1744 module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
1745 sb_module.SetSP(module_sp);
1746 }
1747
1748 return LLDB_RECORD_RESULT(sb_module);
1749 }
1750
RemoveModule(lldb::SBModule module)1751 bool SBTarget::RemoveModule(lldb::SBModule module) {
1752 LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module);
1753
1754 TargetSP target_sp(GetSP());
1755 if (target_sp)
1756 return target_sp->GetImages().Remove(module.GetSP());
1757 return false;
1758 }
1759
GetBroadcaster() const1760 SBBroadcaster SBTarget::GetBroadcaster() const {
1761 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget,
1762 GetBroadcaster);
1763
1764
1765 TargetSP target_sp(GetSP());
1766 SBBroadcaster broadcaster(target_sp.get(), false);
1767
1768
1769 return LLDB_RECORD_RESULT(broadcaster);
1770 }
1771
GetDescription(SBStream & description,lldb::DescriptionLevel description_level)1772 bool SBTarget::GetDescription(SBStream &description,
1773 lldb::DescriptionLevel description_level) {
1774 LLDB_RECORD_METHOD(bool, SBTarget, GetDescription,
1775 (lldb::SBStream &, lldb::DescriptionLevel), description,
1776 description_level);
1777
1778 Stream &strm = description.ref();
1779
1780 TargetSP target_sp(GetSP());
1781 if (target_sp) {
1782 target_sp->Dump(&strm, description_level);
1783 } else
1784 strm.PutCString("No value");
1785
1786 return true;
1787 }
1788
FindFunctions(const char * name,uint32_t name_type_mask)1789 lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
1790 uint32_t name_type_mask) {
1791 LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
1792 (const char *, uint32_t), name, name_type_mask);
1793
1794 lldb::SBSymbolContextList sb_sc_list;
1795 if (!name || !name[0])
1796 return LLDB_RECORD_RESULT(sb_sc_list);
1797
1798 TargetSP target_sp(GetSP());
1799 if (!target_sp)
1800 return LLDB_RECORD_RESULT(sb_sc_list);
1801
1802 const bool symbols_ok = true;
1803 const bool inlines_ok = true;
1804 FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
1805 target_sp->GetImages().FindFunctions(ConstString(name), mask, symbols_ok,
1806 inlines_ok, *sb_sc_list);
1807 return LLDB_RECORD_RESULT(sb_sc_list);
1808 }
1809
FindGlobalFunctions(const char * name,uint32_t max_matches,MatchType matchtype)1810 lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
1811 uint32_t max_matches,
1812 MatchType matchtype) {
1813 LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions,
1814 (const char *, uint32_t, lldb::MatchType), name,
1815 max_matches, matchtype);
1816
1817 lldb::SBSymbolContextList sb_sc_list;
1818 if (name && name[0]) {
1819 llvm::StringRef name_ref(name);
1820 TargetSP target_sp(GetSP());
1821 if (target_sp) {
1822 std::string regexstr;
1823 switch (matchtype) {
1824 case eMatchTypeRegex:
1825 target_sp->GetImages().FindFunctions(RegularExpression(name_ref), true,
1826 true, *sb_sc_list);
1827 break;
1828 case eMatchTypeStartsWith:
1829 regexstr = llvm::Regex::escape(name) + ".*";
1830 target_sp->GetImages().FindFunctions(RegularExpression(regexstr), true,
1831 true, *sb_sc_list);
1832 break;
1833 default:
1834 target_sp->GetImages().FindFunctions(
1835 ConstString(name), eFunctionNameTypeAny, true, true, *sb_sc_list);
1836 break;
1837 }
1838 }
1839 }
1840 return LLDB_RECORD_RESULT(sb_sc_list);
1841 }
1842
FindFirstType(const char * typename_cstr)1843 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
1844 LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *),
1845 typename_cstr);
1846
1847 TargetSP target_sp(GetSP());
1848 if (typename_cstr && typename_cstr[0] && target_sp) {
1849 ConstString const_typename(typename_cstr);
1850 SymbolContext sc;
1851 const bool exact_match = false;
1852
1853 const ModuleList &module_list = target_sp->GetImages();
1854 size_t count = module_list.GetSize();
1855 for (size_t idx = 0; idx < count; idx++) {
1856 ModuleSP module_sp(module_list.GetModuleAtIndex(idx));
1857 if (module_sp) {
1858 TypeSP type_sp(
1859 module_sp->FindFirstType(sc, const_typename, exact_match));
1860 if (type_sp)
1861 return LLDB_RECORD_RESULT(SBType(type_sp));
1862 }
1863 }
1864
1865 // Didn't find the type in the symbols; Try the loaded language runtimes
1866 if (auto process_sp = target_sp->GetProcessSP()) {
1867 for (auto *runtime : process_sp->GetLanguageRuntimes()) {
1868 if (auto vendor = runtime->GetDeclVendor()) {
1869 auto types = vendor->FindTypes(const_typename, /*max_matches*/ 1);
1870 if (!types.empty())
1871 return LLDB_RECORD_RESULT(SBType(types.front()));
1872 }
1873 }
1874 }
1875
1876 // No matches, search for basic typename matches
1877 for (auto *type_system : target_sp->GetScratchTypeSystems())
1878 if (auto type = type_system->GetBuiltinTypeByName(const_typename))
1879 return LLDB_RECORD_RESULT(SBType(type));
1880 }
1881
1882 return LLDB_RECORD_RESULT(SBType());
1883 }
1884
GetBasicType(lldb::BasicType type)1885 SBType SBTarget::GetBasicType(lldb::BasicType type) {
1886 LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType),
1887 type);
1888
1889 TargetSP target_sp(GetSP());
1890 if (target_sp) {
1891 for (auto *type_system : target_sp->GetScratchTypeSystems())
1892 if (auto compiler_type = type_system->GetBasicTypeFromAST(type))
1893 return LLDB_RECORD_RESULT(SBType(compiler_type));
1894 }
1895 return LLDB_RECORD_RESULT(SBType());
1896 }
1897
FindTypes(const char * typename_cstr)1898 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
1899 LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *),
1900 typename_cstr);
1901
1902 SBTypeList sb_type_list;
1903 TargetSP target_sp(GetSP());
1904 if (typename_cstr && typename_cstr[0] && target_sp) {
1905 ModuleList &images = target_sp->GetImages();
1906 ConstString const_typename(typename_cstr);
1907 bool exact_match = false;
1908 TypeList type_list;
1909 llvm::DenseSet<SymbolFile *> searched_symbol_files;
1910 images.FindTypes(nullptr, const_typename, exact_match, UINT32_MAX,
1911 searched_symbol_files, type_list);
1912
1913 for (size_t idx = 0; idx < type_list.GetSize(); idx++) {
1914 TypeSP type_sp(type_list.GetTypeAtIndex(idx));
1915 if (type_sp)
1916 sb_type_list.Append(SBType(type_sp));
1917 }
1918
1919 // Try the loaded language runtimes
1920 if (auto process_sp = target_sp->GetProcessSP()) {
1921 for (auto *runtime : process_sp->GetLanguageRuntimes()) {
1922 if (auto *vendor = runtime->GetDeclVendor()) {
1923 auto types =
1924 vendor->FindTypes(const_typename, /*max_matches*/ UINT32_MAX);
1925 for (auto type : types)
1926 sb_type_list.Append(SBType(type));
1927 }
1928 }
1929 }
1930
1931 if (sb_type_list.GetSize() == 0) {
1932 // No matches, search for basic typename matches
1933 for (auto *type_system : target_sp->GetScratchTypeSystems())
1934 if (auto compiler_type =
1935 type_system->GetBuiltinTypeByName(const_typename))
1936 sb_type_list.Append(SBType(compiler_type));
1937 }
1938 }
1939 return LLDB_RECORD_RESULT(sb_type_list);
1940 }
1941
FindGlobalVariables(const char * name,uint32_t max_matches)1942 SBValueList SBTarget::FindGlobalVariables(const char *name,
1943 uint32_t max_matches) {
1944 LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
1945 (const char *, uint32_t), name, max_matches);
1946
1947 SBValueList sb_value_list;
1948
1949 TargetSP target_sp(GetSP());
1950 if (name && target_sp) {
1951 VariableList variable_list;
1952 target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
1953 variable_list);
1954 if (!variable_list.Empty()) {
1955 ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
1956 if (exe_scope == nullptr)
1957 exe_scope = target_sp.get();
1958 for (const VariableSP &var_sp : variable_list) {
1959 lldb::ValueObjectSP valobj_sp(
1960 ValueObjectVariable::Create(exe_scope, var_sp));
1961 if (valobj_sp)
1962 sb_value_list.Append(SBValue(valobj_sp));
1963 }
1964 }
1965 }
1966
1967 return LLDB_RECORD_RESULT(sb_value_list);
1968 }
1969
FindGlobalVariables(const char * name,uint32_t max_matches,MatchType matchtype)1970 SBValueList SBTarget::FindGlobalVariables(const char *name,
1971 uint32_t max_matches,
1972 MatchType matchtype) {
1973 LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
1974 (const char *, uint32_t, lldb::MatchType), name,
1975 max_matches, matchtype);
1976
1977 SBValueList sb_value_list;
1978
1979 TargetSP target_sp(GetSP());
1980 if (name && target_sp) {
1981 llvm::StringRef name_ref(name);
1982 VariableList variable_list;
1983
1984 std::string regexstr;
1985 switch (matchtype) {
1986 case eMatchTypeNormal:
1987 target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
1988 variable_list);
1989 break;
1990 case eMatchTypeRegex:
1991 target_sp->GetImages().FindGlobalVariables(RegularExpression(name_ref),
1992 max_matches, variable_list);
1993 break;
1994 case eMatchTypeStartsWith:
1995 regexstr = llvm::Regex::escape(name) + ".*";
1996 target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr),
1997 max_matches, variable_list);
1998 break;
1999 }
2000 if (!variable_list.Empty()) {
2001 ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
2002 if (exe_scope == nullptr)
2003 exe_scope = target_sp.get();
2004 for (const VariableSP &var_sp : variable_list) {
2005 lldb::ValueObjectSP valobj_sp(
2006 ValueObjectVariable::Create(exe_scope, var_sp));
2007 if (valobj_sp)
2008 sb_value_list.Append(SBValue(valobj_sp));
2009 }
2010 }
2011 }
2012
2013 return LLDB_RECORD_RESULT(sb_value_list);
2014 }
2015
FindFirstGlobalVariable(const char * name)2016 lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
2017 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
2018 (const char *), name);
2019
2020 SBValueList sb_value_list(FindGlobalVariables(name, 1));
2021 if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
2022 return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
2023 return LLDB_RECORD_RESULT(SBValue());
2024 }
2025
GetSourceManager()2026 SBSourceManager SBTarget::GetSourceManager() {
2027 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager);
2028
2029 SBSourceManager source_manager(*this);
2030 return LLDB_RECORD_RESULT(source_manager);
2031 }
2032
ReadInstructions(lldb::SBAddress base_addr,uint32_t count)2033 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
2034 uint32_t count) {
2035 LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
2036 (lldb::SBAddress, uint32_t), base_addr, count);
2037
2038 return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, nullptr));
2039 }
2040
ReadInstructions(lldb::SBAddress base_addr,uint32_t count,const char * flavor_string)2041 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
2042 uint32_t count,
2043 const char *flavor_string) {
2044 LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
2045 (lldb::SBAddress, uint32_t, const char *), base_addr,
2046 count, flavor_string);
2047
2048 SBInstructionList sb_instructions;
2049
2050 TargetSP target_sp(GetSP());
2051 if (target_sp) {
2052 Address *addr_ptr = base_addr.get();
2053
2054 if (addr_ptr) {
2055 DataBufferHeap data(
2056 target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
2057 bool prefer_file_cache = false;
2058 lldb_private::Status error;
2059 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
2060 const size_t bytes_read =
2061 target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(),
2062 data.GetByteSize(), error, &load_addr);
2063 const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
2064 sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
2065 target_sp->GetArchitecture(), nullptr, flavor_string, *addr_ptr,
2066 data.GetBytes(), bytes_read, count, data_from_file));
2067 }
2068 }
2069
2070 return LLDB_RECORD_RESULT(sb_instructions);
2071 }
2072
GetInstructions(lldb::SBAddress base_addr,const void * buf,size_t size)2073 lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,
2074 const void *buf,
2075 size_t size) {
2076 LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
2077 (lldb::SBAddress, const void *, size_t), base_addr, buf,
2078 size);
2079
2080 return LLDB_RECORD_RESULT(
2081 GetInstructionsWithFlavor(base_addr, nullptr, buf, size));
2082 }
2083
2084 lldb::SBInstructionList
GetInstructionsWithFlavor(lldb::SBAddress base_addr,const char * flavor_string,const void * buf,size_t size)2085 SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
2086 const char *flavor_string, const void *buf,
2087 size_t size) {
2088 LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget,
2089 GetInstructionsWithFlavor,
2090 (lldb::SBAddress, const char *, const void *, size_t),
2091 base_addr, flavor_string, buf, size);
2092
2093 SBInstructionList sb_instructions;
2094
2095 TargetSP target_sp(GetSP());
2096 if (target_sp) {
2097 Address addr;
2098
2099 if (base_addr.get())
2100 addr = *base_addr.get();
2101
2102 const bool data_from_file = true;
2103
2104 sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
2105 target_sp->GetArchitecture(), nullptr, flavor_string, addr, buf, size,
2106 UINT32_MAX, data_from_file));
2107 }
2108
2109 return LLDB_RECORD_RESULT(sb_instructions);
2110 }
2111
GetInstructions(lldb::addr_t base_addr,const void * buf,size_t size)2112 lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr,
2113 const void *buf,
2114 size_t size) {
2115 LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
2116 (lldb::addr_t, const void *, size_t), base_addr, buf,
2117 size);
2118
2119 return LLDB_RECORD_RESULT(GetInstructionsWithFlavor(
2120 ResolveLoadAddress(base_addr), nullptr, buf, size));
2121 }
2122
2123 lldb::SBInstructionList
GetInstructionsWithFlavor(lldb::addr_t base_addr,const char * flavor_string,const void * buf,size_t size)2124 SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
2125 const char *flavor_string, const void *buf,
2126 size_t size) {
2127 LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget,
2128 GetInstructionsWithFlavor,
2129 (lldb::addr_t, const char *, const void *, size_t),
2130 base_addr, flavor_string, buf, size);
2131
2132 return LLDB_RECORD_RESULT(GetInstructionsWithFlavor(
2133 ResolveLoadAddress(base_addr), flavor_string, buf, size));
2134 }
2135
SetSectionLoadAddress(lldb::SBSection section,lldb::addr_t section_base_addr)2136 SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
2137 lldb::addr_t section_base_addr) {
2138 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
2139 (lldb::SBSection, lldb::addr_t), section,
2140 section_base_addr);
2141
2142 SBError sb_error;
2143 TargetSP target_sp(GetSP());
2144 if (target_sp) {
2145 if (!section.IsValid()) {
2146 sb_error.SetErrorStringWithFormat("invalid section");
2147 } else {
2148 SectionSP section_sp(section.GetSP());
2149 if (section_sp) {
2150 if (section_sp->IsThreadSpecific()) {
2151 sb_error.SetErrorString(
2152 "thread specific sections are not yet supported");
2153 } else {
2154 ProcessSP process_sp(target_sp->GetProcessSP());
2155 if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) {
2156 ModuleSP module_sp(section_sp->GetModule());
2157 if (module_sp) {
2158 ModuleList module_list;
2159 module_list.Append(module_sp);
2160 target_sp->ModulesDidLoad(module_list);
2161 }
2162 // Flush info in the process (stack frames, etc)
2163 if (process_sp)
2164 process_sp->Flush();
2165 }
2166 }
2167 }
2168 }
2169 } else {
2170 sb_error.SetErrorString("invalid target");
2171 }
2172 return LLDB_RECORD_RESULT(sb_error);
2173 }
2174
ClearSectionLoadAddress(lldb::SBSection section)2175 SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
2176 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
2177 (lldb::SBSection), section);
2178
2179 SBError sb_error;
2180
2181 TargetSP target_sp(GetSP());
2182 if (target_sp) {
2183 if (!section.IsValid()) {
2184 sb_error.SetErrorStringWithFormat("invalid section");
2185 } else {
2186 SectionSP section_sp(section.GetSP());
2187 if (section_sp) {
2188 ProcessSP process_sp(target_sp->GetProcessSP());
2189 if (target_sp->SetSectionUnloaded(section_sp)) {
2190 ModuleSP module_sp(section_sp->GetModule());
2191 if (module_sp) {
2192 ModuleList module_list;
2193 module_list.Append(module_sp);
2194 target_sp->ModulesDidUnload(module_list, false);
2195 }
2196 // Flush info in the process (stack frames, etc)
2197 if (process_sp)
2198 process_sp->Flush();
2199 }
2200 } else {
2201 sb_error.SetErrorStringWithFormat("invalid section");
2202 }
2203 }
2204 } else {
2205 sb_error.SetErrorStringWithFormat("invalid target");
2206 }
2207 return LLDB_RECORD_RESULT(sb_error);
2208 }
2209
SetModuleLoadAddress(lldb::SBModule module,int64_t slide_offset)2210 SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
2211 int64_t slide_offset) {
2212 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
2213 (lldb::SBModule, int64_t), module, slide_offset);
2214
2215 SBError sb_error;
2216
2217 TargetSP target_sp(GetSP());
2218 if (target_sp) {
2219 ModuleSP module_sp(module.GetSP());
2220 if (module_sp) {
2221 bool changed = false;
2222 if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) {
2223 // The load was successful, make sure that at least some sections
2224 // changed before we notify that our module was loaded.
2225 if (changed) {
2226 ModuleList module_list;
2227 module_list.Append(module_sp);
2228 target_sp->ModulesDidLoad(module_list);
2229 // Flush info in the process (stack frames, etc)
2230 ProcessSP process_sp(target_sp->GetProcessSP());
2231 if (process_sp)
2232 process_sp->Flush();
2233 }
2234 }
2235 } else {
2236 sb_error.SetErrorStringWithFormat("invalid module");
2237 }
2238
2239 } else {
2240 sb_error.SetErrorStringWithFormat("invalid target");
2241 }
2242 return LLDB_RECORD_RESULT(sb_error);
2243 }
2244
ClearModuleLoadAddress(lldb::SBModule module)2245 SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
2246 LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
2247 (lldb::SBModule), module);
2248
2249 SBError sb_error;
2250
2251 char path[PATH_MAX];
2252 TargetSP target_sp(GetSP());
2253 if (target_sp) {
2254 ModuleSP module_sp(module.GetSP());
2255 if (module_sp) {
2256 ObjectFile *objfile = module_sp->GetObjectFile();
2257 if (objfile) {
2258 SectionList *section_list = objfile->GetSectionList();
2259 if (section_list) {
2260 ProcessSP process_sp(target_sp->GetProcessSP());
2261
2262 bool changed = false;
2263 const size_t num_sections = section_list->GetSize();
2264 for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
2265 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
2266 if (section_sp)
2267 changed |= target_sp->SetSectionUnloaded(section_sp);
2268 }
2269 if (changed) {
2270 ModuleList module_list;
2271 module_list.Append(module_sp);
2272 target_sp->ModulesDidUnload(module_list, false);
2273 // Flush info in the process (stack frames, etc)
2274 ProcessSP process_sp(target_sp->GetProcessSP());
2275 if (process_sp)
2276 process_sp->Flush();
2277 }
2278 } else {
2279 module_sp->GetFileSpec().GetPath(path, sizeof(path));
2280 sb_error.SetErrorStringWithFormat("no sections in object file '%s'",
2281 path);
2282 }
2283 } else {
2284 module_sp->GetFileSpec().GetPath(path, sizeof(path));
2285 sb_error.SetErrorStringWithFormat("no object file for module '%s'",
2286 path);
2287 }
2288 } else {
2289 sb_error.SetErrorStringWithFormat("invalid module");
2290 }
2291 } else {
2292 sb_error.SetErrorStringWithFormat("invalid target");
2293 }
2294 return LLDB_RECORD_RESULT(sb_error);
2295 }
2296
FindSymbols(const char * name,lldb::SymbolType symbol_type)2297 lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
2298 lldb::SymbolType symbol_type) {
2299 LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
2300 (const char *, lldb::SymbolType), name, symbol_type);
2301
2302 SBSymbolContextList sb_sc_list;
2303 if (name && name[0]) {
2304 TargetSP target_sp(GetSP());
2305 if (target_sp)
2306 target_sp->GetImages().FindSymbolsWithNameAndType(
2307 ConstString(name), symbol_type, *sb_sc_list);
2308 }
2309 return LLDB_RECORD_RESULT(sb_sc_list);
2310 }
2311
EvaluateExpression(const char * expr)2312 lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
2313 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2314 (const char *), expr);
2315
2316 TargetSP target_sp(GetSP());
2317 if (!target_sp)
2318 return LLDB_RECORD_RESULT(SBValue());
2319
2320 SBExpressionOptions options;
2321 lldb::DynamicValueType fetch_dynamic_value =
2322 target_sp->GetPreferDynamicValue();
2323 options.SetFetchDynamicValue(fetch_dynamic_value);
2324 options.SetUnwindOnError(true);
2325 return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
2326 }
2327
EvaluateExpression(const char * expr,const SBExpressionOptions & options)2328 lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
2329 const SBExpressionOptions &options) {
2330 LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2331 (const char *, const lldb::SBExpressionOptions &), expr,
2332 options);
2333
2334 Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
2335 SBValue expr_result;
2336 ValueObjectSP expr_value_sp;
2337 TargetSP target_sp(GetSP());
2338 StackFrame *frame = nullptr;
2339 if (target_sp) {
2340 if (expr == nullptr || expr[0] == '\0') {
2341 return LLDB_RECORD_RESULT(expr_result);
2342 }
2343
2344 std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
2345 ExecutionContext exe_ctx(m_opaque_sp.get());
2346
2347
2348 frame = exe_ctx.GetFramePtr();
2349 Target *target = exe_ctx.GetTargetPtr();
2350
2351 if (target) {
2352 target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
2353
2354 expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
2355 }
2356 }
2357 LLDB_LOGF(expr_log,
2358 "** [SBTarget::EvaluateExpression] Expression result is "
2359 "%s, summary %s **",
2360 expr_result.GetValue(), expr_result.GetSummary());
2361 return LLDB_RECORD_RESULT(expr_result);
2362 }
2363
GetStackRedZoneSize()2364 lldb::addr_t SBTarget::GetStackRedZoneSize() {
2365 LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize);
2366
2367 TargetSP target_sp(GetSP());
2368 if (target_sp) {
2369 ABISP abi_sp;
2370 ProcessSP process_sp(target_sp->GetProcessSP());
2371 if (process_sp)
2372 abi_sp = process_sp->GetABI();
2373 else
2374 abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture());
2375 if (abi_sp)
2376 return abi_sp->GetRedZoneSize();
2377 }
2378 return 0;
2379 }
2380
GetLaunchInfo() const2381 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
2382 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
2383
2384 lldb::SBLaunchInfo launch_info(nullptr);
2385 TargetSP target_sp(GetSP());
2386 if (target_sp)
2387 launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
2388 return LLDB_RECORD_RESULT(launch_info);
2389 }
2390
SetLaunchInfo(const lldb::SBLaunchInfo & launch_info)2391 void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
2392 LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
2393 (const lldb::SBLaunchInfo &), launch_info);
2394
2395 TargetSP target_sp(GetSP());
2396 if (target_sp)
2397 m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
2398 }
2399
GetEnvironment()2400 SBEnvironment SBTarget::GetEnvironment() {
2401 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment);
2402 TargetSP target_sp(GetSP());
2403
2404 if (target_sp) {
2405 return LLDB_RECORD_RESULT(SBEnvironment(target_sp->GetEnvironment()));
2406 }
2407
2408 return LLDB_RECORD_RESULT(SBEnvironment());
2409 }
2410
2411 namespace lldb_private {
2412 namespace repro {
2413
2414 template <>
RegisterMethods(Registry & R)2415 void RegisterMethods<SBTarget>(Registry &R) {
2416 LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
2417 LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
2418 LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
2419 LLDB_REGISTER_METHOD(const lldb::SBTarget &,
2420 SBTarget, operator=,(const lldb::SBTarget &));
2421 LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
2422 (const lldb::SBEvent &));
2423 LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
2424 (const lldb::SBEvent &));
2425 LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
2426 (const lldb::SBEvent &));
2427 LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
2428 GetModuleAtIndexFromEvent,
2429 (const uint32_t, const lldb::SBEvent &));
2430 LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
2431 ());
2432 LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
2433 LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
2434 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
2435 LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
2436 LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
2437 LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
2438 LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
2439 LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
2440 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
2441 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
2442 (const char *, lldb::SBError &));
2443 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple,
2444 (const char **, const char **, const char *));
2445 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ());
2446 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
2447 (lldb::SBListener &, const char **, const char **,
2448 const char *, const char *, const char *,
2449 const char *, uint32_t, bool, lldb::SBError &));
2450 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch,
2451 (lldb::SBLaunchInfo &, lldb::SBError &));
2452 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach,
2453 (lldb::SBAttachInfo &, lldb::SBError &));
2454 LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
2455 (lldb::SBListener &, lldb::pid_t, lldb::SBError &));
2456 LLDB_REGISTER_METHOD(
2457 lldb::SBProcess, SBTarget, AttachToProcessWithName,
2458 (lldb::SBListener &, const char *, bool, lldb::SBError &));
2459 LLDB_REGISTER_METHOD(
2460 lldb::SBProcess, SBTarget, ConnectRemote,
2461 (lldb::SBListener &, const char *, const char *, lldb::SBError &));
2462 LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
2463 LLDB_REGISTER_METHOD_CONST(bool,
2464 SBTarget, operator==,(const lldb::SBTarget &));
2465 LLDB_REGISTER_METHOD_CONST(bool,
2466 SBTarget, operator!=,(const lldb::SBTarget &));
2467 LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
2468 (lldb::addr_t));
2469 LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
2470 (lldb::addr_t));
2471 LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
2472 (uint32_t, lldb::addr_t));
2473 LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget,
2474 ResolveSymbolContextForAddress,
2475 (const lldb::SBAddress &, uint32_t));
2476 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2477 BreakpointCreateByLocation, (const char *, uint32_t));
2478 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2479 BreakpointCreateByLocation,
2480 (const lldb::SBFileSpec &, uint32_t));
2481 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2482 BreakpointCreateByLocation,
2483 (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
2484 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2485 BreakpointCreateByLocation,
2486 (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
2487 lldb::SBFileSpecList &));
2488 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2489 BreakpointCreateByLocation,
2490 (const lldb::SBFileSpec &, uint32_t, uint32_t,
2491 lldb::addr_t, lldb::SBFileSpecList &));
2492 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2493 (const char *, const char *));
2494 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2495 (const char *, const lldb::SBFileSpecList &,
2496 const lldb::SBFileSpecList &));
2497 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2498 (const char *, uint32_t, const lldb::SBFileSpecList &,
2499 const lldb::SBFileSpecList &));
2500 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2501 (const char *, uint32_t, lldb::LanguageType,
2502 const lldb::SBFileSpecList &,
2503 const lldb::SBFileSpecList &));
2504 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2505 (const char **, uint32_t, uint32_t,
2506 const lldb::SBFileSpecList &,
2507 const lldb::SBFileSpecList &));
2508 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2509 (const char **, uint32_t, uint32_t, lldb::LanguageType,
2510 const lldb::SBFileSpecList &,
2511 const lldb::SBFileSpecList &));
2512 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2513 (const char **, uint32_t, uint32_t, lldb::LanguageType,
2514 lldb::addr_t, const lldb::SBFileSpecList &,
2515 const lldb::SBFileSpecList &));
2516 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2517 (const char *, const char *));
2518 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2519 (const char *, const lldb::SBFileSpecList &,
2520 const lldb::SBFileSpecList &));
2521 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2522 (const char *, lldb::LanguageType,
2523 const lldb::SBFileSpecList &,
2524 const lldb::SBFileSpecList &));
2525 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2526 BreakpointCreateByAddress, (lldb::addr_t));
2527 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2528 BreakpointCreateBySBAddress, (lldb::SBAddress &));
2529 LLDB_REGISTER_METHOD(
2530 lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
2531 (const char *, const lldb::SBFileSpec &, const char *));
2532 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2533 BreakpointCreateBySourceRegex,
2534 (const char *, const lldb::SBFileSpecList &,
2535 const lldb::SBFileSpecList &));
2536 LLDB_REGISTER_METHOD(
2537 lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
2538 (const char *, const lldb::SBFileSpecList &,
2539 const lldb::SBFileSpecList &, const lldb::SBStringList &));
2540 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
2541 BreakpointCreateForException,
2542 (lldb::LanguageType, bool, bool));
2543 LLDB_REGISTER_METHOD(
2544 lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
2545 (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
2546 const lldb::SBFileSpecList &, bool));
2547 LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
2548 LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget,
2549 GetBreakpointAtIndex, (uint32_t));
2550 LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
2551 LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
2552 (lldb::break_id_t));
2553 LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
2554 (const char *, lldb::SBBreakpointList &));
2555 LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
2556 (lldb::SBStringList &));
2557 LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
2558 LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
2559 LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
2560 LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
2561 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
2562 (lldb::SBFileSpec &, lldb::SBBreakpointList &));
2563 LLDB_REGISTER_METHOD(
2564 lldb::SBError, SBTarget, BreakpointsCreateFromFile,
2565 (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &));
2566 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
2567 (lldb::SBFileSpec &));
2568 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
2569 (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool));
2570 LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
2571 LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget,
2572 GetWatchpointAtIndex, (uint32_t));
2573 LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
2574 LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
2575 (lldb::watch_id_t));
2576 LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress,
2577 (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
2578 LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
2579 LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
2580 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
2581 (const char *, lldb::SBAddress, lldb::SBType));
2582 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
2583 (const char *, lldb::SBData, lldb::SBType));
2584 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
2585 (const char *, const char *));
2586 LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
2587 LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
2588 (const char *, const char *, lldb::SBError &));
2589 LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
2590 (const char *, const char *, const char *));
2591 LLDB_REGISTER_METHOD(
2592 lldb::SBModule, SBTarget, AddModule,
2593 (const char *, const char *, const char *, const char *));
2594 LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule,
2595 (const lldb::SBModuleSpec &));
2596 LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
2597 LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
2598 LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
2599 LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
2600 (const lldb::SBFileSpec &));
2601 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
2602 (const lldb::SBFileSpec &));
2603 LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
2604 LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
2605 LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
2606 LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
2607 LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
2608 LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
2609 (uint32_t));
2610 LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
2611 LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
2612 ());
2613 LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
2614 (lldb::SBStream &, lldb::DescriptionLevel));
2615 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions,
2616 (const char *, uint32_t));
2617 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget,
2618 FindGlobalFunctions,
2619 (const char *, uint32_t, lldb::MatchType));
2620 LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
2621 LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType,
2622 (lldb::BasicType));
2623 LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
2624 LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
2625 (const char *, uint32_t));
2626 LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
2627 (const char *, uint32_t, lldb::MatchType));
2628 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
2629 (const char *));
2630 LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
2631 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
2632 (lldb::SBAddress, uint32_t));
2633 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions,
2634 (lldb::SBAddress, uint32_t, const char *));
2635 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
2636 (lldb::SBSection, lldb::addr_t));
2637 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
2638 (lldb::SBSection));
2639 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
2640 (lldb::SBModule, int64_t));
2641 LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
2642 (lldb::SBModule));
2643 LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
2644 (const char *, lldb::SymbolType));
2645 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2646 (const char *));
2647 LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2648 (const char *, const lldb::SBExpressionOptions &));
2649 LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
2650 LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
2651 LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
2652 (const lldb::SBLaunchInfo &));
2653 LLDB_REGISTER_METHOD(
2654 size_t, SBTarget, ReadMemory,
2655 (const lldb::SBAddress, void *, size_t, lldb::SBError &));
2656 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
2657 (lldb::SBAddress, const void *, size_t));
2658 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
2659 GetInstructionsWithFlavor,
2660 (lldb::SBAddress, const char *, const void *, size_t));
2661 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
2662 (lldb::addr_t, const void *, size_t));
2663 LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
2664 GetInstructionsWithFlavor,
2665 (lldb::addr_t, const char *, const void *, size_t));
2666 LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ());
2667 }
2668
2669 }
2670 }
2671