1 //===-- ProcessGDBRemote.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 // C Includes
11 #include <errno.h>
12 #include <spawn.h>
13 #include <stdlib.h>
14 #include <sys/mman.h>       // for mmap
15 #include <sys/stat.h>
16 #include <sys/types.h>
17 #include <time.h>
18 
19 // C++ Includes
20 #include <algorithm>
21 #include <map>
22 
23 // Other libraries and framework includes
24 
25 #include "lldb/Breakpoint/WatchpointLocation.h"
26 #include "lldb/Interpreter/Args.h"
27 #include "lldb/Core/ArchSpec.h"
28 #include "lldb/Core/Debugger.h"
29 #include "lldb/Core/ConnectionFileDescriptor.h"
30 #include "lldb/Host/FileSpec.h"
31 #include "lldb/Core/InputReader.h"
32 #include "lldb/Core/Module.h"
33 #include "lldb/Core/PluginManager.h"
34 #include "lldb/Core/State.h"
35 #include "lldb/Core/StreamString.h"
36 #include "lldb/Core/Timer.h"
37 #include "lldb/Core/Value.h"
38 #include "lldb/Host/TimeValue.h"
39 #include "lldb/Symbol/ObjectFile.h"
40 #include "lldb/Target/DynamicLoader.h"
41 #include "lldb/Target/Target.h"
42 #include "lldb/Target/TargetList.h"
43 #include "lldb/Target/ThreadPlanCallFunction.h"
44 #include "lldb/Utility/PseudoTerminal.h"
45 
46 // Project includes
47 #include "lldb/Host/Host.h"
48 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
49 #include "Utility/StringExtractorGDBRemote.h"
50 #include "GDBRemoteRegisterContext.h"
51 #include "ProcessGDBRemote.h"
52 #include "ProcessGDBRemoteLog.h"
53 #include "ThreadGDBRemote.h"
54 #include "StopInfoMachException.h"
55 
56 
57 
58 #define DEBUGSERVER_BASENAME    "debugserver"
59 using namespace lldb;
60 using namespace lldb_private;
61 
62 static bool rand_initialized = false;
63 
64 static inline uint16_t
65 get_random_port ()
66 {
67     if (!rand_initialized)
68     {
69         time_t seed = time(NULL);
70 
71         rand_initialized = true;
72         srand(seed);
73     }
74     return (rand() % (UINT16_MAX - 1000u)) + 1000u;
75 }
76 
77 
78 const char *
79 ProcessGDBRemote::GetPluginNameStatic()
80 {
81     return "gdb-remote";
82 }
83 
84 const char *
85 ProcessGDBRemote::GetPluginDescriptionStatic()
86 {
87     return "GDB Remote protocol based debugging plug-in.";
88 }
89 
90 void
91 ProcessGDBRemote::Terminate()
92 {
93     PluginManager::UnregisterPlugin (ProcessGDBRemote::CreateInstance);
94 }
95 
96 
97 Process*
98 ProcessGDBRemote::CreateInstance (Target &target, Listener &listener)
99 {
100     return new ProcessGDBRemote (target, listener);
101 }
102 
103 bool
104 ProcessGDBRemote::CanDebug (Target &target, bool plugin_specified_by_name)
105 {
106     // For now we are just making sure the file exists for a given module
107     Module *exe_module = target.GetExecutableModulePointer();
108     if (exe_module)
109         return exe_module->GetFileSpec().Exists();
110     // However, if there is no executable module, we return true since we might be preparing to attach.
111     return true;
112 }
113 
114 //----------------------------------------------------------------------
115 // ProcessGDBRemote constructor
116 //----------------------------------------------------------------------
117 ProcessGDBRemote::ProcessGDBRemote(Target& target, Listener &listener) :
118     Process (target, listener),
119     m_flags (0),
120     m_stdio_mutex (Mutex::eMutexTypeRecursive),
121     m_gdb_comm(false),
122     m_debugserver_pid (LLDB_INVALID_PROCESS_ID),
123     m_debugserver_thread (LLDB_INVALID_HOST_THREAD),
124     m_last_stop_packet (),
125     m_register_info (),
126     m_async_broadcaster ("lldb.process.gdb-remote.async-broadcaster"),
127     m_async_thread (LLDB_INVALID_HOST_THREAD),
128     m_continue_c_tids (),
129     m_continue_C_tids (),
130     m_continue_s_tids (),
131     m_continue_S_tids (),
132     m_dispatch_queue_offsets_addr (LLDB_INVALID_ADDRESS),
133     m_max_memory_size (512),
134     m_waiting_for_attach (false),
135     m_thread_observation_bps()
136 {
137     m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadShouldExit,   "async thread should exit");
138     m_async_broadcaster.SetEventName (eBroadcastBitAsyncContinue,           "async thread continue");
139 }
140 
141 //----------------------------------------------------------------------
142 // Destructor
143 //----------------------------------------------------------------------
144 ProcessGDBRemote::~ProcessGDBRemote()
145 {
146     if (IS_VALID_LLDB_HOST_THREAD(m_debugserver_thread))
147     {
148         Host::ThreadCancel (m_debugserver_thread, NULL);
149         thread_result_t thread_result;
150         Host::ThreadJoin (m_debugserver_thread, &thread_result, NULL);
151         m_debugserver_thread = LLDB_INVALID_HOST_THREAD;
152     }
153     //  m_mach_process.UnregisterNotificationCallbacks (this);
154     Clear();
155 }
156 
157 //----------------------------------------------------------------------
158 // PluginInterface
159 //----------------------------------------------------------------------
160 const char *
161 ProcessGDBRemote::GetPluginName()
162 {
163     return "Process debugging plug-in that uses the GDB remote protocol";
164 }
165 
166 const char *
167 ProcessGDBRemote::GetShortPluginName()
168 {
169     return GetPluginNameStatic();
170 }
171 
172 uint32_t
173 ProcessGDBRemote::GetPluginVersion()
174 {
175     return 1;
176 }
177 
178 void
179 ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
180 {
181     if (!force && m_register_info.GetNumRegisters() > 0)
182         return;
183 
184     char packet[128];
185     m_register_info.Clear();
186     uint32_t reg_offset = 0;
187     uint32_t reg_num = 0;
188     StringExtractorGDBRemote::ResponseType response_type;
189     for (response_type = StringExtractorGDBRemote::eResponse;
190          response_type == StringExtractorGDBRemote::eResponse;
191          ++reg_num)
192     {
193         const int packet_len = ::snprintf (packet, sizeof(packet), "qRegisterInfo%x", reg_num);
194         assert (packet_len < sizeof(packet));
195         StringExtractorGDBRemote response;
196         if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, false))
197         {
198             response_type = response.GetResponseType();
199             if (response_type == StringExtractorGDBRemote::eResponse)
200             {
201                 std::string name;
202                 std::string value;
203                 ConstString reg_name;
204                 ConstString alt_name;
205                 ConstString set_name;
206                 RegisterInfo reg_info = { NULL,                 // Name
207                     NULL,                 // Alt name
208                     0,                    // byte size
209                     reg_offset,           // offset
210                     eEncodingUint,        // encoding
211                     eFormatHex,           // formate
212                     {
213                         LLDB_INVALID_REGNUM, // GCC reg num
214                         LLDB_INVALID_REGNUM, // DWARF reg num
215                         LLDB_INVALID_REGNUM, // generic reg num
216                         reg_num,             // GDB reg num
217                         reg_num           // native register number
218                     }
219                 };
220 
221                 while (response.GetNameColonValue(name, value))
222                 {
223                     if (name.compare("name") == 0)
224                     {
225                         reg_name.SetCString(value.c_str());
226                     }
227                     else if (name.compare("alt-name") == 0)
228                     {
229                         alt_name.SetCString(value.c_str());
230                     }
231                     else if (name.compare("bitsize") == 0)
232                     {
233                         reg_info.byte_size = Args::StringToUInt32(value.c_str(), 0, 0) / CHAR_BIT;
234                     }
235                     else if (name.compare("offset") == 0)
236                     {
237                         uint32_t offset = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0);
238                         if (reg_offset != offset)
239                         {
240                             reg_offset = offset;
241                         }
242                     }
243                     else if (name.compare("encoding") == 0)
244                     {
245                         if (value.compare("uint") == 0)
246                             reg_info.encoding = eEncodingUint;
247                         else if (value.compare("sint") == 0)
248                             reg_info.encoding = eEncodingSint;
249                         else if (value.compare("ieee754") == 0)
250                             reg_info.encoding = eEncodingIEEE754;
251                         else if (value.compare("vector") == 0)
252                             reg_info.encoding = eEncodingVector;
253                     }
254                     else if (name.compare("format") == 0)
255                     {
256                         if (value.compare("binary") == 0)
257                             reg_info.format = eFormatBinary;
258                         else if (value.compare("decimal") == 0)
259                             reg_info.format = eFormatDecimal;
260                         else if (value.compare("hex") == 0)
261                             reg_info.format = eFormatHex;
262                         else if (value.compare("float") == 0)
263                             reg_info.format = eFormatFloat;
264                         else if (value.compare("vector-sint8") == 0)
265                             reg_info.format = eFormatVectorOfSInt8;
266                         else if (value.compare("vector-uint8") == 0)
267                             reg_info.format = eFormatVectorOfUInt8;
268                         else if (value.compare("vector-sint16") == 0)
269                             reg_info.format = eFormatVectorOfSInt16;
270                         else if (value.compare("vector-uint16") == 0)
271                             reg_info.format = eFormatVectorOfUInt16;
272                         else if (value.compare("vector-sint32") == 0)
273                             reg_info.format = eFormatVectorOfSInt32;
274                         else if (value.compare("vector-uint32") == 0)
275                             reg_info.format = eFormatVectorOfUInt32;
276                         else if (value.compare("vector-float32") == 0)
277                             reg_info.format = eFormatVectorOfFloat32;
278                         else if (value.compare("vector-uint128") == 0)
279                             reg_info.format = eFormatVectorOfUInt128;
280                     }
281                     else if (name.compare("set") == 0)
282                     {
283                         set_name.SetCString(value.c_str());
284                     }
285                     else if (name.compare("gcc") == 0)
286                     {
287                         reg_info.kinds[eRegisterKindGCC] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
288                     }
289                     else if (name.compare("dwarf") == 0)
290                     {
291                         reg_info.kinds[eRegisterKindDWARF] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0);
292                     }
293                     else if (name.compare("generic") == 0)
294                     {
295                         if (value.compare("pc") == 0)
296                             reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
297                         else if (value.compare("sp") == 0)
298                             reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
299                         else if (value.compare("fp") == 0)
300                             reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
301                         else if (value.compare("ra") == 0)
302                             reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
303                         else if (value.compare("flags") == 0)
304                             reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
305                         else if (value.find("arg") == 0)
306                         {
307                             if (value.size() == 4)
308                             {
309                                 switch (value[3])
310                                 {
311                                     case '1': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG1; break;
312                                     case '2': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG2; break;
313                                     case '3': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG3; break;
314                                     case '4': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG4; break;
315                                     case '5': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG5; break;
316                                     case '6': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG6; break;
317                                     case '7': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG7; break;
318                                     case '8': reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_ARG8; break;
319                                 }
320                             }
321                         }
322                     }
323                 }
324 
325                 reg_info.byte_offset = reg_offset;
326                 assert (reg_info.byte_size != 0);
327                 reg_offset += reg_info.byte_size;
328                 m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name);
329             }
330         }
331         else
332         {
333             response_type = StringExtractorGDBRemote::eError;
334             break;
335         }
336     }
337 
338     if (reg_num == 0)
339     {
340         // We didn't get anything. See if we are debugging ARM and fill with
341         // a hard coded register set until we can get an updated debugserver
342         // down on the devices.
343         if (GetTarget().GetArchitecture().GetMachine() == llvm::Triple::arm)
344             m_register_info.HardcodeARMRegisters();
345     }
346     m_register_info.Finalize ();
347 }
348 
349 Error
350 ProcessGDBRemote::WillLaunch (Module* module)
351 {
352     return WillLaunchOrAttach ();
353 }
354 
355 Error
356 ProcessGDBRemote::WillAttachToProcessWithID (lldb::pid_t pid)
357 {
358     return WillLaunchOrAttach ();
359 }
360 
361 Error
362 ProcessGDBRemote::WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
363 {
364     return WillLaunchOrAttach ();
365 }
366 
367 Error
368 ProcessGDBRemote::DoConnectRemote (const char *remote_url)
369 {
370     Error error (WillLaunchOrAttach ());
371 
372     if (error.Fail())
373         return error;
374 
375     error = ConnectToDebugserver (remote_url);
376 
377     if (error.Fail())
378         return error;
379     StartAsyncThread ();
380 
381     lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID ();
382     if (pid == LLDB_INVALID_PROCESS_ID)
383     {
384         // We don't have a valid process ID, so note that we are connected
385         // and could now request to launch or attach, or get remote process
386         // listings...
387         SetPrivateState (eStateConnected);
388     }
389     else
390     {
391         // We have a valid process
392         SetID (pid);
393         GetThreadList();
394         if (m_gdb_comm.SendPacketAndWaitForResponse("?", 1, m_last_stop_packet, false))
395         {
396             const StateType state = SetThreadStopInfo (m_last_stop_packet);
397             if (state == eStateStopped)
398             {
399                 SetPrivateState (state);
400             }
401             else
402                 error.SetErrorStringWithFormat ("Process %i was reported after connecting to '%s', but state was not stopped: %s", pid, remote_url, StateAsCString (state));
403         }
404         else
405             error.SetErrorStringWithFormat ("Process %i was reported after connecting to '%s', but no stop reply packet was received", pid, remote_url);
406     }
407     return error;
408 }
409 
410 Error
411 ProcessGDBRemote::WillLaunchOrAttach ()
412 {
413     Error error;
414     m_stdio_communication.Clear ();
415     return error;
416 }
417 
418 //----------------------------------------------------------------------
419 // Process Control
420 //----------------------------------------------------------------------
421 Error
422 ProcessGDBRemote::DoLaunch
423 (
424     Module* module,
425     char const *argv[],
426     char const *envp[],
427     uint32_t launch_flags,
428     const char *stdin_path,
429     const char *stdout_path,
430     const char *stderr_path,
431     const char *working_dir
432 )
433 {
434     Error error;
435     //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
436     //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
437     //  ::LogSetLogFile ("/dev/stdout");
438     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
439 
440     ObjectFile * object_file = module->GetObjectFile();
441     if (object_file)
442     {
443         char host_port[128];
444         snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ());
445         char connect_url[128];
446         snprintf (connect_url, sizeof(connect_url), "connect://%s", host_port);
447 
448         // Make sure we aren't already connected?
449         if (!m_gdb_comm.IsConnected())
450         {
451             error = StartDebugserverProcess (host_port);
452             if (error.Fail())
453             {
454                 if (log)
455                     log->Printf("failed to start debugserver process: %s", error.AsCString());
456                 return error;
457             }
458 
459             error = ConnectToDebugserver (connect_url);
460         }
461 
462         if (error.Success())
463         {
464             lldb_utility::PseudoTerminal pty;
465             const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
466 
467             // If the debugserver is local and we aren't disabling STDIO, lets use
468             // a pseudo terminal to instead of relying on the 'O' packets for stdio
469             // since 'O' packets can really slow down debugging if the inferior
470             // does a lot of output.
471             PlatformSP platform_sp (m_target.GetPlatform());
472             if (platform_sp && platform_sp->IsHost() && !disable_stdio)
473             {
474                 const char *slave_name = NULL;
475                 if (stdin_path == NULL || stdout_path == NULL || stderr_path == NULL)
476                 {
477                     if (pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0))
478                         slave_name = pty.GetSlaveName (NULL, 0);
479                 }
480                 if (stdin_path == NULL)
481                     stdin_path = slave_name;
482 
483                 if (stdout_path == NULL)
484                     stdout_path = slave_name;
485 
486                 if (stderr_path == NULL)
487                     stderr_path = slave_name;
488             }
489 
490             // Set STDIN to /dev/null if we want STDIO disabled or if either
491             // STDOUT or STDERR have been set to something and STDIN hasn't
492             if (disable_stdio || (stdin_path == NULL && (stdout_path || stderr_path)))
493                 stdin_path = "/dev/null";
494 
495             // Set STDOUT to /dev/null if we want STDIO disabled or if either
496             // STDIN or STDERR have been set to something and STDOUT hasn't
497             if (disable_stdio || (stdout_path == NULL && (stdin_path || stderr_path)))
498                 stdout_path = "/dev/null";
499 
500             // Set STDERR to /dev/null if we want STDIO disabled or if either
501             // STDIN or STDOUT have been set to something and STDERR hasn't
502             if (disable_stdio || (stderr_path == NULL && (stdin_path || stdout_path)))
503                 stderr_path = "/dev/null";
504 
505             if (stdin_path)
506                 m_gdb_comm.SetSTDIN (stdin_path);
507             if (stdout_path)
508                 m_gdb_comm.SetSTDOUT (stdout_path);
509             if (stderr_path)
510                 m_gdb_comm.SetSTDERR (stderr_path);
511 
512             m_gdb_comm.SetDisableASLR (launch_flags & eLaunchFlagDisableASLR);
513 
514             m_gdb_comm.SendLaunchArchPacket (m_target.GetArchitecture().GetArchitectureName());
515 
516             if (working_dir && working_dir[0])
517             {
518                 m_gdb_comm.SetWorkingDir (working_dir);
519             }
520 
521             // Send the environment and the program + arguments after we connect
522             if (envp)
523             {
524                 const char *env_entry;
525                 for (int i=0; (env_entry = envp[i]); ++i)
526                 {
527                     if (m_gdb_comm.SendEnvironmentPacket(env_entry) != 0)
528                         break;
529                 }
530             }
531 
532             const uint32_t old_packet_timeout = m_gdb_comm.SetPacketTimeout (10);
533             int arg_packet_err = m_gdb_comm.SendArgumentsPacket (argv);
534             if (arg_packet_err == 0)
535             {
536                 std::string error_str;
537                 if (m_gdb_comm.GetLaunchSuccess (error_str))
538                 {
539                     SetID (m_gdb_comm.GetCurrentProcessID ());
540                 }
541                 else
542                 {
543                     error.SetErrorString (error_str.c_str());
544                 }
545             }
546             else
547             {
548                 error.SetErrorStringWithFormat("'A' packet returned an error: %i.\n", arg_packet_err);
549             }
550 
551             m_gdb_comm.SetPacketTimeout (old_packet_timeout);
552 
553             if (GetID() == LLDB_INVALID_PROCESS_ID)
554             {
555                 if (log)
556                     log->Printf("failed to connect to debugserver: %s", error.AsCString());
557                 KillDebugserverProcess ();
558                 return error;
559             }
560 
561             if (m_gdb_comm.SendPacketAndWaitForResponse("?", 1, m_last_stop_packet, false))
562             {
563                 SetPrivateState (SetThreadStopInfo (m_last_stop_packet));
564 
565                 if (!disable_stdio)
566                 {
567                     if (pty.GetMasterFileDescriptor() != lldb_utility::PseudoTerminal::invalid_fd)
568                         SetUpProcessInputReader (pty.ReleaseMasterFileDescriptor());
569                 }
570             }
571         }
572         else
573         {
574             if (log)
575                 log->Printf("failed to connect to debugserver: %s", error.AsCString());
576         }
577     }
578     else
579     {
580         // Set our user ID to an invalid process ID.
581         SetID(LLDB_INVALID_PROCESS_ID);
582         error.SetErrorStringWithFormat("Failed to get object file from '%s' for arch %s.\n",
583                                        module->GetFileSpec().GetFilename().AsCString(),
584                                        module->GetArchitecture().GetArchitectureName());
585     }
586     return error;
587 
588 }
589 
590 
591 Error
592 ProcessGDBRemote::ConnectToDebugserver (const char *connect_url)
593 {
594     Error error;
595     // Sleep and wait a bit for debugserver to start to listen...
596     std::auto_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
597     if (conn_ap.get())
598     {
599         const uint32_t max_retry_count = 50;
600         uint32_t retry_count = 0;
601         while (!m_gdb_comm.IsConnected())
602         {
603             if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess)
604             {
605                 m_gdb_comm.SetConnection (conn_ap.release());
606                 break;
607             }
608             retry_count++;
609 
610             if (retry_count >= max_retry_count)
611                 break;
612 
613             usleep (100000);
614         }
615     }
616 
617     if (!m_gdb_comm.IsConnected())
618     {
619         if (error.Success())
620             error.SetErrorString("not connected to remote gdb server");
621         return error;
622     }
623 
624     // We always seem to be able to open a connection to a local port
625     // so we need to make sure we can then send data to it. If we can't
626     // then we aren't actually connected to anything, so try and do the
627     // handshake with the remote GDB server and make sure that goes
628     // alright.
629     if (!m_gdb_comm.HandshakeWithServer (NULL))
630     {
631         m_gdb_comm.Disconnect();
632         if (error.Success())
633             error.SetErrorString("not connected to remote gdb server");
634         return error;
635     }
636     if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID)
637         m_debugserver_thread = Host::StartMonitoringChildProcess (MonitorDebugserverProcess,
638                                                                   this,
639                                                                   m_debugserver_pid,
640                                                                   false);
641     m_gdb_comm.ResetDiscoverableSettings();
642     m_gdb_comm.QueryNoAckModeSupported ();
643     m_gdb_comm.GetThreadSuffixSupported ();
644     m_gdb_comm.GetHostInfo ();
645     m_gdb_comm.GetVContSupported ('c');
646     return error;
647 }
648 
649 void
650 ProcessGDBRemote::DidLaunchOrAttach ()
651 {
652     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
653     if (log)
654         log->Printf ("ProcessGDBRemote::DidLaunch()");
655     if (GetID() != LLDB_INVALID_PROCESS_ID)
656     {
657         m_dispatch_queue_offsets_addr = LLDB_INVALID_ADDRESS;
658 
659         BuildDynamicRegisterInfo (false);
660 
661         // See if the GDB server supports the qHostInfo information
662 
663         const ArchSpec &gdb_remote_arch = m_gdb_comm.GetHostArchitecture();
664         if (gdb_remote_arch.IsValid())
665         {
666             ArchSpec &target_arch = GetTarget().GetArchitecture();
667 
668             if (target_arch.IsValid())
669             {
670                 // If the remote host is ARM and we have apple as the vendor, then
671                 // ARM executables and shared libraries can have mixed ARM architectures.
672                 // You can have an armv6 executable, and if the host is armv7, then the
673                 // system will load the best possible architecture for all shared libraries
674                 // it has, so we really need to take the remote host architecture as our
675                 // defacto architecture in this case.
676 
677                 if (gdb_remote_arch.GetMachine() == llvm::Triple::arm &&
678                     gdb_remote_arch.GetTriple().getVendor() == llvm::Triple::Apple)
679                 {
680                     target_arch = gdb_remote_arch;
681                 }
682                 else
683                 {
684                     // Fill in what is missing in the triple
685                     const llvm::Triple &remote_triple = gdb_remote_arch.GetTriple();
686                     llvm::Triple &target_triple = target_arch.GetTriple();
687                     if (target_triple.getVendorName().size() == 0)
688                     {
689                         target_triple.setVendor (remote_triple.getVendor());
690 
691                         if (target_triple.getOSName().size() == 0)
692                         {
693                             target_triple.setOS (remote_triple.getOS());
694 
695                             if (target_triple.getEnvironmentName().size() == 0)
696                                 target_triple.setEnvironment (remote_triple.getEnvironment());
697                         }
698                     }
699                 }
700             }
701             else
702             {
703                 // The target doesn't have a valid architecture yet, set it from
704                 // the architecture we got from the remote GDB server
705                 target_arch = gdb_remote_arch;
706             }
707         }
708     }
709 }
710 
711 void
712 ProcessGDBRemote::DidLaunch ()
713 {
714     DidLaunchOrAttach ();
715 }
716 
717 Error
718 ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid)
719 {
720     Error error;
721     // Clear out and clean up from any current state
722     Clear();
723     if (attach_pid != LLDB_INVALID_PROCESS_ID)
724     {
725         // Make sure we aren't already connected?
726         if (!m_gdb_comm.IsConnected())
727         {
728             char host_port[128];
729             snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ());
730             char connect_url[128];
731             snprintf (connect_url, sizeof(connect_url), "connect://%s", host_port);
732 
733             error = StartDebugserverProcess (host_port);
734 
735             if (error.Fail())
736             {
737                 const char *error_string = error.AsCString();
738                 if (error_string == NULL)
739                     error_string = "unable to launch " DEBUGSERVER_BASENAME;
740 
741                 SetExitStatus (-1, error_string);
742             }
743             else
744             {
745                 error = ConnectToDebugserver (connect_url);
746             }
747         }
748 
749         if (error.Success())
750         {
751             char packet[64];
752             const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%x", attach_pid);
753 
754             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet, packet_len));
755         }
756     }
757     return error;
758 }
759 
760 size_t
761 ProcessGDBRemote::AttachInputReaderCallback
762 (
763     void *baton,
764     InputReader *reader,
765     lldb::InputReaderAction notification,
766     const char *bytes,
767     size_t bytes_len
768 )
769 {
770     if (notification == eInputReaderGotToken)
771     {
772         ProcessGDBRemote *gdb_process = (ProcessGDBRemote *)baton;
773         if (gdb_process->m_waiting_for_attach)
774             gdb_process->m_waiting_for_attach = false;
775         reader->SetIsDone(true);
776         return 1;
777     }
778     return 0;
779 }
780 
781 Error
782 ProcessGDBRemote::DoAttachToProcessWithName (const char *process_name, bool wait_for_launch)
783 {
784     Error error;
785     // Clear out and clean up from any current state
786     Clear();
787 
788     if (process_name && process_name[0])
789     {
790         // Make sure we aren't already connected?
791         if (!m_gdb_comm.IsConnected())
792         {
793             char host_port[128];
794             snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ());
795             char connect_url[128];
796             snprintf (connect_url, sizeof(connect_url), "connect://%s", host_port);
797 
798             error = StartDebugserverProcess (host_port);
799             if (error.Fail())
800             {
801                 const char *error_string = error.AsCString();
802                 if (error_string == NULL)
803                     error_string = "unable to launch " DEBUGSERVER_BASENAME;
804 
805                 SetExitStatus (-1, error_string);
806             }
807             else
808             {
809                 error = ConnectToDebugserver (connect_url);
810             }
811         }
812 
813         if (error.Success())
814         {
815             StreamString packet;
816 
817             if (wait_for_launch)
818                 packet.PutCString("vAttachWait");
819             else
820                 packet.PutCString("vAttachName");
821             packet.PutChar(';');
822             packet.PutBytesAsRawHex8(process_name, strlen(process_name), lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
823 
824             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet.GetData(), packet.GetSize()));
825 
826         }
827     }
828     return error;
829 }
830 
831 
832 void
833 ProcessGDBRemote::DidAttach ()
834 {
835     DidLaunchOrAttach ();
836 }
837 
838 Error
839 ProcessGDBRemote::WillResume ()
840 {
841     m_continue_c_tids.clear();
842     m_continue_C_tids.clear();
843     m_continue_s_tids.clear();
844     m_continue_S_tids.clear();
845     return Error();
846 }
847 
848 Error
849 ProcessGDBRemote::DoResume ()
850 {
851     Error error;
852     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
853     if (log)
854         log->Printf ("ProcessGDBRemote::Resume()");
855 
856     Listener listener ("gdb-remote.resume-packet-sent");
857     if (listener.StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent))
858     {
859         StreamString continue_packet;
860         bool continue_packet_error = false;
861         if (m_gdb_comm.HasAnyVContSupport ())
862         {
863             continue_packet.PutCString ("vCont");
864 
865             if (!m_continue_c_tids.empty())
866             {
867                 if (m_gdb_comm.GetVContSupported ('c'))
868                 {
869                     for (tid_collection::const_iterator t_pos = m_continue_c_tids.begin(), t_end = m_continue_c_tids.end(); t_pos != t_end; ++t_pos)
870                         continue_packet.Printf(";c:%4.4x", *t_pos);
871                 }
872                 else
873                     continue_packet_error = true;
874             }
875 
876             if (!continue_packet_error && !m_continue_C_tids.empty())
877             {
878                 if (m_gdb_comm.GetVContSupported ('C'))
879                 {
880                     for (tid_sig_collection::const_iterator s_pos = m_continue_C_tids.begin(), s_end = m_continue_C_tids.end(); s_pos != s_end; ++s_pos)
881                         continue_packet.Printf(";C%2.2x:%4.4x", s_pos->second, s_pos->first);
882                 }
883                 else
884                     continue_packet_error = true;
885             }
886 
887             if (!continue_packet_error && !m_continue_s_tids.empty())
888             {
889                 if (m_gdb_comm.GetVContSupported ('s'))
890                 {
891                     for (tid_collection::const_iterator t_pos = m_continue_s_tids.begin(), t_end = m_continue_s_tids.end(); t_pos != t_end; ++t_pos)
892                         continue_packet.Printf(";s:%4.4x", *t_pos);
893                 }
894                 else
895                     continue_packet_error = true;
896             }
897 
898             if (!continue_packet_error && !m_continue_S_tids.empty())
899             {
900                 if (m_gdb_comm.GetVContSupported ('S'))
901                 {
902                     for (tid_sig_collection::const_iterator s_pos = m_continue_S_tids.begin(), s_end = m_continue_S_tids.end(); s_pos != s_end; ++s_pos)
903                         continue_packet.Printf(";S%2.2x:%4.4x", s_pos->second, s_pos->first);
904                 }
905                 else
906                     continue_packet_error = true;
907             }
908 
909             if (continue_packet_error)
910                 continue_packet.GetString().clear();
911         }
912         else
913             continue_packet_error = true;
914 
915         if (continue_packet_error)
916         {
917             // Either no vCont support, or we tried to use part of the vCont
918             // packet that wasn't supported by the remote GDB server.
919             // We need to try and make a simple packet that can do our continue
920             const size_t num_threads = GetThreadList().GetSize();
921             const size_t num_continue_c_tids = m_continue_c_tids.size();
922             const size_t num_continue_C_tids = m_continue_C_tids.size();
923             const size_t num_continue_s_tids = m_continue_s_tids.size();
924             const size_t num_continue_S_tids = m_continue_S_tids.size();
925             if (num_continue_c_tids > 0)
926             {
927                 if (num_continue_c_tids == num_threads)
928                 {
929                     // All threads are resuming...
930                     m_gdb_comm.SetCurrentThreadForRun (-1);
931                     continue_packet.PutChar ('c');
932                     continue_packet_error = false;
933                 }
934                 else if (num_continue_c_tids == 1 &&
935                          num_continue_C_tids == 0 &&
936                          num_continue_s_tids == 0 &&
937                          num_continue_S_tids == 0 )
938                 {
939                     // Only one thread is continuing
940                     m_gdb_comm.SetCurrentThreadForRun (m_continue_c_tids.front());
941                     continue_packet.PutChar ('c');
942                     continue_packet_error = false;
943                 }
944             }
945 
946             if (continue_packet_error && num_continue_C_tids > 0)
947             {
948                 if ((num_continue_C_tids + num_continue_c_tids) == num_threads &&
949                     num_continue_C_tids > 0 &&
950                     num_continue_s_tids == 0 &&
951                     num_continue_S_tids == 0 )
952                 {
953                     const int continue_signo = m_continue_C_tids.front().second;
954                     // Only one thread is continuing
955                     if (num_continue_C_tids > 1)
956                     {
957                         // More that one thread with a signal, yet we don't have
958                         // vCont support and we are being asked to resume each
959                         // thread with a signal, we need to make sure they are
960                         // all the same signal, or we can't issue the continue
961                         // accurately with the current support...
962                         if (num_continue_C_tids > 1)
963                         {
964                             continue_packet_error = false;
965                             for (size_t i=1; i<m_continue_C_tids.size(); ++i)
966                             {
967                                 if (m_continue_C_tids[i].second != continue_signo)
968                                     continue_packet_error = true;
969                             }
970                         }
971                         if (!continue_packet_error)
972                             m_gdb_comm.SetCurrentThreadForRun (-1);
973                     }
974                     else
975                     {
976                         // Set the continue thread ID
977                         continue_packet_error = false;
978                         m_gdb_comm.SetCurrentThreadForRun (m_continue_C_tids.front().first);
979                     }
980                     if (!continue_packet_error)
981                     {
982                         // Add threads continuing with the same signo...
983                         continue_packet.Printf("C%2.2x", continue_signo);
984                     }
985                 }
986             }
987 
988             if (continue_packet_error && num_continue_s_tids > 0)
989             {
990                 if (num_continue_s_tids == num_threads)
991                 {
992                     // All threads are resuming...
993                     m_gdb_comm.SetCurrentThreadForRun (-1);
994                     continue_packet.PutChar ('s');
995                     continue_packet_error = false;
996                 }
997                 else if (num_continue_c_tids == 0 &&
998                          num_continue_C_tids == 0 &&
999                          num_continue_s_tids == 1 &&
1000                          num_continue_S_tids == 0 )
1001                 {
1002                     // Only one thread is stepping
1003                     m_gdb_comm.SetCurrentThreadForRun (m_continue_s_tids.front());
1004                     continue_packet.PutChar ('s');
1005                     continue_packet_error = false;
1006                 }
1007             }
1008 
1009             if (!continue_packet_error && num_continue_S_tids > 0)
1010             {
1011                 if (num_continue_S_tids == num_threads)
1012                 {
1013                     const int step_signo = m_continue_S_tids.front().second;
1014                     // Are all threads trying to step with the same signal?
1015                     continue_packet_error = false;
1016                     if (num_continue_S_tids > 1)
1017                     {
1018                         for (size_t i=1; i<num_threads; ++i)
1019                         {
1020                             if (m_continue_S_tids[i].second != step_signo)
1021                                 continue_packet_error = true;
1022                         }
1023                     }
1024                     if (!continue_packet_error)
1025                     {
1026                         // Add threads stepping with the same signo...
1027                         m_gdb_comm.SetCurrentThreadForRun (-1);
1028                         continue_packet.Printf("S%2.2x", step_signo);
1029                     }
1030                 }
1031                 else if (num_continue_c_tids == 0 &&
1032                          num_continue_C_tids == 0 &&
1033                          num_continue_s_tids == 0 &&
1034                          num_continue_S_tids == 1 )
1035                 {
1036                     // Only one thread is stepping with signal
1037                     m_gdb_comm.SetCurrentThreadForRun (m_continue_S_tids.front().first);
1038                     continue_packet.Printf("S%2.2x", m_continue_S_tids.front().second);
1039                     continue_packet_error = false;
1040                 }
1041             }
1042         }
1043 
1044         if (continue_packet_error)
1045         {
1046             error.SetErrorString ("can't make continue packet for this resume");
1047         }
1048         else
1049         {
1050             EventSP event_sp;
1051             TimeValue timeout;
1052             timeout = TimeValue::Now();
1053             timeout.OffsetWithSeconds (5);
1054             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (continue_packet.GetData(), continue_packet.GetSize()));
1055 
1056             if (listener.WaitForEvent (&timeout, event_sp) == false)
1057                 error.SetErrorString("Resume timed out.");
1058         }
1059     }
1060 
1061     return error;
1062 }
1063 
1064 uint32_t
1065 ProcessGDBRemote::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list)
1066 {
1067     // locker will keep a mutex locked until it goes out of scope
1068     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_THREAD));
1069     if (log && log->GetMask().Test(GDBR_LOG_VERBOSE))
1070         log->Printf ("ProcessGDBRemote::%s (pid = %i)", __FUNCTION__, GetID());
1071     // Update the thread list's stop id immediately so we don't recurse into this function.
1072 
1073     std::vector<lldb::tid_t> thread_ids;
1074     bool sequence_mutex_unavailable = false;
1075     const size_t num_thread_ids = m_gdb_comm.GetCurrentThreadIDs (thread_ids, sequence_mutex_unavailable);
1076     if (num_thread_ids > 0)
1077     {
1078         for (size_t i=0; i<num_thread_ids; ++i)
1079         {
1080             tid_t tid = thread_ids[i];
1081             ThreadSP thread_sp (old_thread_list.FindThreadByID (tid, false));
1082             if (!thread_sp)
1083                 thread_sp.reset (new ThreadGDBRemote (*this, tid));
1084             new_thread_list.AddThread(thread_sp);
1085         }
1086     }
1087 
1088     if (sequence_mutex_unavailable == false)
1089         SetThreadStopInfo (m_last_stop_packet);
1090     return new_thread_list.GetSize(false);
1091 }
1092 
1093 
1094 StateType
1095 ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
1096 {
1097     stop_packet.SetFilePos (0);
1098     const char stop_type = stop_packet.GetChar();
1099     switch (stop_type)
1100     {
1101     case 'T':
1102     case 'S':
1103         {
1104             if (GetStopID() == 0)
1105             {
1106                 // Our first stop, make sure we have a process ID, and also make
1107                 // sure we know about our registers
1108                 if (GetID() == LLDB_INVALID_PROCESS_ID)
1109                 {
1110                     lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID ();
1111                     if (pid != LLDB_INVALID_PROCESS_ID)
1112                         SetID (pid);
1113                 }
1114                 BuildDynamicRegisterInfo (true);
1115             }
1116             // Stop with signal and thread info
1117             const uint8_t signo = stop_packet.GetHexU8();
1118             std::string name;
1119             std::string value;
1120             std::string thread_name;
1121             std::string reason;
1122             std::string description;
1123             uint32_t exc_type = 0;
1124             std::vector<addr_t> exc_data;
1125             uint32_t tid = LLDB_INVALID_THREAD_ID;
1126             addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
1127             uint32_t exc_data_count = 0;
1128             ThreadSP thread_sp;
1129 
1130             while (stop_packet.GetNameColonValue(name, value))
1131             {
1132                 if (name.compare("metype") == 0)
1133                 {
1134                     // exception type in big endian hex
1135                     exc_type = Args::StringToUInt32 (value.c_str(), 0, 16);
1136                 }
1137                 else if (name.compare("mecount") == 0)
1138                 {
1139                     // exception count in big endian hex
1140                     exc_data_count = Args::StringToUInt32 (value.c_str(), 0, 16);
1141                 }
1142                 else if (name.compare("medata") == 0)
1143                 {
1144                     // exception data in big endian hex
1145                     exc_data.push_back(Args::StringToUInt64 (value.c_str(), 0, 16));
1146                 }
1147                 else if (name.compare("thread") == 0)
1148                 {
1149                     // thread in big endian hex
1150                     tid = Args::StringToUInt32 (value.c_str(), 0, 16);
1151                     Mutex::Locker locker (m_thread_list.GetMutex ());
1152                     thread_sp = m_thread_list.FindThreadByID(tid, false);
1153                     if (!thread_sp)
1154                     {
1155                         // Create the thread if we need to
1156                         thread_sp.reset (new ThreadGDBRemote (*this, tid));
1157                         m_thread_list.AddThread(thread_sp);
1158                     }
1159                 }
1160                 else if (name.compare("hexname") == 0)
1161                 {
1162                     StringExtractor name_extractor;
1163                     // Swap "value" over into "name_extractor"
1164                     name_extractor.GetStringRef().swap(value);
1165                     // Now convert the HEX bytes into a string value
1166                     name_extractor.GetHexByteString (value);
1167                     thread_name.swap (value);
1168                 }
1169                 else if (name.compare("name") == 0)
1170                 {
1171                     thread_name.swap (value);
1172                 }
1173                 else if (name.compare("qaddr") == 0)
1174                 {
1175                     thread_dispatch_qaddr = Args::StringToUInt64 (value.c_str(), 0, 16);
1176                 }
1177                 else if (name.compare("reason") == 0)
1178                 {
1179                     reason.swap(value);
1180                 }
1181                 else if (name.compare("description") == 0)
1182                 {
1183                     StringExtractor desc_extractor;
1184                     // Swap "value" over into "name_extractor"
1185                     desc_extractor.GetStringRef().swap(value);
1186                     // Now convert the HEX bytes into a string value
1187                     desc_extractor.GetHexByteString (thread_name);
1188                 }
1189                 else if (name.size() == 2 && ::isxdigit(name[0]) && ::isxdigit(name[1]))
1190                 {
1191                     // We have a register number that contains an expedited
1192                     // register value. Lets supply this register to our thread
1193                     // so it won't have to go and read it.
1194                     if (thread_sp)
1195                     {
1196                         uint32_t reg = Args::StringToUInt32 (name.c_str(), UINT32_MAX, 16);
1197 
1198                         if (reg != UINT32_MAX)
1199                         {
1200                             StringExtractor reg_value_extractor;
1201                             // Swap "value" over into "reg_value_extractor"
1202                             reg_value_extractor.GetStringRef().swap(value);
1203                             if (!static_cast<ThreadGDBRemote *> (thread_sp.get())->PrivateSetRegisterValue (reg, reg_value_extractor))
1204                             {
1205                                 Host::SetCrashDescriptionWithFormat("Setting thread register '%s' (decoded to %u (0x%x)) with value '%s' for stop packet: '%s'",
1206                                                                     name.c_str(),
1207                                                                     reg,
1208                                                                     reg,
1209                                                                     reg_value_extractor.GetStringRef().c_str(),
1210                                                                     stop_packet.GetStringRef().c_str());
1211                             }
1212                         }
1213                     }
1214                 }
1215             }
1216 
1217             if (thread_sp)
1218             {
1219                 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
1220 
1221                 gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr);
1222                 gdb_thread->SetName (thread_name.empty() ? NULL : thread_name.c_str());
1223                 if (exc_type != 0)
1224                 {
1225                     const size_t exc_data_size = exc_data.size();
1226 
1227                     gdb_thread->SetStopInfo (StopInfoMachException::CreateStopReasonWithMachException (*thread_sp,
1228                                                                                                        exc_type,
1229                                                                                                        exc_data_size,
1230                                                                                                        exc_data_size >= 1 ? exc_data[0] : 0,
1231                                                                                                        exc_data_size >= 2 ? exc_data[1] : 0));
1232                 }
1233                 else
1234                 {
1235                     bool handled = false;
1236                     if (!reason.empty())
1237                     {
1238                         if (reason.compare("trace") == 0)
1239                         {
1240                             gdb_thread->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp));
1241                             handled = true;
1242                         }
1243                         else if (reason.compare("breakpoint") == 0)
1244                         {
1245                             addr_t pc = gdb_thread->GetRegisterContext()->GetPC();
1246                             lldb::BreakpointSiteSP bp_site_sp = gdb_thread->GetProcess().GetBreakpointSiteList().FindByAddress(pc);
1247                             if (bp_site_sp)
1248                             {
1249                                 // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
1250                                 // we can just report no reason.  We don't need to worry about stepping over the breakpoint here, that
1251                                 // will be taken care of when the thread resumes and notices that there's a breakpoint under the pc.
1252                                 if (bp_site_sp->ValidForThisThread (gdb_thread))
1253                                 {
1254                                     gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID (*thread_sp, bp_site_sp->GetID()));
1255                                     handled = true;
1256                                 }
1257                             }
1258 
1259                             if (!handled)
1260                             {
1261                                 gdb_thread->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp));
1262                             }
1263                         }
1264                         else if (reason.compare("trap") == 0)
1265                         {
1266                             // Let the trap just use the standard signal stop reason below...
1267                         }
1268                         else if (reason.compare("watchpoint") == 0)
1269                         {
1270                             break_id_t watch_id = LLDB_INVALID_WATCH_ID;
1271                             // TODO: locate the watchpoint somehow...
1272                             gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithWatchpointID (*thread_sp, watch_id));
1273                             handled = true;
1274                         }
1275                         else if (reason.compare("exception") == 0)
1276                         {
1277                             gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithException(*thread_sp, description.c_str()));
1278                             handled = true;
1279                         }
1280                     }
1281 
1282                     if (signo)
1283                     {
1284                         if (signo == SIGTRAP)
1285                         {
1286                             // Currently we are going to assume SIGTRAP means we are either
1287                             // hitting a breakpoint or hardware single stepping.
1288                             addr_t pc = gdb_thread->GetRegisterContext()->GetPC();
1289                             lldb::BreakpointSiteSP bp_site_sp = gdb_thread->GetProcess().GetBreakpointSiteList().FindByAddress(pc);
1290                             if (bp_site_sp)
1291                             {
1292                                 // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
1293                                 // we can just report no reason.  We don't need to worry about stepping over the breakpoint here, that
1294                                 // will be taken care of when the thread resumes and notices that there's a breakpoint under the pc.
1295                                 if (bp_site_sp->ValidForThisThread (gdb_thread))
1296                                 {
1297                                     gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID (*thread_sp, bp_site_sp->GetID()));
1298                                     handled = true;
1299                                 }
1300                             }
1301                             if (!handled)
1302                             {
1303                                 // TODO: check for breakpoint or trap opcode in case there is a hard
1304                                 // coded software trap
1305                                 gdb_thread->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp));
1306                                 handled = true;
1307                             }
1308                         }
1309                         if (!handled)
1310                             gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo));
1311                 }
1312                 else
1313                 {
1314                     StopInfoSP invalid_stop_info_sp;
1315                     gdb_thread->SetStopInfo (invalid_stop_info_sp);
1316                 }
1317 
1318                     if (!description.empty())
1319                     {
1320                         lldb::StopInfoSP stop_info_sp (gdb_thread->GetStopInfo ());
1321                         if (stop_info_sp)
1322                         {
1323                             stop_info_sp->SetDescription (description.c_str());
1324                         }
1325                         else
1326                         {
1327                             gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithException (*thread_sp, description.c_str()));
1328                         }
1329                     }
1330                 }
1331             }
1332             return eStateStopped;
1333         }
1334         break;
1335 
1336     case 'W':
1337         // process exited
1338         return eStateExited;
1339 
1340     default:
1341         break;
1342     }
1343     return eStateInvalid;
1344 }
1345 
1346 void
1347 ProcessGDBRemote::RefreshStateAfterStop ()
1348 {
1349     // Let all threads recover from stopping and do any clean up based
1350     // on the previous thread state (if any).
1351     m_thread_list.RefreshStateAfterStop();
1352     SetThreadStopInfo (m_last_stop_packet);
1353 }
1354 
1355 Error
1356 ProcessGDBRemote::DoHalt (bool &caused_stop)
1357 {
1358     Error error;
1359 
1360     bool timed_out = false;
1361     Mutex::Locker locker;
1362 
1363     if (m_public_state.GetValue() == eStateAttaching)
1364     {
1365         // We are being asked to halt during an attach. We need to just close
1366         // our file handle and debugserver will go away, and we can be done...
1367         m_gdb_comm.Disconnect();
1368     }
1369     else
1370     {
1371         if (!m_gdb_comm.SendInterrupt (locker, 2, caused_stop, timed_out))
1372         {
1373             if (timed_out)
1374                 error.SetErrorString("timed out sending interrupt packet");
1375             else
1376                 error.SetErrorString("unknown error sending interrupt packet");
1377         }
1378     }
1379     return error;
1380 }
1381 
1382 Error
1383 ProcessGDBRemote::InterruptIfRunning
1384 (
1385     bool discard_thread_plans,
1386     bool catch_stop_event,
1387     EventSP &stop_event_sp
1388 )
1389 {
1390     Error error;
1391 
1392     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1393 
1394     bool paused_private_state_thread = false;
1395     const bool is_running = m_gdb_comm.IsRunning();
1396     if (log)
1397         log->Printf ("ProcessGDBRemote::InterruptIfRunning(discard_thread_plans=%i, catch_stop_event=%i) is_running=%i",
1398                      discard_thread_plans,
1399                      catch_stop_event,
1400                      is_running);
1401 
1402     if (discard_thread_plans)
1403     {
1404         if (log)
1405             log->Printf ("ProcessGDBRemote::InterruptIfRunning() discarding all thread plans");
1406         m_thread_list.DiscardThreadPlans();
1407     }
1408     if (is_running)
1409     {
1410         if (catch_stop_event)
1411         {
1412             if (log)
1413                 log->Printf ("ProcessGDBRemote::InterruptIfRunning() pausing private state thread");
1414             PausePrivateStateThread();
1415             paused_private_state_thread = true;
1416         }
1417 
1418         bool timed_out = false;
1419         bool sent_interrupt = false;
1420         Mutex::Locker locker;
1421 
1422         if (!m_gdb_comm.SendInterrupt (locker, 1, sent_interrupt, timed_out))
1423         {
1424             if (timed_out)
1425                 error.SetErrorString("timed out sending interrupt packet");
1426             else
1427                 error.SetErrorString("unknown error sending interrupt packet");
1428             if (paused_private_state_thread)
1429                 ResumePrivateStateThread();
1430             return error;
1431         }
1432 
1433         if (catch_stop_event)
1434         {
1435             // LISTEN HERE
1436             TimeValue timeout_time;
1437             timeout_time = TimeValue::Now();
1438             timeout_time.OffsetWithSeconds(5);
1439             StateType state = WaitForStateChangedEventsPrivate (&timeout_time, stop_event_sp);
1440 
1441             timed_out = state == eStateInvalid;
1442             if (log)
1443                 log->Printf ("ProcessGDBRemote::InterruptIfRunning() catch stop event: state = %s, timed-out=%i", StateAsCString(state), timed_out);
1444 
1445             if (timed_out)
1446                 error.SetErrorString("unable to verify target stopped");
1447         }
1448 
1449         if (paused_private_state_thread)
1450         {
1451             if (log)
1452                 log->Printf ("ProcessGDBRemote::InterruptIfRunning() resuming private state thread");
1453             ResumePrivateStateThread();
1454         }
1455     }
1456     return error;
1457 }
1458 
1459 Error
1460 ProcessGDBRemote::WillDetach ()
1461 {
1462     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1463     if (log)
1464         log->Printf ("ProcessGDBRemote::WillDetach()");
1465 
1466     bool discard_thread_plans = true;
1467     bool catch_stop_event = true;
1468     EventSP event_sp;
1469     return InterruptIfRunning (discard_thread_plans, catch_stop_event, event_sp);
1470 }
1471 
1472 Error
1473 ProcessGDBRemote::DoDetach()
1474 {
1475     Error error;
1476     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1477     if (log)
1478         log->Printf ("ProcessGDBRemote::DoDetach()");
1479 
1480     DisableAllBreakpointSites ();
1481 
1482     m_thread_list.DiscardThreadPlans();
1483 
1484     size_t response_size = m_gdb_comm.SendPacket ("D", 1);
1485     if (log)
1486     {
1487         if (response_size)
1488             log->PutCString ("ProcessGDBRemote::DoDetach() detach packet sent successfully");
1489         else
1490             log->PutCString ("ProcessGDBRemote::DoDetach() detach packet send failed");
1491     }
1492     // Sleep for one second to let the process get all detached...
1493     StopAsyncThread ();
1494 
1495     m_gdb_comm.StopReadThread();
1496     m_gdb_comm.Disconnect();    // Disconnect from the debug server.
1497 
1498     SetPrivateState (eStateDetached);
1499     ResumePrivateStateThread();
1500 
1501     //KillDebugserverProcess ();
1502     return error;
1503 }
1504 
1505 Error
1506 ProcessGDBRemote::DoDestroy ()
1507 {
1508     Error error;
1509     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
1510     if (log)
1511         log->Printf ("ProcessGDBRemote::DoDestroy()");
1512 
1513     // Interrupt if our inferior is running...
1514     if (m_gdb_comm.IsConnected())
1515     {
1516         if (m_public_state.GetValue() == eStateAttaching)
1517         {
1518             // We are being asked to halt during an attach. We need to just close
1519             // our file handle and debugserver will go away, and we can be done...
1520             m_gdb_comm.Disconnect();
1521         }
1522         else
1523         {
1524 
1525             StringExtractorGDBRemote response;
1526             bool send_async = true;
1527             if (m_gdb_comm.SendPacketAndWaitForResponse("k", 1, response, send_async))
1528             {
1529                 char packet_cmd = response.GetChar(0);
1530 
1531                 if (packet_cmd == 'W' || packet_cmd == 'X')
1532                 {
1533                     m_last_stop_packet = response;
1534                     SetExitStatus(response.GetHexU8(), NULL);
1535                 }
1536             }
1537             else
1538             {
1539                 SetExitStatus(SIGABRT, NULL);
1540                 //error.SetErrorString("kill packet failed");
1541             }
1542         }
1543     }
1544     StopAsyncThread ();
1545     m_gdb_comm.StopReadThread();
1546     KillDebugserverProcess ();
1547     m_gdb_comm.Disconnect();    // Disconnect from the debug server.
1548     return error;
1549 }
1550 
1551 //------------------------------------------------------------------
1552 // Process Queries
1553 //------------------------------------------------------------------
1554 
1555 bool
1556 ProcessGDBRemote::IsAlive ()
1557 {
1558     return m_gdb_comm.IsConnected() && m_private_state.GetValue() != eStateExited;
1559 }
1560 
1561 addr_t
1562 ProcessGDBRemote::GetImageInfoAddress()
1563 {
1564     if (!m_gdb_comm.IsRunning())
1565     {
1566         StringExtractorGDBRemote response;
1567         if (m_gdb_comm.SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, false))
1568         {
1569             if (response.IsNormalResponse())
1570                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1571         }
1572     }
1573     return LLDB_INVALID_ADDRESS;
1574 }
1575 
1576 //------------------------------------------------------------------
1577 // Process Memory
1578 //------------------------------------------------------------------
1579 size_t
1580 ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &error)
1581 {
1582     if (size > m_max_memory_size)
1583     {
1584         // Keep memory read sizes down to a sane limit. This function will be
1585         // called multiple times in order to complete the task by
1586         // lldb_private::Process so it is ok to do this.
1587         size = m_max_memory_size;
1588     }
1589 
1590     char packet[64];
1591     const int packet_len = ::snprintf (packet, sizeof(packet), "m%llx,%zx", (uint64_t)addr, size);
1592     assert (packet_len + 1 < sizeof(packet));
1593     StringExtractorGDBRemote response;
1594     if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, true))
1595     {
1596         if (response.IsNormalResponse())
1597         {
1598             error.Clear();
1599             return response.GetHexBytes(buf, size, '\xdd');
1600         }
1601         else if (response.IsErrorResponse())
1602             error.SetErrorStringWithFormat("gdb remote returned an error: %s", response.GetStringRef().c_str());
1603         else if (response.IsUnsupportedResponse())
1604             error.SetErrorStringWithFormat("'%s' packet unsupported", packet);
1605         else
1606             error.SetErrorStringWithFormat("unexpected response to '%s': '%s'", packet, response.GetStringRef().c_str());
1607     }
1608     else
1609     {
1610         error.SetErrorStringWithFormat("failed to sent packet: '%s'", packet);
1611     }
1612     return 0;
1613 }
1614 
1615 size_t
1616 ProcessGDBRemote::DoWriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
1617 {
1618     if (size > m_max_memory_size)
1619     {
1620         // Keep memory read sizes down to a sane limit. This function will be
1621         // called multiple times in order to complete the task by
1622         // lldb_private::Process so it is ok to do this.
1623         size = m_max_memory_size;
1624     }
1625 
1626     StreamString packet;
1627     packet.Printf("M%llx,%zx:", addr, size);
1628     packet.PutBytesAsRawHex8(buf, size, lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
1629     StringExtractorGDBRemote response;
1630     if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, true))
1631     {
1632         if (response.IsOKResponse())
1633         {
1634             error.Clear();
1635             return size;
1636         }
1637         else if (response.IsErrorResponse())
1638             error.SetErrorStringWithFormat("gdb remote returned an error: %s", response.GetStringRef().c_str());
1639         else if (response.IsUnsupportedResponse())
1640             error.SetErrorStringWithFormat("'%s' packet unsupported", packet.GetString().c_str());
1641         else
1642             error.SetErrorStringWithFormat("unexpected response to '%s': '%s'", packet.GetString().c_str(), response.GetStringRef().c_str());
1643     }
1644     else
1645     {
1646         error.SetErrorStringWithFormat("failed to sent packet: '%s'", packet.GetString().c_str());
1647     }
1648     return 0;
1649 }
1650 
1651 lldb::addr_t
1652 ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &error)
1653 {
1654     addr_t allocated_addr = LLDB_INVALID_ADDRESS;
1655 
1656     LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();
1657     switch (supported)
1658     {
1659         case eLazyBoolCalculate:
1660         case eLazyBoolYes:
1661             allocated_addr = m_gdb_comm.AllocateMemory (size, permissions);
1662             if (allocated_addr != LLDB_INVALID_ADDRESS || supported == eLazyBoolYes)
1663                 return allocated_addr;
1664 
1665         case eLazyBoolNo:
1666             // Call mmap() to create memory in the inferior..
1667             unsigned prot = 0;
1668             if (permissions & lldb::ePermissionsReadable)
1669                 prot |= eMmapProtRead;
1670             if (permissions & lldb::ePermissionsWritable)
1671                 prot |= eMmapProtWrite;
1672             if (permissions & lldb::ePermissionsExecutable)
1673                 prot |= eMmapProtExec;
1674 
1675             if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
1676                                  eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0))
1677                 m_addr_to_mmap_size[allocated_addr] = size;
1678             else
1679                 allocated_addr = LLDB_INVALID_ADDRESS;
1680             break;
1681     }
1682 
1683     if (allocated_addr == LLDB_INVALID_ADDRESS)
1684         error.SetErrorStringWithFormat("unable to allocate %zu bytes of memory with permissions %s", size, GetPermissionsAsCString (permissions));
1685     else
1686         error.Clear();
1687     return allocated_addr;
1688 }
1689 
1690 Error
1691 ProcessGDBRemote::DoDeallocateMemory (lldb::addr_t addr)
1692 {
1693     Error error;
1694     LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();
1695 
1696     switch (supported)
1697     {
1698         case eLazyBoolCalculate:
1699             // We should never be deallocating memory without allocating memory
1700             // first so we should never get eLazyBoolCalculate
1701             error.SetErrorString ("tried to deallocate memory without ever allocating memory");
1702             break;
1703 
1704         case eLazyBoolYes:
1705             if (!m_gdb_comm.DeallocateMemory (addr))
1706                 error.SetErrorStringWithFormat("unable to deallocate memory at 0x%llx", addr);
1707             break;
1708 
1709         case eLazyBoolNo:
1710             // Call munmap() to deallocate memory in the inferior..
1711             {
1712                 MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
1713                 if (pos != m_addr_to_mmap_size.end() &&
1714                     InferiorCallMunmap(this, addr, pos->second))
1715                     m_addr_to_mmap_size.erase (pos);
1716                 else
1717                     error.SetErrorStringWithFormat("unable to deallocate memory at 0x%llx", addr);
1718             }
1719             break;
1720     }
1721 
1722     return error;
1723 }
1724 
1725 
1726 //------------------------------------------------------------------
1727 // Process STDIO
1728 //------------------------------------------------------------------
1729 
1730 size_t
1731 ProcessGDBRemote::GetSTDOUT (char *buf, size_t buf_size, Error &error)
1732 {
1733     Mutex::Locker locker(m_stdio_mutex);
1734     size_t bytes_available = m_stdout_data.size();
1735     if (bytes_available > 0)
1736     {
1737         LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
1738         if (log)
1739             log->Printf ("ProcessGDBRemote::%s (&%p[%u]) ...", __FUNCTION__, buf, buf_size);
1740         if (bytes_available > buf_size)
1741         {
1742             memcpy(buf, m_stdout_data.c_str(), buf_size);
1743             m_stdout_data.erase(0, buf_size);
1744             bytes_available = buf_size;
1745         }
1746         else
1747         {
1748             memcpy(buf, m_stdout_data.c_str(), bytes_available);
1749             m_stdout_data.clear();
1750 
1751             //ResetEventBits(eBroadcastBitSTDOUT);
1752         }
1753     }
1754     return bytes_available;
1755 }
1756 
1757 size_t
1758 ProcessGDBRemote::GetSTDERR (char *buf, size_t buf_size, Error &error)
1759 {
1760     // Can we get STDERR through the remote protocol?
1761     return 0;
1762 }
1763 
1764 size_t
1765 ProcessGDBRemote::PutSTDIN (const char *src, size_t src_len, Error &error)
1766 {
1767     if (m_stdio_communication.IsConnected())
1768     {
1769         ConnectionStatus status;
1770         m_stdio_communication.Write(src, src_len, status, NULL);
1771     }
1772     return 0;
1773 }
1774 
1775 Error
1776 ProcessGDBRemote::EnableBreakpoint (BreakpointSite *bp_site)
1777 {
1778     Error error;
1779     assert (bp_site != NULL);
1780 
1781     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS));
1782     user_id_t site_id = bp_site->GetID();
1783     const addr_t addr = bp_site->GetLoadAddress();
1784     if (log)
1785         log->Printf ("ProcessGDBRemote::EnableBreakpoint (size_id = %d) address = 0x%llx", site_id, (uint64_t)addr);
1786 
1787     if (bp_site->IsEnabled())
1788     {
1789         if (log)
1790             log->Printf ("ProcessGDBRemote::EnableBreakpoint (size_id = %d) address = 0x%llx -- SUCCESS (already enabled)", site_id, (uint64_t)addr);
1791         return error;
1792     }
1793     else
1794     {
1795         const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site);
1796 
1797         if (bp_site->HardwarePreferred())
1798         {
1799             // Try and set hardware breakpoint, and if that fails, fall through
1800             // and set a software breakpoint?
1801             if (m_gdb_comm.SupportsGDBStoppointPacket (eBreakpointHardware))
1802             {
1803                 if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointHardware, true, addr, bp_op_size) == 0)
1804                 {
1805                     bp_site->SetEnabled(true);
1806                     bp_site->SetType (BreakpointSite::eHardware);
1807                     return error;
1808                 }
1809             }
1810         }
1811 
1812         if (m_gdb_comm.SupportsGDBStoppointPacket (eBreakpointSoftware))
1813         {
1814             if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointSoftware, true, addr, bp_op_size) == 0)
1815             {
1816                 bp_site->SetEnabled(true);
1817                 bp_site->SetType (BreakpointSite::eExternal);
1818                 return error;
1819             }
1820         }
1821 
1822         return EnableSoftwareBreakpoint (bp_site);
1823     }
1824 
1825     if (log)
1826     {
1827         const char *err_string = error.AsCString();
1828         log->Printf ("ProcessGDBRemote::EnableBreakpoint() error for breakpoint at 0x%8.8llx: %s",
1829                      bp_site->GetLoadAddress(),
1830                      err_string ? err_string : "NULL");
1831     }
1832     // We shouldn't reach here on a successful breakpoint enable...
1833     if (error.Success())
1834         error.SetErrorToGenericError();
1835     return error;
1836 }
1837 
1838 Error
1839 ProcessGDBRemote::DisableBreakpoint (BreakpointSite *bp_site)
1840 {
1841     Error error;
1842     assert (bp_site != NULL);
1843     addr_t addr = bp_site->GetLoadAddress();
1844     user_id_t site_id = bp_site->GetID();
1845     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS));
1846     if (log)
1847         log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx", site_id, (uint64_t)addr);
1848 
1849     if (bp_site->IsEnabled())
1850     {
1851         const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site);
1852 
1853         BreakpointSite::Type bp_type = bp_site->GetType();
1854         switch (bp_type)
1855         {
1856         case BreakpointSite::eSoftware:
1857             error = DisableSoftwareBreakpoint (bp_site);
1858             break;
1859 
1860         case BreakpointSite::eHardware:
1861             if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointSoftware, false, addr, bp_op_size))
1862                 error.SetErrorToGenericError();
1863             break;
1864 
1865         case BreakpointSite::eExternal:
1866             if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointSoftware, false, addr, bp_op_size))
1867                 error.SetErrorToGenericError();
1868             break;
1869         }
1870         if (error.Success())
1871             bp_site->SetEnabled(false);
1872     }
1873     else
1874     {
1875         if (log)
1876             log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx -- SUCCESS (already disabled)", site_id, (uint64_t)addr);
1877         return error;
1878     }
1879 
1880     if (error.Success())
1881         error.SetErrorToGenericError();
1882     return error;
1883 }
1884 
1885 // Pre-requisite: wp != NULL.
1886 static GDBStoppointType
1887 GetGDBStoppointType (WatchpointLocation *wp)
1888 {
1889     assert(wp);
1890     bool watch_read = wp->WatchpointRead();
1891     bool watch_write = wp->WatchpointWrite();
1892 
1893     // watch_read and watch_write cannot both be false.
1894     assert(watch_read || watch_write);
1895     if (watch_read && watch_write)
1896         return eWatchpointReadWrite;
1897     else if (watch_read)
1898         return eWatchpointRead;
1899     else // Must be watch_write, then.
1900         return eWatchpointWrite;
1901 }
1902 
1903 Error
1904 ProcessGDBRemote::EnableWatchpoint (WatchpointLocation *wp)
1905 {
1906     Error error;
1907     if (wp)
1908     {
1909         user_id_t watchID = wp->GetID();
1910         addr_t addr = wp->GetLoadAddress();
1911         LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS));
1912         if (log)
1913             log->Printf ("ProcessGDBRemote::EnableWatchpoint(watchID = %d)", watchID);
1914         if (wp->IsEnabled())
1915         {
1916             if (log)
1917                 log->Printf("ProcessGDBRemote::EnableWatchpoint(watchID = %d) addr = 0x%8.8llx: watchpoint already enabled.", watchID, (uint64_t)addr);
1918             return error;
1919         }
1920 
1921         GDBStoppointType type = GetGDBStoppointType(wp);
1922         // Pass down an appropriate z/Z packet...
1923         if (m_gdb_comm.SupportsGDBStoppointPacket (type))
1924         {
1925             if (m_gdb_comm.SendGDBStoppointTypePacket(type, true, addr, wp->GetByteSize()) == 0)
1926             {
1927                 wp->SetEnabled(true);
1928                 return error;
1929             }
1930             else
1931                 error.SetErrorString("sending gdb watchpoint packet failed");
1932         }
1933         else
1934             error.SetErrorString("watchpoints not supported");
1935     }
1936     else
1937     {
1938         error.SetErrorString("Watchpoint location argument was NULL.");
1939     }
1940     if (error.Success())
1941         error.SetErrorToGenericError();
1942     return error;
1943 }
1944 
1945 Error
1946 ProcessGDBRemote::DisableWatchpoint (WatchpointLocation *wp)
1947 {
1948     Error error;
1949     if (wp)
1950     {
1951         user_id_t watchID = wp->GetID();
1952 
1953         LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS));
1954 
1955         addr_t addr = wp->GetLoadAddress();
1956         if (log)
1957             log->Printf ("ProcessGDBRemote::DisableWatchpoint (watchID = %d) addr = 0x%8.8llx", watchID, (uint64_t)addr);
1958 
1959         if (!wp->IsEnabled())
1960         {
1961             if (log)
1962                 log->Printf ("ProcessGDBRemote::DisableWatchpoint (watchID = %d) addr = 0x%8.8llx -- SUCCESS (already disabled)", watchID, (uint64_t)addr);
1963             return error;
1964         }
1965 
1966         if (wp->IsHardware())
1967         {
1968             GDBStoppointType type = GetGDBStoppointType(wp);
1969             // Pass down an appropriate z/Z packet...
1970             if (m_gdb_comm.SendGDBStoppointTypePacket(type, false, addr, wp->GetByteSize()) == 0)
1971             {
1972                 wp->SetEnabled(false);
1973                 return error;
1974             }
1975             else
1976                 error.SetErrorString("sending gdb watchpoint packet failed");
1977         }
1978         // TODO: clear software watchpoints if we implement them
1979     }
1980     else
1981     {
1982         error.SetErrorString("Watchpoint location argument was NULL.");
1983     }
1984     if (error.Success())
1985         error.SetErrorToGenericError();
1986     return error;
1987 }
1988 
1989 void
1990 ProcessGDBRemote::Clear()
1991 {
1992     m_flags = 0;
1993     m_thread_list.Clear();
1994     {
1995         Mutex::Locker locker(m_stdio_mutex);
1996         m_stdout_data.clear();
1997     }
1998 }
1999 
2000 Error
2001 ProcessGDBRemote::DoSignal (int signo)
2002 {
2003     Error error;
2004     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
2005     if (log)
2006         log->Printf ("ProcessGDBRemote::DoSignal (signal = %d)", signo);
2007 
2008     if (!m_gdb_comm.SendAsyncSignal (signo))
2009         error.SetErrorStringWithFormat("failed to send signal %i", signo);
2010     return error;
2011 }
2012 
2013 Error
2014 ProcessGDBRemote::StartDebugserverProcess (const char *debugserver_url)    // The connection string to use in the spawned debugserver ("localhost:1234" or "/dev/tty...")
2015 {
2016     Error error;
2017     if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID)
2018     {
2019         // If we locate debugserver, keep that located version around
2020         static FileSpec g_debugserver_file_spec;
2021 
2022         ProcessLaunchInfo launch_info;
2023         char debugserver_path[PATH_MAX];
2024         FileSpec &debugserver_file_spec = launch_info.GetExecutableFile();
2025 
2026         // Always check to see if we have an environment override for the path
2027         // to the debugserver to use and use it if we do.
2028         const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH");
2029         if (env_debugserver_path)
2030             debugserver_file_spec.SetFile (env_debugserver_path, false);
2031         else
2032             debugserver_file_spec = g_debugserver_file_spec;
2033         bool debugserver_exists = debugserver_file_spec.Exists();
2034         if (!debugserver_exists)
2035         {
2036             // The debugserver binary is in the LLDB.framework/Resources
2037             // directory.
2038             if (Host::GetLLDBPath (ePathTypeSupportExecutableDir, debugserver_file_spec))
2039             {
2040                 debugserver_file_spec.GetFilename().SetCString(DEBUGSERVER_BASENAME);
2041                 debugserver_exists = debugserver_file_spec.Exists();
2042                 if (debugserver_exists)
2043                 {
2044                     g_debugserver_file_spec = debugserver_file_spec;
2045                 }
2046                 else
2047                 {
2048                     g_debugserver_file_spec.Clear();
2049                     debugserver_file_spec.Clear();
2050                 }
2051             }
2052         }
2053 
2054         if (debugserver_exists)
2055         {
2056             debugserver_file_spec.GetPath (debugserver_path, sizeof(debugserver_path));
2057 
2058             m_stdio_communication.Clear();
2059 
2060             LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
2061 
2062             Args &debugserver_args = launch_info.GetArguments();
2063             char arg_cstr[PATH_MAX];
2064 
2065             // Start args with "debugserver /file/path -r --"
2066             debugserver_args.AppendArgument(debugserver_path);
2067             debugserver_args.AppendArgument(debugserver_url);
2068             // use native registers, not the GDB registers
2069             debugserver_args.AppendArgument("--native-regs");
2070             // make debugserver run in its own session so signals generated by
2071             // special terminal key sequences (^C) don't affect debugserver
2072             debugserver_args.AppendArgument("--setsid");
2073 
2074             const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE");
2075             if (env_debugserver_log_file)
2076             {
2077                 ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-file=%s", env_debugserver_log_file);
2078                 debugserver_args.AppendArgument(arg_cstr);
2079             }
2080 
2081             const char *env_debugserver_log_flags = getenv("LLDB_DEBUGSERVER_LOG_FLAGS");
2082             if (env_debugserver_log_flags)
2083             {
2084                 ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
2085                 debugserver_args.AppendArgument(arg_cstr);
2086             }
2087 //            debugserver_args.AppendArgument("--log-file=/tmp/debugserver.txt");
2088 //            debugserver_args.AppendArgument("--log-flags=0x802e0e");
2089 
2090             // We currently send down all arguments, attach pids, or attach
2091             // process names in dedicated GDB server packets, so we don't need
2092             // to pass them as arguments. This is currently because of all the
2093             // things we need to setup prior to launching: the environment,
2094             // current working dir, file actions, etc.
2095 #if 0
2096             // Now append the program arguments
2097             if (inferior_argv)
2098             {
2099                 // Terminate the debugserver args so we can now append the inferior args
2100                 debugserver_args.AppendArgument("--");
2101 
2102                 for (int i = 0; inferior_argv[i] != NULL; ++i)
2103                     debugserver_args.AppendArgument (inferior_argv[i]);
2104             }
2105             else if (attach_pid != LLDB_INVALID_PROCESS_ID)
2106             {
2107                 ::snprintf (arg_cstr, sizeof(arg_cstr), "--attach=%u", attach_pid);
2108                 debugserver_args.AppendArgument (arg_cstr);
2109             }
2110             else if (attach_name && attach_name[0])
2111             {
2112                 if (wait_for_launch)
2113                     debugserver_args.AppendArgument ("--waitfor");
2114                 else
2115                     debugserver_args.AppendArgument ("--attach");
2116                 debugserver_args.AppendArgument (attach_name);
2117             }
2118 #endif
2119 
2120             ProcessLaunchInfo::FileAction file_action;
2121 
2122             // Close STDIN, STDOUT and STDERR. We might need to redirect them
2123             // to "/dev/null" if we run into any problems.
2124             file_action.Close (STDIN_FILENO);
2125             launch_info.AppendFileAction (file_action);
2126             file_action.Close (STDOUT_FILENO);
2127             launch_info.AppendFileAction (file_action);
2128             file_action.Close (STDERR_FILENO);
2129             launch_info.AppendFileAction (file_action);
2130 
2131             if (log)
2132             {
2133                 StreamString strm;
2134                 debugserver_args.Dump (&strm);
2135                 log->Printf("%s arguments:\n%s", debugserver_args.GetArgumentAtIndex(0), strm.GetData());
2136             }
2137 
2138             error = Host::LaunchProcess(launch_info);
2139 
2140             if (error.Success ())
2141                 m_debugserver_pid = launch_info.GetProcessID();
2142             else
2143                 m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
2144 
2145             if (error.Fail() || log)
2146                 error.PutToLog(log.get(), "Host::LaunchProcess (launch_info) => pid=%i, path='%s'", m_debugserver_pid, debugserver_path);
2147         }
2148         else
2149         {
2150             error.SetErrorStringWithFormat ("Unable to locate " DEBUGSERVER_BASENAME ".\n");
2151         }
2152 
2153         if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID)
2154             StartAsyncThread ();
2155     }
2156     return error;
2157 }
2158 
2159 bool
2160 ProcessGDBRemote::MonitorDebugserverProcess
2161 (
2162     void *callback_baton,
2163     lldb::pid_t debugserver_pid,
2164     int signo,          // Zero for no signal
2165     int exit_status     // Exit value of process if signal is zero
2166 )
2167 {
2168     // We pass in the ProcessGDBRemote inferior process it and name it
2169     // "gdb_remote_pid". The process ID is passed in the "callback_baton"
2170     // pointer value itself, thus we need the double cast...
2171 
2172     // "debugserver_pid" argument passed in is the process ID for
2173     // debugserver that we are tracking...
2174 
2175     ProcessGDBRemote *process = (ProcessGDBRemote *)callback_baton;
2176 
2177     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
2178     if (log)
2179         log->Printf ("ProcessGDBRemote::MonitorDebugserverProcess (baton=%p, pid=%i, signo=%i (0x%x), exit_status=%i)", callback_baton, debugserver_pid, signo, signo, exit_status);
2180 
2181     if (process)
2182     {
2183         // Sleep for a half a second to make sure our inferior process has
2184         // time to set its exit status before we set it incorrectly when
2185         // both the debugserver and the inferior process shut down.
2186         usleep (500000);
2187         // If our process hasn't yet exited, debugserver might have died.
2188         // If the process did exit, the we are reaping it.
2189         const StateType state = process->GetState();
2190 
2191         if (process->m_debugserver_pid != LLDB_INVALID_PROCESS_ID &&
2192             state != eStateInvalid &&
2193             state != eStateUnloaded &&
2194             state != eStateExited &&
2195             state != eStateDetached)
2196         {
2197             char error_str[1024];
2198             if (signo)
2199             {
2200                 const char *signal_cstr = process->GetUnixSignals().GetSignalAsCString (signo);
2201                 if (signal_cstr)
2202                     ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %s", signal_cstr);
2203                 else
2204                     ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %i", signo);
2205             }
2206             else
2207             {
2208                 ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x", exit_status);
2209             }
2210 
2211             process->SetExitStatus (-1, error_str);
2212         }
2213         // Debugserver has exited we need to let our ProcessGDBRemote
2214         // know that it no longer has a debugserver instance
2215         process->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
2216         // We are returning true to this function below, so we can
2217         // forget about the monitor handle.
2218         process->m_debugserver_thread = LLDB_INVALID_HOST_THREAD;
2219     }
2220     return true;
2221 }
2222 
2223 void
2224 ProcessGDBRemote::KillDebugserverProcess ()
2225 {
2226     if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID)
2227     {
2228         ::kill (m_debugserver_pid, SIGINT);
2229         m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
2230     }
2231 }
2232 
2233 void
2234 ProcessGDBRemote::Initialize()
2235 {
2236     static bool g_initialized = false;
2237 
2238     if (g_initialized == false)
2239     {
2240         g_initialized = true;
2241         PluginManager::RegisterPlugin (GetPluginNameStatic(),
2242                                        GetPluginDescriptionStatic(),
2243                                        CreateInstance);
2244 
2245         Log::Callbacks log_callbacks = {
2246             ProcessGDBRemoteLog::DisableLog,
2247             ProcessGDBRemoteLog::EnableLog,
2248             ProcessGDBRemoteLog::ListLogCategories
2249         };
2250 
2251         Log::RegisterLogChannel (ProcessGDBRemote::GetPluginNameStatic(), log_callbacks);
2252     }
2253 }
2254 
2255 bool
2256 ProcessGDBRemote::StartAsyncThread ()
2257 {
2258     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
2259 
2260     if (log)
2261         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
2262 
2263     // Create a thread that watches our internal state and controls which
2264     // events make it to clients (into the DCProcess event queue).
2265     m_async_thread = Host::ThreadCreate ("<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this, NULL);
2266     return IS_VALID_LLDB_HOST_THREAD(m_async_thread);
2267 }
2268 
2269 void
2270 ProcessGDBRemote::StopAsyncThread ()
2271 {
2272     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
2273 
2274     if (log)
2275         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
2276 
2277     m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);
2278 
2279     // Stop the stdio thread
2280     if (IS_VALID_LLDB_HOST_THREAD(m_async_thread))
2281     {
2282         Host::ThreadJoin (m_async_thread, NULL, NULL);
2283     }
2284 }
2285 
2286 
2287 void *
2288 ProcessGDBRemote::AsyncThread (void *arg)
2289 {
2290     ProcessGDBRemote *process = (ProcessGDBRemote*) arg;
2291 
2292     LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
2293     if (log)
2294         log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, arg, process->GetID());
2295 
2296     Listener listener ("ProcessGDBRemote::AsyncThread");
2297     EventSP event_sp;
2298     const uint32_t desired_event_mask = eBroadcastBitAsyncContinue |
2299                                         eBroadcastBitAsyncThreadShouldExit;
2300 
2301     if (listener.StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask)
2302     {
2303         listener.StartListeningForEvents (&process->m_gdb_comm, Communication::eBroadcastBitReadThreadDidExit);
2304 
2305         bool done = false;
2306         while (!done)
2307         {
2308             if (log)
2309                 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg, process->GetID());
2310             if (listener.WaitForEvent (NULL, event_sp))
2311             {
2312                 const uint32_t event_type = event_sp->GetType();
2313                 if (event_sp->BroadcasterIs (&process->m_async_broadcaster))
2314                 {
2315                     if (log)
2316                         log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) Got an event of type: %d...", __FUNCTION__, arg, process->GetID(), event_type);
2317 
2318                     switch (event_type)
2319                     {
2320                         case eBroadcastBitAsyncContinue:
2321                             {
2322                                 const EventDataBytes *continue_packet = EventDataBytes::GetEventDataFromEvent(event_sp.get());
2323 
2324                                 if (continue_packet)
2325                                 {
2326                                     const char *continue_cstr = (const char *)continue_packet->GetBytes ();
2327                                     const size_t continue_cstr_len = continue_packet->GetByteSize ();
2328                                     if (log)
2329                                         log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got eBroadcastBitAsyncContinue: %s", __FUNCTION__, arg, process->GetID(), continue_cstr);
2330 
2331                                     if (::strstr (continue_cstr, "vAttach") == NULL)
2332                                         process->SetPrivateState(eStateRunning);
2333                                     StringExtractorGDBRemote response;
2334                                     StateType stop_state = process->GetGDBRemote().SendContinuePacketAndWaitForResponse (process, continue_cstr, continue_cstr_len, response);
2335 
2336                                     switch (stop_state)
2337                                     {
2338                                     case eStateStopped:
2339                                     case eStateCrashed:
2340                                     case eStateSuspended:
2341                                         process->m_last_stop_packet = response;
2342                                         process->SetPrivateState (stop_state);
2343                                         break;
2344 
2345                                     case eStateExited:
2346                                         process->m_last_stop_packet = response;
2347                                         response.SetFilePos(1);
2348                                         process->SetExitStatus(response.GetHexU8(), NULL);
2349                                         done = true;
2350                                         break;
2351 
2352                                     case eStateInvalid:
2353                                         process->SetExitStatus(-1, "lost connection");
2354                                         break;
2355 
2356                                     default:
2357                                         process->SetPrivateState (stop_state);
2358                                         break;
2359                                     }
2360                                 }
2361                             }
2362                             break;
2363 
2364                         case eBroadcastBitAsyncThreadShouldExit:
2365                             if (log)
2366                                 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got eBroadcastBitAsyncThreadShouldExit...", __FUNCTION__, arg, process->GetID());
2367                             done = true;
2368                             break;
2369 
2370                         default:
2371                             if (log)
2372                                 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got unknown event 0x%8.8x", __FUNCTION__, arg, process->GetID(), event_type);
2373                             done = true;
2374                             break;
2375                     }
2376                 }
2377                 else if (event_sp->BroadcasterIs (&process->m_gdb_comm))
2378                 {
2379                     if (event_type & Communication::eBroadcastBitReadThreadDidExit)
2380                     {
2381                         process->SetExitStatus (-1, "lost connection");
2382                         done = true;
2383                     }
2384                 }
2385             }
2386             else
2387             {
2388                 if (log)
2389                     log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) listener.WaitForEvent (NULL, event_sp) => false", __FUNCTION__, arg, process->GetID());
2390                 done = true;
2391             }
2392         }
2393     }
2394 
2395     if (log)
2396         log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, arg, process->GetID());
2397 
2398     process->m_async_thread = LLDB_INVALID_HOST_THREAD;
2399     return NULL;
2400 }
2401 
2402 const char *
2403 ProcessGDBRemote::GetDispatchQueueNameForThread
2404 (
2405     addr_t thread_dispatch_qaddr,
2406     std::string &dispatch_queue_name
2407 )
2408 {
2409     dispatch_queue_name.clear();
2410     if (thread_dispatch_qaddr != 0 && thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
2411     {
2412         // Cache the dispatch_queue_offsets_addr value so we don't always have
2413         // to look it up
2414         if (m_dispatch_queue_offsets_addr == LLDB_INVALID_ADDRESS)
2415         {
2416             static ConstString g_dispatch_queue_offsets_symbol_name ("dispatch_queue_offsets");
2417             const Symbol *dispatch_queue_offsets_symbol = NULL;
2418             ModuleSP module_sp(GetTarget().GetImages().FindFirstModuleForFileSpec (FileSpec("libSystem.B.dylib", false), NULL, NULL));
2419             if (module_sp)
2420                 dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
2421 
2422             if (dispatch_queue_offsets_symbol == NULL)
2423             {
2424                 module_sp = GetTarget().GetImages().FindFirstModuleForFileSpec (FileSpec("libdispatch.dylib", false), NULL, NULL);
2425                 if (module_sp)
2426                     dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
2427             }
2428             if (dispatch_queue_offsets_symbol)
2429                 m_dispatch_queue_offsets_addr = dispatch_queue_offsets_symbol->GetValue().GetLoadAddress(&m_target);
2430 
2431             if (m_dispatch_queue_offsets_addr == LLDB_INVALID_ADDRESS)
2432                 return NULL;
2433         }
2434 
2435         uint8_t memory_buffer[8];
2436         DataExtractor data (memory_buffer,
2437                             sizeof(memory_buffer),
2438                             m_target.GetArchitecture().GetByteOrder(),
2439                             m_target.GetArchitecture().GetAddressByteSize());
2440 
2441         // Excerpt from src/queue_private.h
2442         struct dispatch_queue_offsets_s
2443         {
2444             uint16_t dqo_version;
2445             uint16_t dqo_label;
2446             uint16_t dqo_label_size;
2447         } dispatch_queue_offsets;
2448 
2449 
2450         Error error;
2451         if (ReadMemory (m_dispatch_queue_offsets_addr, memory_buffer, sizeof(dispatch_queue_offsets), error) == sizeof(dispatch_queue_offsets))
2452         {
2453             uint32_t data_offset = 0;
2454             if (data.GetU16(&data_offset, &dispatch_queue_offsets.dqo_version, sizeof(dispatch_queue_offsets)/sizeof(uint16_t)))
2455             {
2456                 if (ReadMemory (thread_dispatch_qaddr, &memory_buffer, data.GetAddressByteSize(), error) == data.GetAddressByteSize())
2457                 {
2458                     data_offset = 0;
2459                     lldb::addr_t queue_addr = data.GetAddress(&data_offset);
2460                     lldb::addr_t label_addr = queue_addr + dispatch_queue_offsets.dqo_label;
2461                     dispatch_queue_name.resize(dispatch_queue_offsets.dqo_label_size, '\0');
2462                     size_t bytes_read = ReadMemory (label_addr, &dispatch_queue_name[0], dispatch_queue_offsets.dqo_label_size, error);
2463                     if (bytes_read < dispatch_queue_offsets.dqo_label_size)
2464                         dispatch_queue_name.erase (bytes_read);
2465                 }
2466             }
2467         }
2468     }
2469     if (dispatch_queue_name.empty())
2470         return NULL;
2471     return dispatch_queue_name.c_str();
2472 }
2473 
2474 //uint32_t
2475 //ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
2476 //{
2477 //    // If we are planning to launch the debugserver remotely, then we need to fire up a debugserver
2478 //    // process and ask it for the list of processes. But if we are local, we can let the Host do it.
2479 //    if (m_local_debugserver)
2480 //    {
2481 //        return Host::ListProcessesMatchingName (name, matches, pids);
2482 //    }
2483 //    else
2484 //    {
2485 //        // FIXME: Implement talking to the remote debugserver.
2486 //        return 0;
2487 //    }
2488 //
2489 //}
2490 //
2491 bool
2492 ProcessGDBRemote::NewThreadNotifyBreakpointHit (void *baton,
2493                              lldb_private::StoppointCallbackContext *context,
2494                              lldb::user_id_t break_id,
2495                              lldb::user_id_t break_loc_id)
2496 {
2497     // I don't think I have to do anything here, just make sure I notice the new thread when it starts to
2498     // run so I can stop it if that's what I want to do.
2499     LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
2500     if (log)
2501         log->Printf("Hit New Thread Notification breakpoint.");
2502     return false;
2503 }
2504 
2505 
2506 bool
2507 ProcessGDBRemote::StartNoticingNewThreads()
2508 {
2509     static const char *bp_names[] =
2510     {
2511         "start_wqthread",
2512         "_pthread_wqthread",
2513         "_pthread_start",
2514         NULL
2515     };
2516 
2517     LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
2518     size_t num_bps = m_thread_observation_bps.size();
2519     if (num_bps != 0)
2520     {
2521         for (int i = 0; i < num_bps; i++)
2522         {
2523             lldb::BreakpointSP break_sp = m_target.GetBreakpointByID(m_thread_observation_bps[i]);
2524             if (break_sp)
2525             {
2526                 if (log)
2527                     log->Printf("Enabled noticing new thread breakpoint.");
2528                 break_sp->SetEnabled(true);
2529             }
2530         }
2531     }
2532     else
2533     {
2534         for (int i = 0; bp_names[i] != NULL; i++)
2535         {
2536             Breakpoint *breakpoint = m_target.CreateBreakpoint (NULL, bp_names[i], eFunctionNameTypeFull, true).get();
2537             if (breakpoint)
2538             {
2539                 if (log)
2540                      log->Printf("Successfully created new thread notification breakpoint at \"%s\".", bp_names[i]);
2541                 m_thread_observation_bps.push_back(breakpoint->GetID());
2542                 breakpoint->SetCallback (ProcessGDBRemote::NewThreadNotifyBreakpointHit, this, true);
2543             }
2544             else
2545             {
2546                 if (log)
2547                     log->Printf("Failed to create new thread notification breakpoint.");
2548                 return false;
2549             }
2550         }
2551     }
2552 
2553     return true;
2554 }
2555 
2556 bool
2557 ProcessGDBRemote::StopNoticingNewThreads()
2558 {
2559     LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
2560     if (log)
2561         log->Printf ("Disabling new thread notification breakpoint.");
2562     size_t num_bps = m_thread_observation_bps.size();
2563     if (num_bps != 0)
2564     {
2565         for (int i = 0; i < num_bps; i++)
2566         {
2567 
2568             lldb::BreakpointSP break_sp = m_target.GetBreakpointByID(m_thread_observation_bps[i]);
2569             if (break_sp)
2570             {
2571                 break_sp->SetEnabled(false);
2572             }
2573         }
2574     }
2575     return true;
2576 }
2577 
2578 
2579