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