Bug Summary

File:tools/lldb/source/API/SBTarget.cpp
Warning:line 1739, column 16
Array access (from variable 'name') results in a null pointer dereference

Annotated Source Code

Press '?' to see keyboard shortcuts

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