1 //===-- GDBRemoteCommunicationServerLLGS.cpp --------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include <errno.h>
11 
12 #include "lldb/Host/Config.h"
13 
14 #include "GDBRemoteCommunicationServerLLGS.h"
15 #include "lldb/Utility/StreamGDBRemote.h"
16 
17 // C Includes
18 // C++ Includes
19 #include <chrono>
20 #include <cstring>
21 #include <thread>
22 
23 // Other libraries and framework includes
24 #include "lldb/Core/RegisterValue.h"
25 #include "lldb/Core/State.h"
26 #include "lldb/Host/ConnectionFileDescriptor.h"
27 #include "lldb/Host/Debug.h"
28 #include "lldb/Host/File.h"
29 #include "lldb/Host/FileSystem.h"
30 #include "lldb/Host/Host.h"
31 #include "lldb/Host/HostInfo.h"
32 #include "lldb/Host/common/NativeProcessProtocol.h"
33 #include "lldb/Host/common/NativeRegisterContext.h"
34 #include "lldb/Host/common/NativeThreadProtocol.h"
35 #include "lldb/Interpreter/Args.h"
36 #include "lldb/Target/FileAction.h"
37 #include "lldb/Target/MemoryRegionInfo.h"
38 #include "lldb/Utility/DataBuffer.h"
39 #include "lldb/Utility/Endian.h"
40 #include "lldb/Utility/JSON.h"
41 #include "lldb/Utility/LLDBAssert.h"
42 #include "lldb/Utility/Log.h"
43 #include "lldb/Utility/StreamString.h"
44 #include "lldb/Utility/UriParser.h"
45 #include "llvm/ADT/Triple.h"
46 #include "llvm/Support/ScopedPrinter.h"
47 
48 // Project includes
49 #include "ProcessGDBRemote.h"
50 #include "ProcessGDBRemoteLog.h"
51 #include "Utility/StringExtractorGDBRemote.h"
52 
53 using namespace lldb;
54 using namespace lldb_private;
55 using namespace lldb_private::process_gdb_remote;
56 using namespace llvm;
57 
58 //----------------------------------------------------------------------
59 // GDBRemote Errors
60 //----------------------------------------------------------------------
61 
62 namespace {
63 enum GDBRemoteServerError {
64   // Set to the first unused error number in literal form below
65   eErrorFirst = 29,
66   eErrorNoProcess = eErrorFirst,
67   eErrorResume,
68   eErrorExitStatus
69 };
70 }
71 
72 //----------------------------------------------------------------------
73 // GDBRemoteCommunicationServerLLGS constructor
74 //----------------------------------------------------------------------
75 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
76     MainLoop &mainloop)
77     : GDBRemoteCommunicationServerCommon("gdb-remote.server",
78                                          "gdb-remote.server.rx_packet"),
79       m_mainloop(mainloop), m_current_tid(LLDB_INVALID_THREAD_ID),
80       m_continue_tid(LLDB_INVALID_THREAD_ID), m_debugged_process_mutex(),
81       m_debugged_process_sp(), m_stdio_communication("process.stdio"),
82       m_inferior_prev_state(StateType::eStateInvalid),
83       m_saved_registers_map(), m_next_saved_registers_id(1),
84       m_handshake_completed(false) {
85   RegisterPacketHandlers();
86 }
87 
88 void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() {
89   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
90                                 &GDBRemoteCommunicationServerLLGS::Handle_C);
91   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c,
92                                 &GDBRemoteCommunicationServerLLGS::Handle_c);
93   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D,
94                                 &GDBRemoteCommunicationServerLLGS::Handle_D);
95   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H,
96                                 &GDBRemoteCommunicationServerLLGS::Handle_H);
97   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I,
98                                 &GDBRemoteCommunicationServerLLGS::Handle_I);
99   RegisterMemberFunctionHandler(
100       StringExtractorGDBRemote::eServerPacketType_interrupt,
101       &GDBRemoteCommunicationServerLLGS::Handle_interrupt);
102   RegisterMemberFunctionHandler(
103       StringExtractorGDBRemote::eServerPacketType_m,
104       &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
105   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M,
106                                 &GDBRemoteCommunicationServerLLGS::Handle_M);
107   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p,
108                                 &GDBRemoteCommunicationServerLLGS::Handle_p);
109   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P,
110                                 &GDBRemoteCommunicationServerLLGS::Handle_P);
111   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
112                                 &GDBRemoteCommunicationServerLLGS::Handle_qC);
113   RegisterMemberFunctionHandler(
114       StringExtractorGDBRemote::eServerPacketType_qfThreadInfo,
115       &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo);
116   RegisterMemberFunctionHandler(
117       StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress,
118       &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress);
119   RegisterMemberFunctionHandler(
120       StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
121       &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir);
122   RegisterMemberFunctionHandler(
123       StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo,
124       &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo);
125   RegisterMemberFunctionHandler(
126       StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported,
127       &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported);
128   RegisterMemberFunctionHandler(
129       StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
130       &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo);
131   RegisterMemberFunctionHandler(
132       StringExtractorGDBRemote::eServerPacketType_qRegisterInfo,
133       &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo);
134   RegisterMemberFunctionHandler(
135       StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState,
136       &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState);
137   RegisterMemberFunctionHandler(
138       StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState,
139       &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState);
140   RegisterMemberFunctionHandler(
141       StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR,
142       &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR);
143   RegisterMemberFunctionHandler(
144       StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
145       &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir);
146   RegisterMemberFunctionHandler(
147       StringExtractorGDBRemote::eServerPacketType_qsThreadInfo,
148       &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo);
149   RegisterMemberFunctionHandler(
150       StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo,
151       &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo);
152   RegisterMemberFunctionHandler(
153       StringExtractorGDBRemote::eServerPacketType_jThreadsInfo,
154       &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo);
155   RegisterMemberFunctionHandler(
156       StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo,
157       &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo);
158   RegisterMemberFunctionHandler(
159       StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read,
160       &GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read);
161   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s,
162                                 &GDBRemoteCommunicationServerLLGS::Handle_s);
163   RegisterMemberFunctionHandler(
164       StringExtractorGDBRemote::eServerPacketType_stop_reason,
165       &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ?
166   RegisterMemberFunctionHandler(
167       StringExtractorGDBRemote::eServerPacketType_vAttach,
168       &GDBRemoteCommunicationServerLLGS::Handle_vAttach);
169   RegisterMemberFunctionHandler(
170       StringExtractorGDBRemote::eServerPacketType_vCont,
171       &GDBRemoteCommunicationServerLLGS::Handle_vCont);
172   RegisterMemberFunctionHandler(
173       StringExtractorGDBRemote::eServerPacketType_vCont_actions,
174       &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions);
175   RegisterMemberFunctionHandler(
176       StringExtractorGDBRemote::eServerPacketType_x,
177       &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
178   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z,
179                                 &GDBRemoteCommunicationServerLLGS::Handle_Z);
180   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z,
181                                 &GDBRemoteCommunicationServerLLGS::Handle_z);
182   RegisterMemberFunctionHandler(
183       StringExtractorGDBRemote::eServerPacketType_QPassSignals,
184       &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals);
185 
186   RegisterMemberFunctionHandler(
187       StringExtractorGDBRemote::eServerPacketType_jTraceStart,
188       &GDBRemoteCommunicationServerLLGS::Handle_jTraceStart);
189   RegisterMemberFunctionHandler(
190       StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead,
191       &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
192   RegisterMemberFunctionHandler(
193       StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead,
194       &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
195   RegisterMemberFunctionHandler(
196       StringExtractorGDBRemote::eServerPacketType_jTraceStop,
197       &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
198   RegisterMemberFunctionHandler(
199       StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
200       &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);
201 
202   RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
203                         [this](StringExtractorGDBRemote packet, Status &error,
204                                bool &interrupt, bool &quit) {
205                           quit = true;
206                           return this->Handle_k(packet);
207                         });
208 }
209 
210 Status
211 GDBRemoteCommunicationServerLLGS::SetLaunchArguments(const char *const args[],
212                                                      int argc) {
213   if ((argc < 1) || !args || !args[0] || !args[0][0])
214     return Status("%s: no process command line specified to launch",
215                   __FUNCTION__);
216 
217   m_process_launch_info.SetArguments(const_cast<const char **>(args), true);
218   return Status();
219 }
220 
221 Status
222 GDBRemoteCommunicationServerLLGS::SetLaunchFlags(unsigned int launch_flags) {
223   m_process_launch_info.GetFlags().Set(launch_flags);
224   return Status();
225 }
226 
227 Status GDBRemoteCommunicationServerLLGS::LaunchProcess() {
228   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
229 
230   if (!m_process_launch_info.GetArguments().GetArgumentCount())
231     return Status("%s: no process command line specified to launch",
232                   __FUNCTION__);
233 
234   const bool should_forward_stdio =
235       m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr ||
236       m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr ||
237       m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr;
238   m_process_launch_info.SetLaunchInSeparateProcessGroup(true);
239   m_process_launch_info.GetFlags().Set(eLaunchFlagDebug);
240 
241   const bool default_to_use_pty = true;
242   m_process_launch_info.FinalizeFileActions(nullptr, default_to_use_pty);
243 
244   Status error;
245   {
246     std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
247     assert(!m_debugged_process_sp && "lldb-server creating debugged "
248                                      "process but one already exists");
249     error = NativeProcessProtocol::Launch(m_process_launch_info, *this,
250                                           m_mainloop, m_debugged_process_sp);
251   }
252 
253   if (!error.Success()) {
254     fprintf(stderr, "%s: failed to launch executable %s", __FUNCTION__,
255             m_process_launch_info.GetArguments().GetArgumentAtIndex(0));
256     return error;
257   }
258 
259   // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol
260   // as needed.
261   // llgs local-process debugging may specify PTY paths, which will make these
262   // file actions non-null
263   // process launch -i/e/o will also make these file actions non-null
264   // nullptr means that the traffic is expected to flow over gdb-remote protocol
265   if (should_forward_stdio) {
266     // nullptr means it's not redirected to file or pty (in case of LLGS local)
267     // at least one of stdio will be transferred pty<->gdb-remote
268     // we need to give the pty master handle to this object to read and/or write
269     if (log)
270       log->Printf(
271           "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
272           " setting up stdout/stderr redirection via $O gdb-remote commands",
273           __FUNCTION__, m_debugged_process_sp->GetID());
274 
275     // Setup stdout/stderr mapping from inferior to $O
276     auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor();
277     if (terminal_fd >= 0) {
278       if (log)
279         log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting "
280                     "inferior STDIO fd to %d",
281                     __FUNCTION__, terminal_fd);
282       error = SetSTDIOFileDescriptor(terminal_fd);
283       if (error.Fail())
284         return error;
285     } else {
286       if (log)
287         log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring "
288                     "inferior STDIO since terminal fd reported as %d",
289                     __FUNCTION__, terminal_fd);
290     }
291   } else {
292     if (log)
293       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
294                   " skipping stdout/stderr redirection via $O: inferior will "
295                   "communicate over client-provided file descriptors",
296                   __FUNCTION__, m_debugged_process_sp->GetID());
297   }
298 
299   printf("Launched '%s' as process %" PRIu64 "...\n",
300          m_process_launch_info.GetArguments().GetArgumentAtIndex(0),
301          m_process_launch_info.GetProcessID());
302 
303   return error;
304 }
305 
306 Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) {
307   Status error;
308 
309   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
310   if (log)
311     log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64,
312                 __FUNCTION__, pid);
313 
314   // Before we try to attach, make sure we aren't already monitoring something
315   // else.
316   if (m_debugged_process_sp &&
317       m_debugged_process_sp->GetID() != LLDB_INVALID_PROCESS_ID)
318     return Status("cannot attach to a process %" PRIu64
319                   " when another process with pid %" PRIu64
320                   " is being debugged.",
321                   pid, m_debugged_process_sp->GetID());
322 
323   // Try to attach.
324   error = NativeProcessProtocol::Attach(pid, *this, m_mainloop,
325                                         m_debugged_process_sp);
326   if (!error.Success()) {
327     fprintf(stderr, "%s: failed to attach to process %" PRIu64 ": %s",
328             __FUNCTION__, pid, error.AsCString());
329     return error;
330   }
331 
332   // Setup stdout/stderr mapping from inferior.
333   auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor();
334   if (terminal_fd >= 0) {
335     if (log)
336       log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting "
337                   "inferior STDIO fd to %d",
338                   __FUNCTION__, terminal_fd);
339     error = SetSTDIOFileDescriptor(terminal_fd);
340     if (error.Fail())
341       return error;
342   } else {
343     if (log)
344       log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring "
345                   "inferior STDIO since terminal fd reported as %d",
346                   __FUNCTION__, terminal_fd);
347   }
348 
349   printf("Attached to process %" PRIu64 "...\n", pid);
350 
351   return error;
352 }
353 
354 void GDBRemoteCommunicationServerLLGS::InitializeDelegate(
355     NativeProcessProtocol *process) {
356   assert(process && "process cannot be NULL");
357   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
358   if (log) {
359     log->Printf("GDBRemoteCommunicationServerLLGS::%s called with "
360                 "NativeProcessProtocol pid %" PRIu64 ", current state: %s",
361                 __FUNCTION__, process->GetID(),
362                 StateAsCString(process->GetState()));
363   }
364 }
365 
366 GDBRemoteCommunication::PacketResult
367 GDBRemoteCommunicationServerLLGS::SendWResponse(
368     NativeProcessProtocol *process) {
369   assert(process && "process cannot be NULL");
370   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
371 
372   // send W notification
373   auto wait_status = process->GetExitStatus();
374   if (!wait_status) {
375     LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status",
376              process->GetID());
377 
378     StreamGDBRemote response;
379     response.PutChar('E');
380     response.PutHex8(GDBRemoteServerError::eErrorExitStatus);
381     return SendPacketNoLock(response.GetString());
382   }
383 
384   LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(),
385            *wait_status);
386 
387   StreamGDBRemote response;
388   response.Format("{0:g}", *wait_status);
389   return SendPacketNoLock(response.GetString());
390 }
391 
392 static void AppendHexValue(StreamString &response, const uint8_t *buf,
393                            uint32_t buf_size, bool swap) {
394   int64_t i;
395   if (swap) {
396     for (i = buf_size - 1; i >= 0; i--)
397       response.PutHex8(buf[i]);
398   } else {
399     for (i = 0; i < buf_size; i++)
400       response.PutHex8(buf[i]);
401   }
402 }
403 
404 static void WriteRegisterValueInHexFixedWidth(
405     StreamString &response, NativeRegisterContextSP &reg_ctx_sp,
406     const RegisterInfo &reg_info, const RegisterValue *reg_value_p,
407     lldb::ByteOrder byte_order) {
408   RegisterValue reg_value;
409   if (!reg_value_p) {
410     Status error = reg_ctx_sp->ReadRegister(&reg_info, reg_value);
411     if (error.Success())
412       reg_value_p = &reg_value;
413     // else log.
414   }
415 
416   if (reg_value_p) {
417     AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(),
418                    reg_value_p->GetByteSize(),
419                    byte_order == lldb::eByteOrderLittle);
420   } else {
421     // Zero-out any unreadable values.
422     if (reg_info.byte_size > 0) {
423       std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
424       AppendHexValue(response, zeros.data(), zeros.size(), false);
425     }
426   }
427 }
428 
429 static JSONObject::SP GetRegistersAsJSON(NativeThreadProtocol &thread) {
430   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
431 
432   NativeRegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
433   if (!reg_ctx_sp)
434     return nullptr;
435 
436   JSONObject::SP register_object_sp = std::make_shared<JSONObject>();
437 
438 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET
439   // Expedite all registers in the first register set (i.e. should be GPRs) that
440   // are not contained in other registers.
441   const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0);
442   if (!reg_set_p)
443     return nullptr;
444   for (const uint32_t *reg_num_p = reg_set_p->registers;
445        *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) {
446     uint32_t reg_num = *reg_num_p;
447 #else
448   // Expedite only a couple of registers until we figure out why sending
449   // registers is
450   // expensive.
451   static const uint32_t k_expedited_registers[] = {
452       LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP,
453       LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM};
454 
455   for (const uint32_t *generic_reg_p = k_expedited_registers;
456        *generic_reg_p != LLDB_INVALID_REGNUM; ++generic_reg_p) {
457     uint32_t reg_num = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
458         eRegisterKindGeneric, *generic_reg_p);
459     if (reg_num == LLDB_INVALID_REGNUM)
460       continue; // Target does not support the given register.
461 #endif
462 
463     const RegisterInfo *const reg_info_p =
464         reg_ctx_sp->GetRegisterInfoAtIndex(reg_num);
465     if (reg_info_p == nullptr) {
466       if (log)
467         log->Printf(
468             "%s failed to get register info for register index %" PRIu32,
469             __FUNCTION__, reg_num);
470       continue;
471     }
472 
473     if (reg_info_p->value_regs != nullptr)
474       continue; // Only expedite registers that are not contained in other
475                 // registers.
476 
477     RegisterValue reg_value;
478     Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
479     if (error.Fail()) {
480       if (log)
481         log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s",
482                     __FUNCTION__,
483                     reg_info_p->name ? reg_info_p->name : "<unnamed-register>",
484                     reg_num, error.AsCString());
485       continue;
486     }
487 
488     StreamString stream;
489     WriteRegisterValueInHexFixedWidth(stream, reg_ctx_sp, *reg_info_p,
490                                       &reg_value, lldb::eByteOrderBig);
491 
492     register_object_sp->SetObject(
493         llvm::to_string(reg_num),
494         std::make_shared<JSONString>(stream.GetString()));
495   }
496 
497   return register_object_sp;
498 }
499 
500 static const char *GetStopReasonString(StopReason stop_reason) {
501   switch (stop_reason) {
502   case eStopReasonTrace:
503     return "trace";
504   case eStopReasonBreakpoint:
505     return "breakpoint";
506   case eStopReasonWatchpoint:
507     return "watchpoint";
508   case eStopReasonSignal:
509     return "signal";
510   case eStopReasonException:
511     return "exception";
512   case eStopReasonExec:
513     return "exec";
514   case eStopReasonInstrumentation:
515   case eStopReasonInvalid:
516   case eStopReasonPlanComplete:
517   case eStopReasonThreadExiting:
518   case eStopReasonNone:
519     break; // ignored
520   }
521   return nullptr;
522 }
523 
524 static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process,
525                                         bool abridged) {
526   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
527 
528   JSONArray::SP threads_array_sp = std::make_shared<JSONArray>();
529 
530   // Ensure we can get info on the given thread.
531   uint32_t thread_idx = 0;
532   for (NativeThreadProtocolSP thread_sp;
533        (thread_sp = process.GetThreadAtIndex(thread_idx)) != nullptr;
534        ++thread_idx) {
535 
536     lldb::tid_t tid = thread_sp->GetID();
537 
538     // Grab the reason this thread stopped.
539     struct ThreadStopInfo tid_stop_info;
540     std::string description;
541     if (!thread_sp->GetStopReason(tid_stop_info, description))
542       return nullptr;
543 
544     const int signum = tid_stop_info.details.signal.signo;
545     if (log) {
546       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
547                   " tid %" PRIu64
548                   " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
549                   __FUNCTION__, process.GetID(), tid, signum,
550                   tid_stop_info.reason, tid_stop_info.details.exception.type);
551     }
552 
553     JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
554     threads_array_sp->AppendObject(thread_obj_sp);
555 
556     if (!abridged) {
557       if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp))
558         thread_obj_sp->SetObject("registers", registers_sp);
559     }
560 
561     thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
562     if (signum != 0)
563       thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum));
564 
565     const std::string thread_name = thread_sp->GetName();
566     if (!thread_name.empty())
567       thread_obj_sp->SetObject("name",
568                                std::make_shared<JSONString>(thread_name));
569 
570     if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
571       thread_obj_sp->SetObject("reason",
572                                std::make_shared<JSONString>(stop_reason_str));
573 
574     if (!description.empty())
575       thread_obj_sp->SetObject("description",
576                                std::make_shared<JSONString>(description));
577 
578     if ((tid_stop_info.reason == eStopReasonException) &&
579         tid_stop_info.details.exception.type) {
580       thread_obj_sp->SetObject(
581           "metype",
582           std::make_shared<JSONNumber>(tid_stop_info.details.exception.type));
583 
584       JSONArray::SP medata_array_sp = std::make_shared<JSONArray>();
585       for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count;
586            ++i) {
587         medata_array_sp->AppendObject(std::make_shared<JSONNumber>(
588             tid_stop_info.details.exception.data[i]));
589       }
590       thread_obj_sp->SetObject("medata", medata_array_sp);
591     }
592 
593     // TODO: Expedite interesting regions of inferior memory
594   }
595 
596   return threads_array_sp;
597 }
598 
599 GDBRemoteCommunication::PacketResult
600 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
601     lldb::tid_t tid) {
602   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
603 
604   // Ensure we have a debugged process.
605   if (!m_debugged_process_sp ||
606       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
607     return SendErrorResponse(50);
608 
609   if (log)
610     log->Printf(
611         "GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64
612         " tid %" PRIu64,
613         __FUNCTION__, m_debugged_process_sp->GetID(), tid);
614 
615   // Ensure we can get info on the given thread.
616   NativeThreadProtocolSP thread_sp(m_debugged_process_sp->GetThreadByID(tid));
617   if (!thread_sp)
618     return SendErrorResponse(51);
619 
620   // Grab the reason this thread stopped.
621   struct ThreadStopInfo tid_stop_info;
622   std::string description;
623   if (!thread_sp->GetStopReason(tid_stop_info, description))
624     return SendErrorResponse(52);
625 
626   // FIXME implement register handling for exec'd inferiors.
627   // if (tid_stop_info.reason == eStopReasonExec)
628   // {
629   //     const bool force = true;
630   //     InitializeRegisters(force);
631   // }
632 
633   StreamString response;
634   // Output the T packet with the thread
635   response.PutChar('T');
636   int signum = tid_stop_info.details.signal.signo;
637   if (log) {
638     log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
639                 " tid %" PRIu64
640                 " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
641                 __FUNCTION__, m_debugged_process_sp->GetID(), tid, signum,
642                 tid_stop_info.reason, tid_stop_info.details.exception.type);
643   }
644 
645   // Print the signal number.
646   response.PutHex8(signum & 0xff);
647 
648   // Include the tid.
649   response.Printf("thread:%" PRIx64 ";", tid);
650 
651   // Include the thread name if there is one.
652   const std::string thread_name = thread_sp->GetName();
653   if (!thread_name.empty()) {
654     size_t thread_name_len = thread_name.length();
655 
656     if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) {
657       response.PutCString("name:");
658       response.PutCString(thread_name);
659     } else {
660       // The thread name contains special chars, send as hex bytes.
661       response.PutCString("hexname:");
662       response.PutCStringAsRawHex8(thread_name.c_str());
663     }
664     response.PutChar(';');
665   }
666 
667   // If a 'QListThreadsInStopReply' was sent to enable this feature, we
668   // will send all thread IDs back in the "threads" key whose value is
669   // a list of hex thread IDs separated by commas:
670   //  "threads:10a,10b,10c;"
671   // This will save the debugger from having to send a pair of qfThreadInfo
672   // and qsThreadInfo packets, but it also might take a lot of room in the
673   // stop reply packet, so it must be enabled only on systems where there
674   // are no limits on packet lengths.
675   if (m_list_threads_in_stop_reply) {
676     response.PutCString("threads:");
677 
678     uint32_t thread_index = 0;
679     NativeThreadProtocolSP listed_thread_sp;
680     for (listed_thread_sp =
681              m_debugged_process_sp->GetThreadAtIndex(thread_index);
682          listed_thread_sp; ++thread_index,
683         listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex(
684             thread_index)) {
685       if (thread_index > 0)
686         response.PutChar(',');
687       response.Printf("%" PRIx64, listed_thread_sp->GetID());
688     }
689     response.PutChar(';');
690 
691     // Include JSON info that describes the stop reason for any threads
692     // that actually have stop reasons. We use the new "jstopinfo" key
693     // whose values is hex ascii JSON that contains the thread IDs
694     // thread stop info only for threads that have stop reasons. Only send
695     // this if we have more than one thread otherwise this packet has all
696     // the info it needs.
697     if (thread_index > 0) {
698       const bool threads_with_valid_stop_info_only = true;
699       JSONArray::SP threads_info_sp = GetJSONThreadsInfo(
700           *m_debugged_process_sp, threads_with_valid_stop_info_only);
701       if (threads_info_sp) {
702         response.PutCString("jstopinfo:");
703         StreamString unescaped_response;
704         threads_info_sp->Write(unescaped_response);
705         response.PutCStringAsRawHex8(unescaped_response.GetData());
706         response.PutChar(';');
707       } else if (log)
708         log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to prepare a "
709                     "jstopinfo field for pid %" PRIu64,
710                     __FUNCTION__, m_debugged_process_sp->GetID());
711     }
712 
713     uint32_t i = 0;
714     response.PutCString("thread-pcs");
715     char delimiter = ':';
716     for (NativeThreadProtocolSP thread_sp;
717          (thread_sp = m_debugged_process_sp->GetThreadAtIndex(i)) != nullptr;
718          ++i) {
719       NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
720       if (!reg_ctx_sp)
721         continue;
722 
723       uint32_t reg_to_read = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
724           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
725       const RegisterInfo *const reg_info_p =
726           reg_ctx_sp->GetRegisterInfoAtIndex(reg_to_read);
727 
728       RegisterValue reg_value;
729       Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
730       if (error.Fail()) {
731         if (log)
732           log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s",
733                       __FUNCTION__,
734                       reg_info_p->name ? reg_info_p->name
735                                        : "<unnamed-register>",
736                       reg_to_read, error.AsCString());
737         continue;
738       }
739 
740       response.PutChar(delimiter);
741       delimiter = ',';
742       WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p,
743                                         &reg_value, endian::InlHostByteOrder());
744     }
745 
746     response.PutChar(';');
747   }
748 
749   //
750   // Expedite registers.
751   //
752 
753   // Grab the register context.
754   NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
755   if (reg_ctx_sp) {
756     // Expedite all registers in the first register set (i.e. should be GPRs)
757     // that are not contained in other registers.
758     const RegisterSet *reg_set_p;
759     if (reg_ctx_sp->GetRegisterSetCount() > 0 &&
760         ((reg_set_p = reg_ctx_sp->GetRegisterSet(0)) != nullptr)) {
761       if (log)
762         log->Printf("GDBRemoteCommunicationServerLLGS::%s expediting registers "
763                     "from set '%s' (registers set count: %zu)",
764                     __FUNCTION__,
765                     reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
766                     reg_set_p->num_registers);
767 
768       for (const uint32_t *reg_num_p = reg_set_p->registers;
769            *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) {
770         const RegisterInfo *const reg_info_p =
771             reg_ctx_sp->GetRegisterInfoAtIndex(*reg_num_p);
772         if (reg_info_p == nullptr) {
773           if (log)
774             log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get "
775                         "register info for register set '%s', register index "
776                         "%" PRIu32,
777                         __FUNCTION__,
778                         reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
779                         *reg_num_p);
780         } else if (reg_info_p->value_regs == nullptr) {
781           // Only expediate registers that are not contained in other registers.
782           RegisterValue reg_value;
783           Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
784           if (error.Success()) {
785             response.Printf("%.02x:", *reg_num_p);
786             WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p,
787                                               &reg_value, lldb::eByteOrderBig);
788             response.PutChar(';');
789           } else {
790             if (log)
791               log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to read "
792                           "register '%s' index %" PRIu32 ": %s",
793                           __FUNCTION__, reg_info_p->name ? reg_info_p->name
794                                                          : "<unnamed-register>",
795                           *reg_num_p, error.AsCString());
796           }
797         }
798       }
799     }
800   }
801 
802   const char *reason_str = GetStopReasonString(tid_stop_info.reason);
803   if (reason_str != nullptr) {
804     response.Printf("reason:%s;", reason_str);
805   }
806 
807   if (!description.empty()) {
808     // Description may contains special chars, send as hex bytes.
809     response.PutCString("description:");
810     response.PutCStringAsRawHex8(description.c_str());
811     response.PutChar(';');
812   } else if ((tid_stop_info.reason == eStopReasonException) &&
813              tid_stop_info.details.exception.type) {
814     response.PutCString("metype:");
815     response.PutHex64(tid_stop_info.details.exception.type);
816     response.PutCString(";mecount:");
817     response.PutHex32(tid_stop_info.details.exception.data_count);
818     response.PutChar(';');
819 
820     for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) {
821       response.PutCString("medata:");
822       response.PutHex64(tid_stop_info.details.exception.data[i]);
823       response.PutChar(';');
824     }
825   }
826 
827   return SendPacketNoLock(response.GetString());
828 }
829 
830 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited(
831     NativeProcessProtocol *process) {
832   assert(process && "process cannot be NULL");
833 
834   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
835   if (log)
836     log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
837 
838   PacketResult result = SendStopReasonForState(StateType::eStateExited);
839   if (result != PacketResult::Success) {
840     if (log)
841       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop "
842                   "notification for PID %" PRIu64 ", state: eStateExited",
843                   __FUNCTION__, process->GetID());
844   }
845 
846   // Close the pipe to the inferior terminal i/o if we launched it
847   // and set one up.
848   MaybeCloseInferiorTerminalConnection();
849 
850   // We are ready to exit the debug monitor.
851   m_exit_now = true;
852 }
853 
854 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped(
855     NativeProcessProtocol *process) {
856   assert(process && "process cannot be NULL");
857 
858   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
859   if (log)
860     log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
861 
862   // Send the stop reason unless this is the stop after the
863   // launch or attach.
864   switch (m_inferior_prev_state) {
865   case eStateLaunching:
866   case eStateAttaching:
867     // Don't send anything per debugserver behavior.
868     break;
869   default:
870     // In all other cases, send the stop reason.
871     PacketResult result = SendStopReasonForState(StateType::eStateStopped);
872     if (result != PacketResult::Success) {
873       if (log)
874         log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop "
875                     "notification for PID %" PRIu64 ", state: eStateExited",
876                     __FUNCTION__, process->GetID());
877     }
878     break;
879   }
880 }
881 
882 void GDBRemoteCommunicationServerLLGS::ProcessStateChanged(
883     NativeProcessProtocol *process, lldb::StateType state) {
884   assert(process && "process cannot be NULL");
885   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
886   if (log) {
887     log->Printf("GDBRemoteCommunicationServerLLGS::%s called with "
888                 "NativeProcessProtocol pid %" PRIu64 ", state: %s",
889                 __FUNCTION__, process->GetID(), StateAsCString(state));
890   }
891 
892   switch (state) {
893   case StateType::eStateRunning:
894     StartSTDIOForwarding();
895     break;
896 
897   case StateType::eStateStopped:
898     // Make sure we get all of the pending stdout/stderr from the inferior
899     // and send it to the lldb host before we send the state change
900     // notification
901     SendProcessOutput();
902     // Then stop the forwarding, so that any late output (see llvm.org/pr25652)
903     // does not
904     // interfere with our protocol.
905     StopSTDIOForwarding();
906     HandleInferiorState_Stopped(process);
907     break;
908 
909   case StateType::eStateExited:
910     // Same as above
911     SendProcessOutput();
912     StopSTDIOForwarding();
913     HandleInferiorState_Exited(process);
914     break;
915 
916   default:
917     if (log) {
918       log->Printf("GDBRemoteCommunicationServerLLGS::%s didn't handle state "
919                   "change for pid %" PRIu64 ", new state: %s",
920                   __FUNCTION__, process->GetID(), StateAsCString(state));
921     }
922     break;
923   }
924 
925   // Remember the previous state reported to us.
926   m_inferior_prev_state = state;
927 }
928 
929 void GDBRemoteCommunicationServerLLGS::DidExec(NativeProcessProtocol *process) {
930   ClearProcessSpecificData();
931 }
932 
933 void GDBRemoteCommunicationServerLLGS::DataAvailableCallback() {
934   Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_COMM));
935 
936   if (!m_handshake_completed) {
937     if (!HandshakeWithClient()) {
938       if (log)
939         log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with "
940                     "client failed, exiting",
941                     __FUNCTION__);
942       m_mainloop.RequestTermination();
943       return;
944     }
945     m_handshake_completed = true;
946   }
947 
948   bool interrupt = false;
949   bool done = false;
950   Status error;
951   while (true) {
952     const PacketResult result = GetPacketAndSendResponse(
953         std::chrono::microseconds(0), error, interrupt, done);
954     if (result == PacketResult::ErrorReplyTimeout)
955       break; // No more packets in the queue
956 
957     if ((result != PacketResult::Success)) {
958       if (log)
959         log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet "
960                     "failed: %s",
961                     __FUNCTION__, error.AsCString());
962       m_mainloop.RequestTermination();
963       break;
964     }
965   }
966 }
967 
968 Status GDBRemoteCommunicationServerLLGS::InitializeConnection(
969     std::unique_ptr<Connection> &&connection) {
970   IOObjectSP read_object_sp = connection->GetReadObject();
971   GDBRemoteCommunicationServer::SetConnection(connection.release());
972 
973   Status error;
974   m_network_handle_up = m_mainloop.RegisterReadObject(
975       read_object_sp, [this](MainLoopBase &) { DataAvailableCallback(); },
976       error);
977   return error;
978 }
979 
980 GDBRemoteCommunication::PacketResult
981 GDBRemoteCommunicationServerLLGS::SendONotification(const char *buffer,
982                                                     uint32_t len) {
983   if ((buffer == nullptr) || (len == 0)) {
984     // Nothing to send.
985     return PacketResult::Success;
986   }
987 
988   StreamString response;
989   response.PutChar('O');
990   response.PutBytesAsRawHex8(buffer, len);
991 
992   return SendPacketNoLock(response.GetString());
993 }
994 
995 Status GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) {
996   Status error;
997 
998   // Set up the reading/handling of process I/O
999   std::unique_ptr<ConnectionFileDescriptor> conn_up(
1000       new ConnectionFileDescriptor(fd, true));
1001   if (!conn_up) {
1002     error.SetErrorString("failed to create ConnectionFileDescriptor");
1003     return error;
1004   }
1005 
1006   m_stdio_communication.SetCloseOnEOF(false);
1007   m_stdio_communication.SetConnection(conn_up.release());
1008   if (!m_stdio_communication.IsConnected()) {
1009     error.SetErrorString(
1010         "failed to set connection for inferior I/O communication");
1011     return error;
1012   }
1013 
1014   return Status();
1015 }
1016 
1017 void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() {
1018   // Don't forward if not connected (e.g. when attaching).
1019   if (!m_stdio_communication.IsConnected())
1020     return;
1021 
1022   Status error;
1023   lldbassert(!m_stdio_handle_up);
1024   m_stdio_handle_up = m_mainloop.RegisterReadObject(
1025       m_stdio_communication.GetConnection()->GetReadObject(),
1026       [this](MainLoopBase &) { SendProcessOutput(); }, error);
1027 
1028   if (!m_stdio_handle_up) {
1029     // Not much we can do about the failure. Log it and continue without
1030     // forwarding.
1031     if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS))
1032       log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio "
1033                   "forwarding: %s",
1034                   __FUNCTION__, error.AsCString());
1035   }
1036 }
1037 
1038 void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() {
1039   m_stdio_handle_up.reset();
1040 }
1041 
1042 void GDBRemoteCommunicationServerLLGS::SendProcessOutput() {
1043   char buffer[1024];
1044   ConnectionStatus status;
1045   Status error;
1046   while (true) {
1047     size_t bytes_read = m_stdio_communication.Read(
1048         buffer, sizeof buffer, std::chrono::microseconds(0), status, &error);
1049     switch (status) {
1050     case eConnectionStatusSuccess:
1051       SendONotification(buffer, bytes_read);
1052       break;
1053     case eConnectionStatusLostConnection:
1054     case eConnectionStatusEndOfFile:
1055     case eConnectionStatusError:
1056     case eConnectionStatusNoConnection:
1057       if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS))
1058         log->Printf("GDBRemoteCommunicationServerLLGS::%s Stopping stdio "
1059                     "forwarding as communication returned status %d (error: "
1060                     "%s)",
1061                     __FUNCTION__, status, error.AsCString());
1062       m_stdio_handle_up.reset();
1063       return;
1064 
1065     case eConnectionStatusInterrupted:
1066     case eConnectionStatusTimedOut:
1067       return;
1068     }
1069   }
1070 }
1071 
1072 GDBRemoteCommunication::PacketResult
1073 GDBRemoteCommunicationServerLLGS::Handle_jTraceStart(
1074     StringExtractorGDBRemote &packet) {
1075   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1076   // Fail if we don't have a current process.
1077   if (!m_debugged_process_sp ||
1078       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1079     return SendErrorResponse(68);
1080 
1081   if (!packet.ConsumeFront("jTraceStart:"))
1082     return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
1083 
1084   TraceOptions options;
1085   uint64_t type = std::numeric_limits<uint64_t>::max();
1086   uint64_t buffersize = std::numeric_limits<uint64_t>::max();
1087   lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
1088   uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
1089 
1090   auto json_object = StructuredData::ParseJSON(packet.Peek());
1091 
1092   if (!json_object ||
1093       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
1094     return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
1095 
1096   auto json_dict = json_object->GetAsDictionary();
1097 
1098   json_dict->GetValueForKeyAsInteger("metabuffersize", metabuffersize);
1099   options.setMetaDataBufferSize(metabuffersize);
1100 
1101   json_dict->GetValueForKeyAsInteger("buffersize", buffersize);
1102   options.setTraceBufferSize(buffersize);
1103 
1104   json_dict->GetValueForKeyAsInteger("type", type);
1105   options.setType(static_cast<lldb::TraceType>(type));
1106 
1107   json_dict->GetValueForKeyAsInteger("threadid", tid);
1108   options.setThreadID(tid);
1109 
1110   StructuredData::ObjectSP custom_params_sp =
1111       json_dict->GetValueForKey("params");
1112   if (custom_params_sp &&
1113       custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary)
1114     return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
1115 
1116   options.setTraceParams(
1117       static_pointer_cast<StructuredData::Dictionary>(custom_params_sp));
1118 
1119   if (buffersize == std::numeric_limits<uint64_t>::max() ||
1120       type != lldb::TraceType::eTraceTypeProcessorTrace) {
1121     LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize,
1122              type);
1123     return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet ");
1124   }
1125 
1126   Status error;
1127   lldb::user_id_t uid = LLDB_INVALID_UID;
1128   uid = m_debugged_process_sp->StartTrace(options, error);
1129   LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError());
1130   if (error.Fail())
1131     return SendErrorResponse(error.GetError());
1132 
1133   StreamGDBRemote response;
1134   response.Printf("%" PRIx64, uid);
1135   return SendPacketNoLock(response.GetString());
1136 }
1137 
1138 GDBRemoteCommunication::PacketResult
1139 GDBRemoteCommunicationServerLLGS::Handle_jTraceStop(
1140     StringExtractorGDBRemote &packet) {
1141   // Fail if we don't have a current process.
1142   if (!m_debugged_process_sp ||
1143       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1144     return SendErrorResponse(68);
1145 
1146   if (!packet.ConsumeFront("jTraceStop:"))
1147     return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
1148 
1149   lldb::user_id_t uid = LLDB_INVALID_UID;
1150   lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
1151 
1152   auto json_object = StructuredData::ParseJSON(packet.Peek());
1153 
1154   if (!json_object ||
1155       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
1156     return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
1157 
1158   auto json_dict = json_object->GetAsDictionary();
1159 
1160   if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
1161     return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
1162 
1163   json_dict->GetValueForKeyAsInteger("threadid", tid);
1164 
1165   Status error = m_debugged_process_sp->StopTrace(uid, tid);
1166 
1167   if (error.Fail())
1168     return SendErrorResponse(error.GetError());
1169 
1170   return SendOKResponse();
1171 }
1172 
1173 GDBRemoteCommunication::PacketResult
1174 GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead(
1175     StringExtractorGDBRemote &packet) {
1176 
1177   // Fail if we don't have a current process.
1178   if (!m_debugged_process_sp ||
1179       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1180     return SendErrorResponse(68);
1181 
1182   if (!packet.ConsumeFront("jTraceConfigRead:"))
1183     return SendIllFormedResponse(packet,
1184                                  "jTraceConfigRead: Ill formed packet ");
1185 
1186   lldb::user_id_t uid = LLDB_INVALID_UID;
1187   lldb::tid_t threadid = LLDB_INVALID_THREAD_ID;
1188 
1189   auto json_object = StructuredData::ParseJSON(packet.Peek());
1190 
1191   if (!json_object ||
1192       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
1193     return SendIllFormedResponse(packet,
1194                                  "jTraceConfigRead: Ill formed packet ");
1195 
1196   auto json_dict = json_object->GetAsDictionary();
1197 
1198   if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
1199     return SendIllFormedResponse(packet,
1200                                  "jTraceConfigRead: Ill formed packet ");
1201 
1202   json_dict->GetValueForKeyAsInteger("threadid", threadid);
1203 
1204   TraceOptions options;
1205   StreamGDBRemote response;
1206 
1207   options.setThreadID(threadid);
1208   Status error = m_debugged_process_sp->GetTraceConfig(uid, options);
1209 
1210   if (error.Fail())
1211     return SendErrorResponse(error.GetError());
1212 
1213   StreamGDBRemote escaped_response;
1214   StructuredData::Dictionary json_packet;
1215 
1216   json_packet.AddIntegerItem("type", options.getType());
1217   json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
1218   json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
1219 
1220   StructuredData::DictionarySP custom_params = options.getTraceParams();
1221   if (custom_params)
1222     json_packet.AddItem("params", custom_params);
1223 
1224   StreamString json_string;
1225   json_packet.Dump(json_string, false);
1226   escaped_response.PutEscapedBytes(json_string.GetData(),
1227                                    json_string.GetSize());
1228   return SendPacketNoLock(escaped_response.GetString());
1229 }
1230 
1231 GDBRemoteCommunication::PacketResult
1232 GDBRemoteCommunicationServerLLGS::Handle_jTraceRead(
1233     StringExtractorGDBRemote &packet) {
1234 
1235   // Fail if we don't have a current process.
1236   if (!m_debugged_process_sp ||
1237       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1238     return SendErrorResponse(68);
1239 
1240   enum PacketType { MetaData, BufferData };
1241   PacketType tracetype = MetaData;
1242 
1243   if (packet.ConsumeFront("jTraceBufferRead:"))
1244     tracetype = BufferData;
1245   else if (packet.ConsumeFront("jTraceMetaRead:"))
1246     tracetype = MetaData;
1247   else {
1248     return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
1249   }
1250 
1251   lldb::user_id_t uid = LLDB_INVALID_UID;
1252 
1253   size_t byte_count = std::numeric_limits<size_t>::max();
1254   lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
1255   size_t offset = std::numeric_limits<size_t>::max();
1256 
1257   auto json_object = StructuredData::ParseJSON(packet.Peek());
1258 
1259   if (!json_object ||
1260       json_object->GetType() != lldb::eStructuredDataTypeDictionary)
1261     return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
1262 
1263   auto json_dict = json_object->GetAsDictionary();
1264 
1265   if (!json_dict->GetValueForKeyAsInteger("traceid", uid) ||
1266       !json_dict->GetValueForKeyAsInteger("offset", offset) ||
1267       !json_dict->GetValueForKeyAsInteger("buffersize", byte_count))
1268     return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
1269 
1270   json_dict->GetValueForKeyAsInteger("threadid", tid);
1271 
1272   // Allocate the response buffer.
1273   std::unique_ptr<uint8_t[]> buffer (new (std::nothrow) uint8_t[byte_count]);
1274   if (!buffer)
1275     return SendErrorResponse(0x78);
1276 
1277   StreamGDBRemote response;
1278   Status error;
1279   llvm::MutableArrayRef<uint8_t> buf(buffer.get(), byte_count);
1280 
1281   if (tracetype == BufferData)
1282     error = m_debugged_process_sp->GetData(uid, tid, buf, offset);
1283   else if (tracetype == MetaData)
1284     error = m_debugged_process_sp->GetMetaData(uid, tid, buf, offset);
1285 
1286   if (error.Fail())
1287     return SendErrorResponse(error.GetError());
1288 
1289   for (size_t i = 0; i < buf.size(); ++i)
1290     response.PutHex8(buf[i]);
1291 
1292   StreamGDBRemote escaped_response;
1293   escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
1294   return SendPacketNoLock(escaped_response.GetString());
1295 }
1296 
1297 GDBRemoteCommunication::PacketResult
1298 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
1299     StringExtractorGDBRemote &packet) {
1300   // Fail if we don't have a current process.
1301   if (!m_debugged_process_sp ||
1302       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1303     return SendErrorResponse(68);
1304 
1305   lldb::pid_t pid = m_debugged_process_sp->GetID();
1306 
1307   if (pid == LLDB_INVALID_PROCESS_ID)
1308     return SendErrorResponse(1);
1309 
1310   ProcessInstanceInfo proc_info;
1311   if (!Host::GetProcessInfo(pid, proc_info))
1312     return SendErrorResponse(1);
1313 
1314   StreamString response;
1315   CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
1316   return SendPacketNoLock(response.GetString());
1317 }
1318 
1319 GDBRemoteCommunication::PacketResult
1320 GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) {
1321   // Fail if we don't have a current process.
1322   if (!m_debugged_process_sp ||
1323       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1324     return SendErrorResponse(68);
1325 
1326   // Make sure we set the current thread so g and p packets return
1327   // the data the gdb will expect.
1328   lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID();
1329   SetCurrentThreadID(tid);
1330 
1331   NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetCurrentThread();
1332   if (!thread_sp)
1333     return SendErrorResponse(69);
1334 
1335   StreamString response;
1336   response.Printf("QC%" PRIx64, thread_sp->GetID());
1337 
1338   return SendPacketNoLock(response.GetString());
1339 }
1340 
1341 GDBRemoteCommunication::PacketResult
1342 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
1343   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1344 
1345   StopSTDIOForwarding();
1346 
1347   if (!m_debugged_process_sp) {
1348     if (log)
1349       log->Printf(
1350           "GDBRemoteCommunicationServerLLGS::%s No debugged process found.",
1351           __FUNCTION__);
1352     return PacketResult::Success;
1353   }
1354 
1355   Status error = m_debugged_process_sp->Kill();
1356   if (error.Fail() && log)
1357     log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to kill debugged "
1358                 "process %" PRIu64 ": %s",
1359                 __FUNCTION__, m_debugged_process_sp->GetID(),
1360                 error.AsCString());
1361 
1362   // No OK response for kill packet.
1363   // return SendOKResponse ();
1364   return PacketResult::Success;
1365 }
1366 
1367 GDBRemoteCommunication::PacketResult
1368 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR(
1369     StringExtractorGDBRemote &packet) {
1370   packet.SetFilePos(::strlen("QSetDisableASLR:"));
1371   if (packet.GetU32(0))
1372     m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR);
1373   else
1374     m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR);
1375   return SendOKResponse();
1376 }
1377 
1378 GDBRemoteCommunication::PacketResult
1379 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir(
1380     StringExtractorGDBRemote &packet) {
1381   packet.SetFilePos(::strlen("QSetWorkingDir:"));
1382   std::string path;
1383   packet.GetHexByteString(path);
1384   m_process_launch_info.SetWorkingDirectory(FileSpec{path, true});
1385   return SendOKResponse();
1386 }
1387 
1388 GDBRemoteCommunication::PacketResult
1389 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
1390     StringExtractorGDBRemote &packet) {
1391   FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
1392   if (working_dir) {
1393     StreamString response;
1394     response.PutCStringAsRawHex8(working_dir.GetCString());
1395     return SendPacketNoLock(response.GetString());
1396   }
1397 
1398   return SendErrorResponse(14);
1399 }
1400 
1401 GDBRemoteCommunication::PacketResult
1402 GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) {
1403   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
1404   if (log)
1405     log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
1406 
1407   // Ensure we have a native process.
1408   if (!m_debugged_process_sp) {
1409     if (log)
1410       log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
1411                   "shared pointer",
1412                   __FUNCTION__);
1413     return SendErrorResponse(0x36);
1414   }
1415 
1416   // Pull out the signal number.
1417   packet.SetFilePos(::strlen("C"));
1418   if (packet.GetBytesLeft() < 1) {
1419     // Shouldn't be using a C without a signal.
1420     return SendIllFormedResponse(packet, "C packet specified without signal.");
1421   }
1422   const uint32_t signo =
1423       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
1424   if (signo == std::numeric_limits<uint32_t>::max())
1425     return SendIllFormedResponse(packet, "failed to parse signal number");
1426 
1427   // Handle optional continue address.
1428   if (packet.GetBytesLeft() > 0) {
1429     // FIXME add continue at address support for $C{signo}[;{continue-address}].
1430     if (*packet.Peek() == ';')
1431       return SendUnimplementedResponse(packet.GetStringRef().c_str());
1432     else
1433       return SendIllFormedResponse(
1434           packet, "unexpected content after $C{signal-number}");
1435   }
1436 
1437   ResumeActionList resume_actions(StateType::eStateRunning, 0);
1438   Status error;
1439 
1440   // We have two branches: what to do if a continue thread is specified (in
1441   // which case we target
1442   // sending the signal to that thread), or when we don't have a continue thread
1443   // set (in which
1444   // case we send a signal to the process).
1445 
1446   // TODO discuss with Greg Clayton, make sure this makes sense.
1447 
1448   lldb::tid_t signal_tid = GetContinueThreadID();
1449   if (signal_tid != LLDB_INVALID_THREAD_ID) {
1450     // The resume action for the continue thread (or all threads if a continue
1451     // thread is not set).
1452     ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning,
1453                            static_cast<int>(signo)};
1454 
1455     // Add the action for the continue thread (or all threads when the continue
1456     // thread isn't present).
1457     resume_actions.Append(action);
1458   } else {
1459     // Send the signal to the process since we weren't targeting a specific
1460     // continue thread with the signal.
1461     error = m_debugged_process_sp->Signal(signo);
1462     if (error.Fail()) {
1463       if (log)
1464         log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send "
1465                     "signal for process %" PRIu64 ": %s",
1466                     __FUNCTION__, m_debugged_process_sp->GetID(),
1467                     error.AsCString());
1468 
1469       return SendErrorResponse(0x52);
1470     }
1471   }
1472 
1473   // Resume the threads.
1474   error = m_debugged_process_sp->Resume(resume_actions);
1475   if (error.Fail()) {
1476     if (log)
1477       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to resume "
1478                   "threads for process %" PRIu64 ": %s",
1479                   __FUNCTION__, m_debugged_process_sp->GetID(),
1480                   error.AsCString());
1481 
1482     return SendErrorResponse(0x38);
1483   }
1484 
1485   // Don't send an "OK" packet; response is the stopped/exited message.
1486   return PacketResult::Success;
1487 }
1488 
1489 GDBRemoteCommunication::PacketResult
1490 GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) {
1491   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
1492   if (log)
1493     log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
1494 
1495   packet.SetFilePos(packet.GetFilePos() + ::strlen("c"));
1496 
1497   // For now just support all continue.
1498   const bool has_continue_address = (packet.GetBytesLeft() > 0);
1499   if (has_continue_address) {
1500     if (log)
1501       log->Printf("GDBRemoteCommunicationServerLLGS::%s not implemented for "
1502                   "c{address} variant [%s remains]",
1503                   __FUNCTION__, packet.Peek());
1504     return SendUnimplementedResponse(packet.GetStringRef().c_str());
1505   }
1506 
1507   // Ensure we have a native process.
1508   if (!m_debugged_process_sp) {
1509     if (log)
1510       log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
1511                   "shared pointer",
1512                   __FUNCTION__);
1513     return SendErrorResponse(0x36);
1514   }
1515 
1516   // Build the ResumeActionList
1517   ResumeActionList actions(StateType::eStateRunning, 0);
1518 
1519   Status error = m_debugged_process_sp->Resume(actions);
1520   if (error.Fail()) {
1521     if (log) {
1522       log->Printf(
1523           "GDBRemoteCommunicationServerLLGS::%s c failed for process %" PRIu64
1524           ": %s",
1525           __FUNCTION__, m_debugged_process_sp->GetID(), error.AsCString());
1526     }
1527     return SendErrorResponse(GDBRemoteServerError::eErrorResume);
1528   }
1529 
1530   if (log)
1531     log->Printf(
1532         "GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64,
1533         __FUNCTION__, m_debugged_process_sp->GetID());
1534 
1535   // No response required from continue.
1536   return PacketResult::Success;
1537 }
1538 
1539 GDBRemoteCommunication::PacketResult
1540 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions(
1541     StringExtractorGDBRemote &packet) {
1542   StreamString response;
1543   response.Printf("vCont;c;C;s;S");
1544 
1545   return SendPacketNoLock(response.GetString());
1546 }
1547 
1548 GDBRemoteCommunication::PacketResult
1549 GDBRemoteCommunicationServerLLGS::Handle_vCont(
1550     StringExtractorGDBRemote &packet) {
1551   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1552   if (log)
1553     log->Printf("GDBRemoteCommunicationServerLLGS::%s handling vCont packet",
1554                 __FUNCTION__);
1555 
1556   packet.SetFilePos(::strlen("vCont"));
1557 
1558   if (packet.GetBytesLeft() == 0) {
1559     if (log)
1560       log->Printf("GDBRemoteCommunicationServerLLGS::%s missing action from "
1561                   "vCont package",
1562                   __FUNCTION__);
1563     return SendIllFormedResponse(packet, "Missing action from vCont package");
1564   }
1565 
1566   // Check if this is all continue (no options or ";c").
1567   if (::strcmp(packet.Peek(), ";c") == 0) {
1568     // Move past the ';', then do a simple 'c'.
1569     packet.SetFilePos(packet.GetFilePos() + 1);
1570     return Handle_c(packet);
1571   } else if (::strcmp(packet.Peek(), ";s") == 0) {
1572     // Move past the ';', then do a simple 's'.
1573     packet.SetFilePos(packet.GetFilePos() + 1);
1574     return Handle_s(packet);
1575   }
1576 
1577   // Ensure we have a native process.
1578   if (!m_debugged_process_sp) {
1579     if (log)
1580       log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
1581                   "shared pointer",
1582                   __FUNCTION__);
1583     return SendErrorResponse(0x36);
1584   }
1585 
1586   ResumeActionList thread_actions;
1587 
1588   while (packet.GetBytesLeft() && *packet.Peek() == ';') {
1589     // Skip the semi-colon.
1590     packet.GetChar();
1591 
1592     // Build up the thread action.
1593     ResumeAction thread_action;
1594     thread_action.tid = LLDB_INVALID_THREAD_ID;
1595     thread_action.state = eStateInvalid;
1596     thread_action.signal = 0;
1597 
1598     const char action = packet.GetChar();
1599     switch (action) {
1600     case 'C':
1601       thread_action.signal = packet.GetHexMaxU32(false, 0);
1602       if (thread_action.signal == 0)
1603         return SendIllFormedResponse(
1604             packet, "Could not parse signal in vCont packet C action");
1605       LLVM_FALLTHROUGH;
1606 
1607     case 'c':
1608       // Continue
1609       thread_action.state = eStateRunning;
1610       break;
1611 
1612     case 'S':
1613       thread_action.signal = packet.GetHexMaxU32(false, 0);
1614       if (thread_action.signal == 0)
1615         return SendIllFormedResponse(
1616             packet, "Could not parse signal in vCont packet S action");
1617       LLVM_FALLTHROUGH;
1618 
1619     case 's':
1620       // Step
1621       thread_action.state = eStateStepping;
1622       break;
1623 
1624     default:
1625       return SendIllFormedResponse(packet, "Unsupported vCont action");
1626       break;
1627     }
1628 
1629     // Parse out optional :{thread-id} value.
1630     if (packet.GetBytesLeft() && (*packet.Peek() == ':')) {
1631       // Consume the separator.
1632       packet.GetChar();
1633 
1634       thread_action.tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID);
1635       if (thread_action.tid == LLDB_INVALID_THREAD_ID)
1636         return SendIllFormedResponse(
1637             packet, "Could not parse thread number in vCont packet");
1638     }
1639 
1640     thread_actions.Append(thread_action);
1641   }
1642 
1643   Status error = m_debugged_process_sp->Resume(thread_actions);
1644   if (error.Fail()) {
1645     if (log) {
1646       log->Printf("GDBRemoteCommunicationServerLLGS::%s vCont failed for "
1647                   "process %" PRIu64 ": %s",
1648                   __FUNCTION__, m_debugged_process_sp->GetID(),
1649                   error.AsCString());
1650     }
1651     return SendErrorResponse(GDBRemoteServerError::eErrorResume);
1652   }
1653 
1654   if (log)
1655     log->Printf(
1656         "GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64,
1657         __FUNCTION__, m_debugged_process_sp->GetID());
1658 
1659   // No response required from vCont.
1660   return PacketResult::Success;
1661 }
1662 
1663 void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) {
1664   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1665   if (log)
1666     log->Printf("GDBRemoteCommunicationServerLLGS::%s setting current thread "
1667                 "id to %" PRIu64,
1668                 __FUNCTION__, tid);
1669 
1670   m_current_tid = tid;
1671   if (m_debugged_process_sp)
1672     m_debugged_process_sp->SetCurrentThreadID(m_current_tid);
1673 }
1674 
1675 void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) {
1676   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1677   if (log)
1678     log->Printf("GDBRemoteCommunicationServerLLGS::%s setting continue thread "
1679                 "id to %" PRIu64,
1680                 __FUNCTION__, tid);
1681 
1682   m_continue_tid = tid;
1683 }
1684 
1685 GDBRemoteCommunication::PacketResult
1686 GDBRemoteCommunicationServerLLGS::Handle_stop_reason(
1687     StringExtractorGDBRemote &packet) {
1688   // Handle the $? gdbremote command.
1689 
1690   // If no process, indicate error
1691   if (!m_debugged_process_sp)
1692     return SendErrorResponse(02);
1693 
1694   return SendStopReasonForState(m_debugged_process_sp->GetState());
1695 }
1696 
1697 GDBRemoteCommunication::PacketResult
1698 GDBRemoteCommunicationServerLLGS::SendStopReasonForState(
1699     lldb::StateType process_state) {
1700   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1701 
1702   switch (process_state) {
1703   case eStateAttaching:
1704   case eStateLaunching:
1705   case eStateRunning:
1706   case eStateStepping:
1707   case eStateDetached:
1708     // NOTE: gdb protocol doc looks like it should return $OK
1709     // when everything is running (i.e. no stopped result).
1710     return PacketResult::Success; // Ignore
1711 
1712   case eStateSuspended:
1713   case eStateStopped:
1714   case eStateCrashed: {
1715     lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID();
1716     // Make sure we set the current thread so g and p packets return
1717     // the data the gdb will expect.
1718     SetCurrentThreadID(tid);
1719     return SendStopReplyPacketForThread(tid);
1720   }
1721 
1722   case eStateInvalid:
1723   case eStateUnloaded:
1724   case eStateExited:
1725     return SendWResponse(m_debugged_process_sp.get());
1726 
1727   default:
1728     if (log) {
1729       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
1730                   ", current state reporting not handled: %s",
1731                   __FUNCTION__, m_debugged_process_sp->GetID(),
1732                   StateAsCString(process_state));
1733     }
1734     break;
1735   }
1736 
1737   return SendErrorResponse(0);
1738 }
1739 
1740 GDBRemoteCommunication::PacketResult
1741 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
1742     StringExtractorGDBRemote &packet) {
1743   // Fail if we don't have a current process.
1744   if (!m_debugged_process_sp ||
1745       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
1746     return SendErrorResponse(68);
1747 
1748   // Ensure we have a thread.
1749   NativeThreadProtocolSP thread_sp(m_debugged_process_sp->GetThreadAtIndex(0));
1750   if (!thread_sp)
1751     return SendErrorResponse(69);
1752 
1753   // Get the register context for the first thread.
1754   NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
1755   if (!reg_context_sp)
1756     return SendErrorResponse(69);
1757 
1758   // Parse out the register number from the request.
1759   packet.SetFilePos(strlen("qRegisterInfo"));
1760   const uint32_t reg_index =
1761       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
1762   if (reg_index == std::numeric_limits<uint32_t>::max())
1763     return SendErrorResponse(69);
1764 
1765   // Return the end of registers response if we've iterated one past the end of
1766   // the register set.
1767   if (reg_index >= reg_context_sp->GetUserRegisterCount())
1768     return SendErrorResponse(69);
1769 
1770   const RegisterInfo *reg_info =
1771       reg_context_sp->GetRegisterInfoAtIndex(reg_index);
1772   if (!reg_info)
1773     return SendErrorResponse(69);
1774 
1775   // Build the reginfos response.
1776   StreamGDBRemote response;
1777 
1778   response.PutCString("name:");
1779   response.PutCString(reg_info->name);
1780   response.PutChar(';');
1781 
1782   if (reg_info->alt_name && reg_info->alt_name[0]) {
1783     response.PutCString("alt-name:");
1784     response.PutCString(reg_info->alt_name);
1785     response.PutChar(';');
1786   }
1787 
1788   response.Printf("bitsize:%" PRIu32 ";offset:%" PRIu32 ";",
1789                   reg_info->byte_size * 8, reg_info->byte_offset);
1790 
1791   switch (reg_info->encoding) {
1792   case eEncodingUint:
1793     response.PutCString("encoding:uint;");
1794     break;
1795   case eEncodingSint:
1796     response.PutCString("encoding:sint;");
1797     break;
1798   case eEncodingIEEE754:
1799     response.PutCString("encoding:ieee754;");
1800     break;
1801   case eEncodingVector:
1802     response.PutCString("encoding:vector;");
1803     break;
1804   default:
1805     break;
1806   }
1807 
1808   switch (reg_info->format) {
1809   case eFormatBinary:
1810     response.PutCString("format:binary;");
1811     break;
1812   case eFormatDecimal:
1813     response.PutCString("format:decimal;");
1814     break;
1815   case eFormatHex:
1816     response.PutCString("format:hex;");
1817     break;
1818   case eFormatFloat:
1819     response.PutCString("format:float;");
1820     break;
1821   case eFormatVectorOfSInt8:
1822     response.PutCString("format:vector-sint8;");
1823     break;
1824   case eFormatVectorOfUInt8:
1825     response.PutCString("format:vector-uint8;");
1826     break;
1827   case eFormatVectorOfSInt16:
1828     response.PutCString("format:vector-sint16;");
1829     break;
1830   case eFormatVectorOfUInt16:
1831     response.PutCString("format:vector-uint16;");
1832     break;
1833   case eFormatVectorOfSInt32:
1834     response.PutCString("format:vector-sint32;");
1835     break;
1836   case eFormatVectorOfUInt32:
1837     response.PutCString("format:vector-uint32;");
1838     break;
1839   case eFormatVectorOfFloat32:
1840     response.PutCString("format:vector-float32;");
1841     break;
1842   case eFormatVectorOfUInt64:
1843     response.PutCString("format:vector-uint64;");
1844     break;
1845   case eFormatVectorOfUInt128:
1846     response.PutCString("format:vector-uint128;");
1847     break;
1848   default:
1849     break;
1850   };
1851 
1852   const char *const register_set_name =
1853       reg_context_sp->GetRegisterSetNameForRegisterAtIndex(reg_index);
1854   if (register_set_name) {
1855     response.PutCString("set:");
1856     response.PutCString(register_set_name);
1857     response.PutChar(';');
1858   }
1859 
1860   if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] !=
1861       LLDB_INVALID_REGNUM)
1862     response.Printf("ehframe:%" PRIu32 ";",
1863                     reg_info->kinds[RegisterKind::eRegisterKindEHFrame]);
1864 
1865   if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
1866     response.Printf("dwarf:%" PRIu32 ";",
1867                     reg_info->kinds[RegisterKind::eRegisterKindDWARF]);
1868 
1869   switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) {
1870   case LLDB_REGNUM_GENERIC_PC:
1871     response.PutCString("generic:pc;");
1872     break;
1873   case LLDB_REGNUM_GENERIC_SP:
1874     response.PutCString("generic:sp;");
1875     break;
1876   case LLDB_REGNUM_GENERIC_FP:
1877     response.PutCString("generic:fp;");
1878     break;
1879   case LLDB_REGNUM_GENERIC_RA:
1880     response.PutCString("generic:ra;");
1881     break;
1882   case LLDB_REGNUM_GENERIC_FLAGS:
1883     response.PutCString("generic:flags;");
1884     break;
1885   case LLDB_REGNUM_GENERIC_ARG1:
1886     response.PutCString("generic:arg1;");
1887     break;
1888   case LLDB_REGNUM_GENERIC_ARG2:
1889     response.PutCString("generic:arg2;");
1890     break;
1891   case LLDB_REGNUM_GENERIC_ARG3:
1892     response.PutCString("generic:arg3;");
1893     break;
1894   case LLDB_REGNUM_GENERIC_ARG4:
1895     response.PutCString("generic:arg4;");
1896     break;
1897   case LLDB_REGNUM_GENERIC_ARG5:
1898     response.PutCString("generic:arg5;");
1899     break;
1900   case LLDB_REGNUM_GENERIC_ARG6:
1901     response.PutCString("generic:arg6;");
1902     break;
1903   case LLDB_REGNUM_GENERIC_ARG7:
1904     response.PutCString("generic:arg7;");
1905     break;
1906   case LLDB_REGNUM_GENERIC_ARG8:
1907     response.PutCString("generic:arg8;");
1908     break;
1909   default:
1910     break;
1911   }
1912 
1913   if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) {
1914     response.PutCString("container-regs:");
1915     int i = 0;
1916     for (const uint32_t *reg_num = reg_info->value_regs;
1917          *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
1918       if (i > 0)
1919         response.PutChar(',');
1920       response.Printf("%" PRIx32, *reg_num);
1921     }
1922     response.PutChar(';');
1923   }
1924 
1925   if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) {
1926     response.PutCString("invalidate-regs:");
1927     int i = 0;
1928     for (const uint32_t *reg_num = reg_info->invalidate_regs;
1929          *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
1930       if (i > 0)
1931         response.PutChar(',');
1932       response.Printf("%" PRIx32, *reg_num);
1933     }
1934     response.PutChar(';');
1935   }
1936 
1937   if (reg_info->dynamic_size_dwarf_expr_bytes) {
1938     const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
1939     response.PutCString("dynamic_size_dwarf_expr_bytes:");
1940     for (uint32_t i = 0; i < dwarf_opcode_len; ++i)
1941       response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]);
1942     response.PutChar(';');
1943   }
1944   return SendPacketNoLock(response.GetString());
1945 }
1946 
1947 GDBRemoteCommunication::PacketResult
1948 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo(
1949     StringExtractorGDBRemote &packet) {
1950   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1951 
1952   // Fail if we don't have a current process.
1953   if (!m_debugged_process_sp ||
1954       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
1955     if (log)
1956       log->Printf("GDBRemoteCommunicationServerLLGS::%s() no process (%s), "
1957                   "returning OK",
1958                   __FUNCTION__,
1959                   m_debugged_process_sp ? "invalid process id"
1960                                         : "null m_debugged_process_sp");
1961     return SendOKResponse();
1962   }
1963 
1964   StreamGDBRemote response;
1965   response.PutChar('m');
1966 
1967   if (log)
1968     log->Printf(
1969         "GDBRemoteCommunicationServerLLGS::%s() starting thread iteration",
1970         __FUNCTION__);
1971 
1972   NativeThreadProtocolSP thread_sp;
1973   uint32_t thread_index;
1974   for (thread_index = 0,
1975       thread_sp = m_debugged_process_sp->GetThreadAtIndex(thread_index);
1976        thread_sp; ++thread_index,
1977       thread_sp = m_debugged_process_sp->GetThreadAtIndex(thread_index)) {
1978     if (log)
1979       log->Printf(
1980           "GDBRemoteCommunicationServerLLGS::%s() iterated thread %" PRIu32
1981           "(%s, tid=0x%" PRIx64 ")",
1982           __FUNCTION__, thread_index, thread_sp ? "is not null" : "null",
1983           thread_sp ? thread_sp->GetID() : LLDB_INVALID_THREAD_ID);
1984     if (thread_index > 0)
1985       response.PutChar(',');
1986     response.Printf("%" PRIx64, thread_sp->GetID());
1987   }
1988 
1989   if (log)
1990     log->Printf(
1991         "GDBRemoteCommunicationServerLLGS::%s() finished thread iteration",
1992         __FUNCTION__);
1993 
1994   return SendPacketNoLock(response.GetString());
1995 }
1996 
1997 GDBRemoteCommunication::PacketResult
1998 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
1999     StringExtractorGDBRemote &packet) {
2000   // FIXME for now we return the full thread list in the initial packet and
2001   // always do nothing here.
2002   return SendPacketNoLock("l");
2003 }
2004 
2005 GDBRemoteCommunication::PacketResult
2006 GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) {
2007   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2008 
2009   // Parse out the register number from the request.
2010   packet.SetFilePos(strlen("p"));
2011   const uint32_t reg_index =
2012       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
2013   if (reg_index == std::numeric_limits<uint32_t>::max()) {
2014     if (log)
2015       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
2016                   "parse register number from request \"%s\"",
2017                   __FUNCTION__, packet.GetStringRef().c_str());
2018     return SendErrorResponse(0x15);
2019   }
2020 
2021   // Get the thread to use.
2022   NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
2023   if (!thread_sp) {
2024     if (log)
2025       log->Printf(
2026           "GDBRemoteCommunicationServerLLGS::%s failed, no thread available",
2027           __FUNCTION__);
2028     return SendErrorResponse(0x15);
2029   }
2030 
2031   // Get the thread's register context.
2032   NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
2033   if (!reg_context_sp) {
2034     if (log)
2035       log->Printf(
2036           "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64
2037           " failed, no register context available for the thread",
2038           __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID());
2039     return SendErrorResponse(0x15);
2040   }
2041 
2042   // Return the end of registers response if we've iterated one past the end of
2043   // the register set.
2044   if (reg_index >= reg_context_sp->GetUserRegisterCount()) {
2045     if (log)
2046       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
2047                   "register %" PRIu32 " beyond register count %" PRIu32,
2048                   __FUNCTION__, reg_index,
2049                   reg_context_sp->GetUserRegisterCount());
2050     return SendErrorResponse(0x15);
2051   }
2052 
2053   const RegisterInfo *reg_info =
2054       reg_context_sp->GetRegisterInfoAtIndex(reg_index);
2055   if (!reg_info) {
2056     if (log)
2057       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
2058                   "register %" PRIu32 " returned NULL",
2059                   __FUNCTION__, reg_index);
2060     return SendErrorResponse(0x15);
2061   }
2062 
2063   // Build the reginfos response.
2064   StreamGDBRemote response;
2065 
2066   // Retrieve the value
2067   RegisterValue reg_value;
2068   Status error = reg_context_sp->ReadRegister(reg_info, reg_value);
2069   if (error.Fail()) {
2070     if (log)
2071       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, read of "
2072                   "requested register %" PRIu32 " (%s) failed: %s",
2073                   __FUNCTION__, reg_index, reg_info->name, error.AsCString());
2074     return SendErrorResponse(0x15);
2075   }
2076 
2077   const uint8_t *const data =
2078       reinterpret_cast<const uint8_t *>(reg_value.GetBytes());
2079   if (!data) {
2080     if (log)
2081       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get data "
2082                   "bytes from requested register %" PRIu32,
2083                   __FUNCTION__, reg_index);
2084     return SendErrorResponse(0x15);
2085   }
2086 
2087   // FIXME flip as needed to get data in big/little endian format for this host.
2088   for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i)
2089     response.PutHex8(data[i]);
2090 
2091   return SendPacketNoLock(response.GetString());
2092 }
2093 
2094 GDBRemoteCommunication::PacketResult
2095 GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) {
2096   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2097 
2098   // Ensure there is more content.
2099   if (packet.GetBytesLeft() < 1)
2100     return SendIllFormedResponse(packet, "Empty P packet");
2101 
2102   // Parse out the register number from the request.
2103   packet.SetFilePos(strlen("P"));
2104   const uint32_t reg_index =
2105       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
2106   if (reg_index == std::numeric_limits<uint32_t>::max()) {
2107     if (log)
2108       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
2109                   "parse register number from request \"%s\"",
2110                   __FUNCTION__, packet.GetStringRef().c_str());
2111     return SendErrorResponse(0x29);
2112   }
2113 
2114   // Note debugserver would send an E30 here.
2115   if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '='))
2116     return SendIllFormedResponse(
2117         packet, "P packet missing '=' char after register number");
2118 
2119   // Get process architecture.
2120   ArchSpec process_arch;
2121   if (!m_debugged_process_sp ||
2122       !m_debugged_process_sp->GetArchitecture(process_arch)) {
2123     if (log)
2124       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to retrieve "
2125                   "inferior architecture",
2126                   __FUNCTION__);
2127     return SendErrorResponse(0x49);
2128   }
2129 
2130   // Parse out the value.
2131   uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register
2132   size_t reg_size = packet.GetHexBytesAvail(reg_bytes);
2133 
2134   // Get the thread to use.
2135   NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
2136   if (!thread_sp) {
2137     if (log)
2138       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread "
2139                   "available (thread index 0)",
2140                   __FUNCTION__);
2141     return SendErrorResponse(0x28);
2142   }
2143 
2144   // Get the thread's register context.
2145   NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
2146   if (!reg_context_sp) {
2147     if (log)
2148       log->Printf(
2149           "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64
2150           " failed, no register context available for the thread",
2151           __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID());
2152     return SendErrorResponse(0x15);
2153   }
2154 
2155   const RegisterInfo *reg_info =
2156       reg_context_sp->GetRegisterInfoAtIndex(reg_index);
2157   if (!reg_info) {
2158     if (log)
2159       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
2160                   "register %" PRIu32 " returned NULL",
2161                   __FUNCTION__, reg_index);
2162     return SendErrorResponse(0x48);
2163   }
2164 
2165   // Return the end of registers response if we've iterated one past the end of
2166   // the register set.
2167   if (reg_index >= reg_context_sp->GetUserRegisterCount()) {
2168     if (log)
2169       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
2170                   "register %" PRIu32 " beyond register count %" PRIu32,
2171                   __FUNCTION__, reg_index,
2172                   reg_context_sp->GetUserRegisterCount());
2173     return SendErrorResponse(0x47);
2174   }
2175 
2176   // The dwarf expression are evaluate on host site
2177   // which may cause register size to change
2178   // Hence the reg_size may not be same as reg_info->bytes_size
2179   if ((reg_size != reg_info->byte_size) &&
2180       !(reg_info->dynamic_size_dwarf_expr_bytes)) {
2181     return SendIllFormedResponse(packet, "P packet register size is incorrect");
2182   }
2183 
2184   // Build the reginfos response.
2185   StreamGDBRemote response;
2186 
2187   RegisterValue reg_value(reg_bytes, reg_size, process_arch.GetByteOrder());
2188   Status error = reg_context_sp->WriteRegister(reg_info, reg_value);
2189   if (error.Fail()) {
2190     if (log)
2191       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, write of "
2192                   "requested register %" PRIu32 " (%s) failed: %s",
2193                   __FUNCTION__, reg_index, reg_info->name, error.AsCString());
2194     return SendErrorResponse(0x32);
2195   }
2196 
2197   return SendOKResponse();
2198 }
2199 
2200 GDBRemoteCommunication::PacketResult
2201 GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) {
2202   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2203 
2204   // Fail if we don't have a current process.
2205   if (!m_debugged_process_sp ||
2206       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2207     if (log)
2208       log->Printf(
2209           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2210           __FUNCTION__);
2211     return SendErrorResponse(0x15);
2212   }
2213 
2214   // Parse out which variant of $H is requested.
2215   packet.SetFilePos(strlen("H"));
2216   if (packet.GetBytesLeft() < 1) {
2217     if (log)
2218       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, H command "
2219                   "missing {g,c} variant",
2220                   __FUNCTION__);
2221     return SendIllFormedResponse(packet, "H command missing {g,c} variant");
2222   }
2223 
2224   const char h_variant = packet.GetChar();
2225   switch (h_variant) {
2226   case 'g':
2227     break;
2228 
2229   case 'c':
2230     break;
2231 
2232   default:
2233     if (log)
2234       log->Printf(
2235           "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c",
2236           __FUNCTION__, h_variant);
2237     return SendIllFormedResponse(packet,
2238                                  "H variant unsupported, should be c or g");
2239   }
2240 
2241   // Parse out the thread number.
2242   // FIXME return a parse success/fail value.  All values are valid here.
2243   const lldb::tid_t tid =
2244       packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max());
2245 
2246   // Ensure we have the given thread when not specifying -1 (all threads) or 0
2247   // (any thread).
2248   if (tid != LLDB_INVALID_THREAD_ID && tid != 0) {
2249     NativeThreadProtocolSP thread_sp(m_debugged_process_sp->GetThreadByID(tid));
2250     if (!thread_sp) {
2251       if (log)
2252         log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64
2253                     " not found",
2254                     __FUNCTION__, tid);
2255       return SendErrorResponse(0x15);
2256     }
2257   }
2258 
2259   // Now switch the given thread type.
2260   switch (h_variant) {
2261   case 'g':
2262     SetCurrentThreadID(tid);
2263     break;
2264 
2265   case 'c':
2266     SetContinueThreadID(tid);
2267     break;
2268 
2269   default:
2270     assert(false && "unsupported $H variant - shouldn't get here");
2271     return SendIllFormedResponse(packet,
2272                                  "H variant unsupported, should be c or g");
2273   }
2274 
2275   return SendOKResponse();
2276 }
2277 
2278 GDBRemoteCommunication::PacketResult
2279 GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) {
2280   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2281 
2282   // Fail if we don't have a current process.
2283   if (!m_debugged_process_sp ||
2284       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2285     if (log)
2286       log->Printf(
2287           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2288           __FUNCTION__);
2289     return SendErrorResponse(0x15);
2290   }
2291 
2292   packet.SetFilePos(::strlen("I"));
2293   uint8_t tmp[4096];
2294   for (;;) {
2295     size_t read = packet.GetHexBytesAvail(tmp);
2296     if (read == 0) {
2297       break;
2298     }
2299     // write directly to stdin *this might block if stdin buffer is full*
2300     // TODO: enqueue this block in circular buffer and send window size to
2301     // remote host
2302     ConnectionStatus status;
2303     Status error;
2304     m_stdio_communication.Write(tmp, read, status, &error);
2305     if (error.Fail()) {
2306       return SendErrorResponse(0x15);
2307     }
2308   }
2309 
2310   return SendOKResponse();
2311 }
2312 
2313 GDBRemoteCommunication::PacketResult
2314 GDBRemoteCommunicationServerLLGS::Handle_interrupt(
2315     StringExtractorGDBRemote &packet) {
2316   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
2317 
2318   // Fail if we don't have a current process.
2319   if (!m_debugged_process_sp ||
2320       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2321     if (log)
2322       log->Printf(
2323           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2324           __FUNCTION__);
2325     return SendErrorResponse(0x15);
2326   }
2327 
2328   // Interrupt the process.
2329   Status error = m_debugged_process_sp->Interrupt();
2330   if (error.Fail()) {
2331     if (log) {
2332       log->Printf(
2333           "GDBRemoteCommunicationServerLLGS::%s failed for process %" PRIu64
2334           ": %s",
2335           __FUNCTION__, m_debugged_process_sp->GetID(), error.AsCString());
2336     }
2337     return SendErrorResponse(GDBRemoteServerError::eErrorResume);
2338   }
2339 
2340   if (log)
2341     log->Printf("GDBRemoteCommunicationServerLLGS::%s stopped process %" PRIu64,
2342                 __FUNCTION__, m_debugged_process_sp->GetID());
2343 
2344   // No response required from stop all.
2345   return PacketResult::Success;
2346 }
2347 
2348 GDBRemoteCommunication::PacketResult
2349 GDBRemoteCommunicationServerLLGS::Handle_memory_read(
2350     StringExtractorGDBRemote &packet) {
2351   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2352 
2353   if (!m_debugged_process_sp ||
2354       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2355     if (log)
2356       log->Printf(
2357           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2358           __FUNCTION__);
2359     return SendErrorResponse(0x15);
2360   }
2361 
2362   // Parse out the memory address.
2363   packet.SetFilePos(strlen("m"));
2364   if (packet.GetBytesLeft() < 1)
2365     return SendIllFormedResponse(packet, "Too short m packet");
2366 
2367   // Read the address.  Punting on validation.
2368   // FIXME replace with Hex U64 read with no default value that fails on failed
2369   // read.
2370   const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
2371 
2372   // Validate comma.
2373   if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
2374     return SendIllFormedResponse(packet, "Comma sep missing in m packet");
2375 
2376   // Get # bytes to read.
2377   if (packet.GetBytesLeft() < 1)
2378     return SendIllFormedResponse(packet, "Length missing in m packet");
2379 
2380   const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
2381   if (byte_count == 0) {
2382     if (log)
2383       log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to read: "
2384                   "zero-length packet",
2385                   __FUNCTION__);
2386     return SendOKResponse();
2387   }
2388 
2389   // Allocate the response buffer.
2390   std::string buf(byte_count, '\0');
2391   if (buf.empty())
2392     return SendErrorResponse(0x78);
2393 
2394   // Retrieve the process memory.
2395   size_t bytes_read = 0;
2396   Status error = m_debugged_process_sp->ReadMemoryWithoutTrap(
2397       read_addr, &buf[0], byte_count, bytes_read);
2398   if (error.Fail()) {
2399     if (log)
2400       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2401                   " mem 0x%" PRIx64 ": failed to read. Error: %s",
2402                   __FUNCTION__, m_debugged_process_sp->GetID(), read_addr,
2403                   error.AsCString());
2404     return SendErrorResponse(0x08);
2405   }
2406 
2407   if (bytes_read == 0) {
2408     if (log)
2409       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2410                   " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes",
2411                   __FUNCTION__, m_debugged_process_sp->GetID(), read_addr,
2412                   byte_count);
2413     return SendErrorResponse(0x08);
2414   }
2415 
2416   StreamGDBRemote response;
2417   packet.SetFilePos(0);
2418   char kind = packet.GetChar('?');
2419   if (kind == 'x')
2420     response.PutEscapedBytes(buf.data(), byte_count);
2421   else {
2422     assert(kind == 'm');
2423     for (size_t i = 0; i < bytes_read; ++i)
2424       response.PutHex8(buf[i]);
2425   }
2426 
2427   return SendPacketNoLock(response.GetString());
2428 }
2429 
2430 GDBRemoteCommunication::PacketResult
2431 GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) {
2432   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2433 
2434   if (!m_debugged_process_sp ||
2435       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2436     if (log)
2437       log->Printf(
2438           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2439           __FUNCTION__);
2440     return SendErrorResponse(0x15);
2441   }
2442 
2443   // Parse out the memory address.
2444   packet.SetFilePos(strlen("M"));
2445   if (packet.GetBytesLeft() < 1)
2446     return SendIllFormedResponse(packet, "Too short M packet");
2447 
2448   // Read the address.  Punting on validation.
2449   // FIXME replace with Hex U64 read with no default value that fails on failed
2450   // read.
2451   const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0);
2452 
2453   // Validate comma.
2454   if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
2455     return SendIllFormedResponse(packet, "Comma sep missing in M packet");
2456 
2457   // Get # bytes to read.
2458   if (packet.GetBytesLeft() < 1)
2459     return SendIllFormedResponse(packet, "Length missing in M packet");
2460 
2461   const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
2462   if (byte_count == 0) {
2463     if (log)
2464       log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to write: "
2465                   "zero-length packet",
2466                   __FUNCTION__);
2467     return PacketResult::Success;
2468   }
2469 
2470   // Validate colon.
2471   if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':'))
2472     return SendIllFormedResponse(
2473         packet, "Comma sep missing in M packet after byte length");
2474 
2475   // Allocate the conversion buffer.
2476   std::vector<uint8_t> buf(byte_count, 0);
2477   if (buf.empty())
2478     return SendErrorResponse(0x78);
2479 
2480   // Convert the hex memory write contents to bytes.
2481   StreamGDBRemote response;
2482   const uint64_t convert_count = packet.GetHexBytes(buf, 0);
2483   if (convert_count != byte_count) {
2484     if (log)
2485       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2486                   " mem 0x%" PRIx64 ": asked to write %" PRIu64
2487                   " bytes, but only found %" PRIu64 " to convert.",
2488                   __FUNCTION__, m_debugged_process_sp->GetID(), write_addr,
2489                   byte_count, convert_count);
2490     return SendIllFormedResponse(packet, "M content byte length specified did "
2491                                          "not match hex-encoded content "
2492                                          "length");
2493   }
2494 
2495   // Write the process memory.
2496   size_t bytes_written = 0;
2497   Status error = m_debugged_process_sp->WriteMemory(write_addr, &buf[0],
2498                                                     byte_count, bytes_written);
2499   if (error.Fail()) {
2500     if (log)
2501       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2502                   " mem 0x%" PRIx64 ": failed to write. Error: %s",
2503                   __FUNCTION__, m_debugged_process_sp->GetID(), write_addr,
2504                   error.AsCString());
2505     return SendErrorResponse(0x09);
2506   }
2507 
2508   if (bytes_written == 0) {
2509     if (log)
2510       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2511                   " mem 0x%" PRIx64 ": wrote 0 of %" PRIu64 " requested bytes",
2512                   __FUNCTION__, m_debugged_process_sp->GetID(), write_addr,
2513                   byte_count);
2514     return SendErrorResponse(0x09);
2515   }
2516 
2517   return SendOKResponse();
2518 }
2519 
2520 GDBRemoteCommunication::PacketResult
2521 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported(
2522     StringExtractorGDBRemote &packet) {
2523   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2524 
2525   // Currently only the NativeProcessProtocol knows if it can handle a
2526   // qMemoryRegionInfoSupported
2527   // request, but we're not guaranteed to be attached to a process.  For now
2528   // we'll assume the
2529   // client only asks this when a process is being debugged.
2530 
2531   // Ensure we have a process running; otherwise, we can't figure this out
2532   // since we won't have a NativeProcessProtocol.
2533   if (!m_debugged_process_sp ||
2534       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2535     if (log)
2536       log->Printf(
2537           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2538           __FUNCTION__);
2539     return SendErrorResponse(0x15);
2540   }
2541 
2542   // Test if we can get any region back when asking for the region around NULL.
2543   MemoryRegionInfo region_info;
2544   const Status error =
2545       m_debugged_process_sp->GetMemoryRegionInfo(0, region_info);
2546   if (error.Fail()) {
2547     // We don't support memory region info collection for this
2548     // NativeProcessProtocol.
2549     return SendUnimplementedResponse("");
2550   }
2551 
2552   return SendOKResponse();
2553 }
2554 
2555 GDBRemoteCommunication::PacketResult
2556 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo(
2557     StringExtractorGDBRemote &packet) {
2558   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2559 
2560   // Ensure we have a process.
2561   if (!m_debugged_process_sp ||
2562       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2563     if (log)
2564       log->Printf(
2565           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2566           __FUNCTION__);
2567     return SendErrorResponse(0x15);
2568   }
2569 
2570   // Parse out the memory address.
2571   packet.SetFilePos(strlen("qMemoryRegionInfo:"));
2572   if (packet.GetBytesLeft() < 1)
2573     return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet");
2574 
2575   // Read the address.  Punting on validation.
2576   const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
2577 
2578   StreamGDBRemote response;
2579 
2580   // Get the memory region info for the target address.
2581   MemoryRegionInfo region_info;
2582   const Status error =
2583       m_debugged_process_sp->GetMemoryRegionInfo(read_addr, region_info);
2584   if (error.Fail()) {
2585     // Return the error message.
2586 
2587     response.PutCString("error:");
2588     response.PutCStringAsRawHex8(error.AsCString());
2589     response.PutChar(';');
2590   } else {
2591     // Range start and size.
2592     response.Printf("start:%" PRIx64 ";size:%" PRIx64 ";",
2593                     region_info.GetRange().GetRangeBase(),
2594                     region_info.GetRange().GetByteSize());
2595 
2596     // Permissions.
2597     if (region_info.GetReadable() || region_info.GetWritable() ||
2598         region_info.GetExecutable()) {
2599       // Write permissions info.
2600       response.PutCString("permissions:");
2601 
2602       if (region_info.GetReadable())
2603         response.PutChar('r');
2604       if (region_info.GetWritable())
2605         response.PutChar('w');
2606       if (region_info.GetExecutable())
2607         response.PutChar('x');
2608 
2609       response.PutChar(';');
2610     }
2611 
2612     // Name
2613     ConstString name = region_info.GetName();
2614     if (name) {
2615       response.PutCString("name:");
2616       response.PutCStringAsRawHex8(name.AsCString());
2617       response.PutChar(';');
2618     }
2619   }
2620 
2621   return SendPacketNoLock(response.GetString());
2622 }
2623 
2624 GDBRemoteCommunication::PacketResult
2625 GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) {
2626   // Ensure we have a process.
2627   if (!m_debugged_process_sp ||
2628       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2629     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2630     if (log)
2631       log->Printf(
2632           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2633           __FUNCTION__);
2634     return SendErrorResponse(0x15);
2635   }
2636 
2637   // Parse out software or hardware breakpoint or watchpoint requested.
2638   packet.SetFilePos(strlen("Z"));
2639   if (packet.GetBytesLeft() < 1)
2640     return SendIllFormedResponse(
2641         packet, "Too short Z packet, missing software/hardware specifier");
2642 
2643   bool want_breakpoint = true;
2644   bool want_hardware = false;
2645   uint32_t watch_flags = 0;
2646 
2647   const GDBStoppointType stoppoint_type =
2648       GDBStoppointType(packet.GetS32(eStoppointInvalid));
2649   switch (stoppoint_type) {
2650   case eBreakpointSoftware:
2651     want_hardware = false;
2652     want_breakpoint = true;
2653     break;
2654   case eBreakpointHardware:
2655     want_hardware = true;
2656     want_breakpoint = true;
2657     break;
2658   case eWatchpointWrite:
2659     watch_flags = 1;
2660     want_hardware = true;
2661     want_breakpoint = false;
2662     break;
2663   case eWatchpointRead:
2664     watch_flags = 2;
2665     want_hardware = true;
2666     want_breakpoint = false;
2667     break;
2668   case eWatchpointReadWrite:
2669     watch_flags = 3;
2670     want_hardware = true;
2671     want_breakpoint = false;
2672     break;
2673   case eStoppointInvalid:
2674     return SendIllFormedResponse(
2675         packet, "Z packet had invalid software/hardware specifier");
2676   }
2677 
2678   if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
2679     return SendIllFormedResponse(
2680         packet, "Malformed Z packet, expecting comma after stoppoint type");
2681 
2682   // Parse out the stoppoint address.
2683   if (packet.GetBytesLeft() < 1)
2684     return SendIllFormedResponse(packet, "Too short Z packet, missing address");
2685   const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);
2686 
2687   if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
2688     return SendIllFormedResponse(
2689         packet, "Malformed Z packet, expecting comma after address");
2690 
2691   // Parse out the stoppoint size (i.e. size hint for opcode size).
2692   const uint32_t size =
2693       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
2694   if (size == std::numeric_limits<uint32_t>::max())
2695     return SendIllFormedResponse(
2696         packet, "Malformed Z packet, failed to parse size argument");
2697 
2698   if (want_breakpoint) {
2699     // Try to set the breakpoint.
2700     const Status error =
2701         m_debugged_process_sp->SetBreakpoint(addr, size, want_hardware);
2702     if (error.Success())
2703       return SendOKResponse();
2704     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
2705     if (log)
2706       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2707                   " failed to set breakpoint: %s",
2708                   __FUNCTION__, m_debugged_process_sp->GetID(),
2709                   error.AsCString());
2710     return SendErrorResponse(0x09);
2711   } else {
2712     // Try to set the watchpoint.
2713     const Status error = m_debugged_process_sp->SetWatchpoint(
2714         addr, size, watch_flags, want_hardware);
2715     if (error.Success())
2716       return SendOKResponse();
2717     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
2718     if (log)
2719       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2720                   " failed to set watchpoint: %s",
2721                   __FUNCTION__, m_debugged_process_sp->GetID(),
2722                   error.AsCString());
2723     return SendErrorResponse(0x09);
2724   }
2725 }
2726 
2727 GDBRemoteCommunication::PacketResult
2728 GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
2729   // Ensure we have a process.
2730   if (!m_debugged_process_sp ||
2731       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2732     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2733     if (log)
2734       log->Printf(
2735           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2736           __FUNCTION__);
2737     return SendErrorResponse(0x15);
2738   }
2739 
2740   // Parse out software or hardware breakpoint or watchpoint requested.
2741   packet.SetFilePos(strlen("z"));
2742   if (packet.GetBytesLeft() < 1)
2743     return SendIllFormedResponse(
2744         packet, "Too short z packet, missing software/hardware specifier");
2745 
2746   bool want_breakpoint = true;
2747   bool want_hardware = false;
2748 
2749   const GDBStoppointType stoppoint_type =
2750       GDBStoppointType(packet.GetS32(eStoppointInvalid));
2751   switch (stoppoint_type) {
2752   case eBreakpointHardware:
2753     want_breakpoint = true;
2754     want_hardware = true;
2755     break;
2756   case eBreakpointSoftware:
2757     want_breakpoint = true;
2758     break;
2759   case eWatchpointWrite:
2760     want_breakpoint = false;
2761     break;
2762   case eWatchpointRead:
2763     want_breakpoint = false;
2764     break;
2765   case eWatchpointReadWrite:
2766     want_breakpoint = false;
2767     break;
2768   default:
2769     return SendIllFormedResponse(
2770         packet, "z packet had invalid software/hardware specifier");
2771   }
2772 
2773   if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
2774     return SendIllFormedResponse(
2775         packet, "Malformed z packet, expecting comma after stoppoint type");
2776 
2777   // Parse out the stoppoint address.
2778   if (packet.GetBytesLeft() < 1)
2779     return SendIllFormedResponse(packet, "Too short z packet, missing address");
2780   const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);
2781 
2782   if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
2783     return SendIllFormedResponse(
2784         packet, "Malformed z packet, expecting comma after address");
2785 
2786   /*
2787   // Parse out the stoppoint size (i.e. size hint for opcode size).
2788   const uint32_t size = packet.GetHexMaxU32 (false,
2789   std::numeric_limits<uint32_t>::max ());
2790   if (size == std::numeric_limits<uint32_t>::max ())
2791       return SendIllFormedResponse(packet, "Malformed z packet, failed to parse
2792   size argument");
2793   */
2794 
2795   if (want_breakpoint) {
2796     // Try to clear the breakpoint.
2797     const Status error =
2798         m_debugged_process_sp->RemoveBreakpoint(addr, want_hardware);
2799     if (error.Success())
2800       return SendOKResponse();
2801     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
2802     if (log)
2803       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2804                   " failed to remove breakpoint: %s",
2805                   __FUNCTION__, m_debugged_process_sp->GetID(),
2806                   error.AsCString());
2807     return SendErrorResponse(0x09);
2808   } else {
2809     // Try to clear the watchpoint.
2810     const Status error = m_debugged_process_sp->RemoveWatchpoint(addr);
2811     if (error.Success())
2812       return SendOKResponse();
2813     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
2814     if (log)
2815       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2816                   " failed to remove watchpoint: %s",
2817                   __FUNCTION__, m_debugged_process_sp->GetID(),
2818                   error.AsCString());
2819     return SendErrorResponse(0x09);
2820   }
2821 }
2822 
2823 GDBRemoteCommunication::PacketResult
2824 GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) {
2825   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
2826 
2827   // Ensure we have a process.
2828   if (!m_debugged_process_sp ||
2829       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2830     if (log)
2831       log->Printf(
2832           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2833           __FUNCTION__);
2834     return SendErrorResponse(0x32);
2835   }
2836 
2837   // We first try to use a continue thread id.  If any one or any all set, use
2838   // the current thread.
2839   // Bail out if we don't have a thread id.
2840   lldb::tid_t tid = GetContinueThreadID();
2841   if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
2842     tid = GetCurrentThreadID();
2843   if (tid == LLDB_INVALID_THREAD_ID)
2844     return SendErrorResponse(0x33);
2845 
2846   // Double check that we have such a thread.
2847   // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
2848   NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetThreadByID(tid);
2849   if (!thread_sp || thread_sp->GetID() != tid)
2850     return SendErrorResponse(0x33);
2851 
2852   // Create the step action for the given thread.
2853   ResumeAction action = {tid, eStateStepping, 0};
2854 
2855   // Setup the actions list.
2856   ResumeActionList actions;
2857   actions.Append(action);
2858 
2859   // All other threads stop while we're single stepping a thread.
2860   actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
2861   Status error = m_debugged_process_sp->Resume(actions);
2862   if (error.Fail()) {
2863     if (log)
2864       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2865                   " tid %" PRIu64 " Resume() failed with error: %s",
2866                   __FUNCTION__, m_debugged_process_sp->GetID(), tid,
2867                   error.AsCString());
2868     return SendErrorResponse(0x49);
2869   }
2870 
2871   // No response here - the stop or exit will come from the resulting action.
2872   return PacketResult::Success;
2873 }
2874 
2875 GDBRemoteCommunication::PacketResult
2876 GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read(
2877     StringExtractorGDBRemote &packet) {
2878 // *BSD impls should be able to do this too.
2879 #if defined(__linux__) || defined(__NetBSD__)
2880   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2881 
2882   // Parse out the offset.
2883   packet.SetFilePos(strlen("qXfer:auxv:read::"));
2884   if (packet.GetBytesLeft() < 1)
2885     return SendIllFormedResponse(packet,
2886                                  "qXfer:auxv:read:: packet missing offset");
2887 
2888   const uint64_t auxv_offset =
2889       packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
2890   if (auxv_offset == std::numeric_limits<uint64_t>::max())
2891     return SendIllFormedResponse(packet,
2892                                  "qXfer:auxv:read:: packet missing offset");
2893 
2894   // Parse out comma.
2895   if (packet.GetBytesLeft() < 1 || packet.GetChar() != ',')
2896     return SendIllFormedResponse(
2897         packet, "qXfer:auxv:read:: packet missing comma after offset");
2898 
2899   // Parse out the length.
2900   const uint64_t auxv_length =
2901       packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
2902   if (auxv_length == std::numeric_limits<uint64_t>::max())
2903     return SendIllFormedResponse(packet,
2904                                  "qXfer:auxv:read:: packet missing length");
2905 
2906   // Grab the auxv data if we need it.
2907   if (!m_active_auxv_buffer_up) {
2908     // Make sure we have a valid process.
2909     if (!m_debugged_process_sp ||
2910         (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
2911       if (log)
2912         log->Printf(
2913             "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
2914             __FUNCTION__);
2915       return SendErrorResponse(0x10);
2916     }
2917 
2918     // Grab the auxv data.
2919     auto buffer_or_error = m_debugged_process_sp->GetAuxvData();
2920     if (!buffer_or_error) {
2921       std::error_code ec = buffer_or_error.getError();
2922       LLDB_LOG(log, "no auxv data retrieved: {0}", ec.message());
2923       return SendErrorResponse(ec.value());
2924     }
2925     m_active_auxv_buffer_up = std::move(*buffer_or_error);
2926   }
2927 
2928   StreamGDBRemote response;
2929   bool done_with_buffer = false;
2930 
2931   llvm::StringRef buffer = m_active_auxv_buffer_up->getBuffer();
2932   if (auxv_offset >= buffer.size()) {
2933     // We have nothing left to send.  Mark the buffer as complete.
2934     response.PutChar('l');
2935     done_with_buffer = true;
2936   } else {
2937     // Figure out how many bytes are available starting at the given offset.
2938     buffer = buffer.drop_front(auxv_offset);
2939 
2940     // Mark the response type according to whether we're reading the remainder
2941     // of the auxv data.
2942     if (auxv_length >= buffer.size()) {
2943       // There will be nothing left to read after this
2944       response.PutChar('l');
2945       done_with_buffer = true;
2946     } else {
2947       // There will still be bytes to read after this request.
2948       response.PutChar('m');
2949       buffer = buffer.take_front(auxv_length);
2950     }
2951 
2952     // Now write the data in encoded binary form.
2953     response.PutEscapedBytes(buffer.data(), buffer.size());
2954   }
2955 
2956   if (done_with_buffer)
2957     m_active_auxv_buffer_up.reset();
2958 
2959   return SendPacketNoLock(response.GetString());
2960 #else
2961   return SendUnimplementedResponse("not implemented on this platform");
2962 #endif
2963 }
2964 
2965 GDBRemoteCommunication::PacketResult
2966 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState(
2967     StringExtractorGDBRemote &packet) {
2968   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2969 
2970   // Move past packet name.
2971   packet.SetFilePos(strlen("QSaveRegisterState"));
2972 
2973   // Get the thread to use.
2974   NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
2975   if (!thread_sp) {
2976     if (m_thread_suffix_supported)
2977       return SendIllFormedResponse(
2978           packet, "No thread specified in QSaveRegisterState packet");
2979     else
2980       return SendIllFormedResponse(packet,
2981                                    "No thread was is set with the Hg packet");
2982   }
2983 
2984   // Grab the register context for the thread.
2985   NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
2986   if (!reg_context_sp) {
2987     if (log)
2988       log->Printf(
2989           "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64
2990           " failed, no register context available for the thread",
2991           __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID());
2992     return SendErrorResponse(0x15);
2993   }
2994 
2995   // Save registers to a buffer.
2996   DataBufferSP register_data_sp;
2997   Status error = reg_context_sp->ReadAllRegisterValues(register_data_sp);
2998   if (error.Fail()) {
2999     if (log)
3000       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
3001                   " failed to save all register values: %s",
3002                   __FUNCTION__, m_debugged_process_sp->GetID(),
3003                   error.AsCString());
3004     return SendErrorResponse(0x75);
3005   }
3006 
3007   // Allocate a new save id.
3008   const uint32_t save_id = GetNextSavedRegistersID();
3009   assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) &&
3010          "GetNextRegisterSaveID() returned an existing register save id");
3011 
3012   // Save the register data buffer under the save id.
3013   {
3014     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
3015     m_saved_registers_map[save_id] = register_data_sp;
3016   }
3017 
3018   // Write the response.
3019   StreamGDBRemote response;
3020   response.Printf("%" PRIu32, save_id);
3021   return SendPacketNoLock(response.GetString());
3022 }
3023 
3024 GDBRemoteCommunication::PacketResult
3025 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState(
3026     StringExtractorGDBRemote &packet) {
3027   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
3028 
3029   // Parse out save id.
3030   packet.SetFilePos(strlen("QRestoreRegisterState:"));
3031   if (packet.GetBytesLeft() < 1)
3032     return SendIllFormedResponse(
3033         packet, "QRestoreRegisterState packet missing register save id");
3034 
3035   const uint32_t save_id = packet.GetU32(0);
3036   if (save_id == 0) {
3037     if (log)
3038       log->Printf("GDBRemoteCommunicationServerLLGS::%s QRestoreRegisterState "
3039                   "packet has malformed save id, expecting decimal uint32_t",
3040                   __FUNCTION__);
3041     return SendErrorResponse(0x76);
3042   }
3043 
3044   // Get the thread to use.
3045   NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
3046   if (!thread_sp) {
3047     if (m_thread_suffix_supported)
3048       return SendIllFormedResponse(
3049           packet, "No thread specified in QRestoreRegisterState packet");
3050     else
3051       return SendIllFormedResponse(packet,
3052                                    "No thread was is set with the Hg packet");
3053   }
3054 
3055   // Grab the register context for the thread.
3056   NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
3057   if (!reg_context_sp) {
3058     if (log)
3059       log->Printf(
3060           "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64
3061           " failed, no register context available for the thread",
3062           __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID());
3063     return SendErrorResponse(0x15);
3064   }
3065 
3066   // Retrieve register state buffer, then remove from the list.
3067   DataBufferSP register_data_sp;
3068   {
3069     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
3070 
3071     // Find the register set buffer for the given save id.
3072     auto it = m_saved_registers_map.find(save_id);
3073     if (it == m_saved_registers_map.end()) {
3074       if (log)
3075         log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
3076                     " does not have a register set save buffer for id %" PRIu32,
3077                     __FUNCTION__, m_debugged_process_sp->GetID(), save_id);
3078       return SendErrorResponse(0x77);
3079     }
3080     register_data_sp = it->second;
3081 
3082     // Remove it from the map.
3083     m_saved_registers_map.erase(it);
3084   }
3085 
3086   Status error = reg_context_sp->WriteAllRegisterValues(register_data_sp);
3087   if (error.Fail()) {
3088     if (log)
3089       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
3090                   " failed to restore all register values: %s",
3091                   __FUNCTION__, m_debugged_process_sp->GetID(),
3092                   error.AsCString());
3093     return SendErrorResponse(0x77);
3094   }
3095 
3096   return SendOKResponse();
3097 }
3098 
3099 GDBRemoteCommunication::PacketResult
3100 GDBRemoteCommunicationServerLLGS::Handle_vAttach(
3101     StringExtractorGDBRemote &packet) {
3102   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
3103 
3104   // Consume the ';' after vAttach.
3105   packet.SetFilePos(strlen("vAttach"));
3106   if (!packet.GetBytesLeft() || packet.GetChar() != ';')
3107     return SendIllFormedResponse(packet, "vAttach missing expected ';'");
3108 
3109   // Grab the PID to which we will attach (assume hex encoding).
3110   lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16);
3111   if (pid == LLDB_INVALID_PROCESS_ID)
3112     return SendIllFormedResponse(packet,
3113                                  "vAttach failed to parse the process id");
3114 
3115   // Attempt to attach.
3116   if (log)
3117     log->Printf("GDBRemoteCommunicationServerLLGS::%s attempting to attach to "
3118                 "pid %" PRIu64,
3119                 __FUNCTION__, pid);
3120 
3121   Status error = AttachToProcess(pid);
3122 
3123   if (error.Fail()) {
3124     if (log)
3125       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to attach to "
3126                   "pid %" PRIu64 ": %s\n",
3127                   __FUNCTION__, pid, error.AsCString());
3128     return SendErrorResponse(0x01);
3129   }
3130 
3131   // Notify we attached by sending a stop packet.
3132   return SendStopReasonForState(m_debugged_process_sp->GetState());
3133 }
3134 
3135 GDBRemoteCommunication::PacketResult
3136 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) {
3137   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
3138 
3139   StopSTDIOForwarding();
3140 
3141   // Fail if we don't have a current process.
3142   if (!m_debugged_process_sp ||
3143       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) {
3144     if (log)
3145       log->Printf(
3146           "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
3147           __FUNCTION__);
3148     return SendErrorResponse(0x15);
3149   }
3150 
3151   lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
3152 
3153   // Consume the ';' after D.
3154   packet.SetFilePos(1);
3155   if (packet.GetBytesLeft()) {
3156     if (packet.GetChar() != ';')
3157       return SendIllFormedResponse(packet, "D missing expected ';'");
3158 
3159     // Grab the PID from which we will detach (assume hex encoding).
3160     pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16);
3161     if (pid == LLDB_INVALID_PROCESS_ID)
3162       return SendIllFormedResponse(packet, "D failed to parse the process id");
3163   }
3164 
3165   if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_sp->GetID() != pid) {
3166     return SendIllFormedResponse(packet, "Invalid pid");
3167   }
3168 
3169   const Status error = m_debugged_process_sp->Detach();
3170   if (error.Fail()) {
3171     if (log)
3172       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to detach from "
3173                   "pid %" PRIu64 ": %s\n",
3174                   __FUNCTION__, m_debugged_process_sp->GetID(),
3175                   error.AsCString());
3176     return SendErrorResponse(0x01);
3177   }
3178 
3179   return SendOKResponse();
3180 }
3181 
3182 GDBRemoteCommunication::PacketResult
3183 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo(
3184     StringExtractorGDBRemote &packet) {
3185   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
3186 
3187   packet.SetFilePos(strlen("qThreadStopInfo"));
3188   const lldb::tid_t tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID);
3189   if (tid == LLDB_INVALID_THREAD_ID) {
3190     if (log)
3191       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
3192                   "parse thread id from request \"%s\"",
3193                   __FUNCTION__, packet.GetStringRef().c_str());
3194     return SendErrorResponse(0x15);
3195   }
3196   return SendStopReplyPacketForThread(tid);
3197 }
3198 
3199 GDBRemoteCommunication::PacketResult
3200 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo(
3201     StringExtractorGDBRemote &) {
3202   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
3203 
3204   // Ensure we have a debugged process.
3205   if (!m_debugged_process_sp ||
3206       (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID))
3207     return SendErrorResponse(50);
3208 
3209   if (log)
3210     log->Printf("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid "
3211                 "%" PRIu64,
3212                 __FUNCTION__, m_debugged_process_sp->GetID());
3213 
3214   StreamString response;
3215   const bool threads_with_valid_stop_info_only = false;
3216   JSONArray::SP threads_array_sp = GetJSONThreadsInfo(
3217       *m_debugged_process_sp, threads_with_valid_stop_info_only);
3218   if (!threads_array_sp) {
3219     if (log)
3220       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to prepare a "
3221                   "packet for pid %" PRIu64,
3222                   __FUNCTION__, m_debugged_process_sp->GetID());
3223     return SendErrorResponse(52);
3224   }
3225 
3226   threads_array_sp->Write(response);
3227   StreamGDBRemote escaped_response;
3228   escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
3229   return SendPacketNoLock(escaped_response.GetString());
3230 }
3231 
3232 GDBRemoteCommunication::PacketResult
3233 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo(
3234     StringExtractorGDBRemote &packet) {
3235   // Fail if we don't have a current process.
3236   if (!m_debugged_process_sp ||
3237       m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)
3238     return SendErrorResponse(68);
3239 
3240   packet.SetFilePos(strlen("qWatchpointSupportInfo"));
3241   if (packet.GetBytesLeft() == 0)
3242     return SendOKResponse();
3243   if (packet.GetChar() != ':')
3244     return SendErrorResponse(67);
3245 
3246   auto hw_debug_cap = m_debugged_process_sp->GetHardwareDebugSupportInfo();
3247 
3248   StreamGDBRemote response;
3249   if (hw_debug_cap == llvm::None)
3250     response.Printf("num:0;");
3251   else
3252     response.Printf("num:%d;", hw_debug_cap->second);
3253 
3254   return SendPacketNoLock(response.GetString());
3255 }
3256 
3257 GDBRemoteCommunication::PacketResult
3258 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress(
3259     StringExtractorGDBRemote &packet) {
3260   // Fail if we don't have a current process.
3261   if (!m_debugged_process_sp ||
3262       m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)
3263     return SendErrorResponse(67);
3264 
3265   packet.SetFilePos(strlen("qFileLoadAddress:"));
3266   if (packet.GetBytesLeft() == 0)
3267     return SendErrorResponse(68);
3268 
3269   std::string file_name;
3270   packet.GetHexByteString(file_name);
3271 
3272   lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS;
3273   Status error =
3274       m_debugged_process_sp->GetFileLoadAddress(file_name, file_load_address);
3275   if (error.Fail())
3276     return SendErrorResponse(69);
3277 
3278   if (file_load_address == LLDB_INVALID_ADDRESS)
3279     return SendErrorResponse(1); // File not loaded
3280 
3281   StreamGDBRemote response;
3282   response.PutHex64(file_load_address);
3283   return SendPacketNoLock(response.GetString());
3284 }
3285 
3286 GDBRemoteCommunication::PacketResult
3287 GDBRemoteCommunicationServerLLGS::Handle_QPassSignals(
3288     StringExtractorGDBRemote &packet) {
3289   std::vector<int> signals;
3290   packet.SetFilePos(strlen("QPassSignals:"));
3291 
3292   // Read sequence of hex signal numbers divided by a semicolon and
3293   // optionally spaces.
3294   while (packet.GetBytesLeft() > 0) {
3295     int signal = packet.GetS32(-1, 16);
3296     if (signal < 0)
3297       return SendIllFormedResponse(packet, "Failed to parse signal number.");
3298     signals.push_back(signal);
3299 
3300     packet.SkipSpaces();
3301     char separator = packet.GetChar();
3302     if (separator == '\0')
3303       break; // End of string
3304     if (separator != ';')
3305       return SendIllFormedResponse(packet, "Invalid separator,"
3306                                             " expected semicolon.");
3307   }
3308 
3309   // Fail if we don't have a current process.
3310   if (!m_debugged_process_sp)
3311     return SendErrorResponse(68);
3312 
3313   Status error = m_debugged_process_sp->IgnoreSignals(signals);
3314   if (error.Fail())
3315     return SendErrorResponse(69);
3316 
3317   return SendOKResponse();
3318 }
3319 
3320 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() {
3321   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
3322 
3323   // Tell the stdio connection to shut down.
3324   if (m_stdio_communication.IsConnected()) {
3325     auto connection = m_stdio_communication.GetConnection();
3326     if (connection) {
3327       Status error;
3328       connection->Disconnect(&error);
3329 
3330       if (error.Success()) {
3331         if (log)
3332           log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
3333                       "terminal stdio - SUCCESS",
3334                       __FUNCTION__);
3335       } else {
3336         if (log)
3337           log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
3338                       "terminal stdio - FAIL: %s",
3339                       __FUNCTION__, error.AsCString());
3340       }
3341     }
3342   }
3343 }
3344 
3345 NativeThreadProtocolSP GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix(
3346     StringExtractorGDBRemote &packet) {
3347   NativeThreadProtocolSP thread_sp;
3348 
3349   // We have no thread if we don't have a process.
3350   if (!m_debugged_process_sp ||
3351       m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)
3352     return thread_sp;
3353 
3354   // If the client hasn't asked for thread suffix support, there will not be a
3355   // thread suffix.
3356   // Use the current thread in that case.
3357   if (!m_thread_suffix_supported) {
3358     const lldb::tid_t current_tid = GetCurrentThreadID();
3359     if (current_tid == LLDB_INVALID_THREAD_ID)
3360       return thread_sp;
3361     else if (current_tid == 0) {
3362       // Pick a thread.
3363       return m_debugged_process_sp->GetThreadAtIndex(0);
3364     } else
3365       return m_debugged_process_sp->GetThreadByID(current_tid);
3366   }
3367 
3368   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
3369 
3370   // Parse out the ';'.
3371   if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') {
3372     if (log)
3373       log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
3374                   "error: expected ';' prior to start of thread suffix: packet "
3375                   "contents = '%s'",
3376                   __FUNCTION__, packet.GetStringRef().c_str());
3377     return thread_sp;
3378   }
3379 
3380   if (!packet.GetBytesLeft())
3381     return thread_sp;
3382 
3383   // Parse out thread: portion.
3384   if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) {
3385     if (log)
3386       log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
3387                   "error: expected 'thread:' but not found, packet contents = "
3388                   "'%s'",
3389                   __FUNCTION__, packet.GetStringRef().c_str());
3390     return thread_sp;
3391   }
3392   packet.SetFilePos(packet.GetFilePos() + strlen("thread:"));
3393   const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
3394   if (tid != 0)
3395     return m_debugged_process_sp->GetThreadByID(tid);
3396 
3397   return thread_sp;
3398 }
3399 
3400 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const {
3401   if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) {
3402     // Use whatever the debug process says is the current thread id
3403     // since the protocol either didn't specify or specified we want
3404     // any/all threads marked as the current thread.
3405     if (!m_debugged_process_sp)
3406       return LLDB_INVALID_THREAD_ID;
3407     return m_debugged_process_sp->GetCurrentThreadID();
3408   }
3409   // Use the specific current thread id set by the gdb remote protocol.
3410   return m_current_tid;
3411 }
3412 
3413 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() {
3414   std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
3415   return m_next_saved_registers_id++;
3416 }
3417 
3418 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() {
3419   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
3420 
3421   LLDB_LOG(log, "clearing auxv buffer: {0}", m_active_auxv_buffer_up.get());
3422   m_active_auxv_buffer_up.reset();
3423 }
3424 
3425 FileSpec
3426 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path,
3427                                                  const ArchSpec &arch) {
3428   if (m_debugged_process_sp) {
3429     FileSpec file_spec;
3430     if (m_debugged_process_sp
3431             ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec)
3432             .Success()) {
3433       if (file_spec.Exists())
3434         return file_spec;
3435     }
3436   }
3437 
3438   return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
3439 }
3440