contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

   1 //===-- GDBRemoteCommunicationClient.h --------------------------*- 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 #ifndef liblldb_GDBRemoteCommunicationClient_h_
  11 #define liblldb_GDBRemoteCommunicationClient_h_
  12
  13 #include "GDBRemoteClientBase.h"
  14
  15 // C Includes
  16 // C++ Includes
  17 #include <chrono>
  18 #include <map>
  19 #include <mutex>
  20 #include <string>
  21 #include <vector>
  22
  23 #include "lldb/Target/Process.h"
  24 #include "lldb/Utility/ArchSpec.h"
  25 #include "lldb/Utility/StreamGDBRemote.h"
  26 #include "lldb/Utility/StructuredData.h"
  27
  28 #include "llvm/ADT/Optional.h"
  29
  30 namespace lldb_private {
  31 namespace process_gdb_remote {
  32
  33 class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
  34 public:
  35   GDBRemoteCommunicationClient();
  36
  37   ~GDBRemoteCommunicationClient() override;
  38
  39   //------------------------------------------------------------------
  40   // After connecting, send the handshake to the server to make sure
  41   // we are communicating with it.
  42   //------------------------------------------------------------------
  43   bool HandshakeWithServer(Status *error_ptr);
  44
  45   // For packets which specify a range of output to be returned,
  46   // return all of the output via a series of request packets of the form
  47   // <prefix>0,<size>
  48   // <prefix><size>,<size>
  49   // <prefix><size>*2,<size>
  50   // <prefix><size>*3,<size>
  51   // ...
  52   // until a "$l..." packet is received, indicating the end.
  53   // (size is in hex; this format is used by a standard gdbserver to
  54   // return the given portion of the output specified by <prefix>;
  55   // for example, "qXfer:libraries-svr4:read::fff,1000" means
  56   // "return a chunk of the xml description file for shared
  57   // library load addresses, where the chunk starts at offset 0xfff
  58   // and continues for 0x1000 bytes").
  59   // Concatenate the resulting server response packets together and
  60   // return in response_string.  If any packet fails, the return value
  61   // indicates that failure and the returned string value is undefined.
  62   PacketResult
  63   SendPacketsAndConcatenateResponses(const char *send_payload_prefix,
  64                                      std::string &response_string);
  65
  66   bool GetThreadSuffixSupported();
  67
  68   // This packet is usually sent first and the boolean return value
  69   // indicates if the packet was send and any response was received
  70   // even in the response is UNIMPLEMENTED. If the packet failed to
  71   // get a response, then false is returned. This quickly tells us
  72   // if we were able to connect and communicate with the remote GDB
  73   // server
  74   bool QueryNoAckModeSupported();
  75
  76   void GetListThreadsInStopReplySupported();
  77
  78   lldb::pid_t GetCurrentProcessID(bool allow_lazy = true);
  79
  80   bool GetLaunchSuccess(std::string &error_str);
  81
  82   bool LaunchGDBServer(const char *remote_accept_hostname, lldb::pid_t &pid,
  83                        uint16_t &port, std::string &socket_name);
  84
  85   size_t QueryGDBServer(
  86       std::vector<std::pair<uint16_t, std::string>> &connection_urls);
  87
  88   bool KillSpawnedProcess(lldb::pid_t pid);
  89
  90   //------------------------------------------------------------------
  91   /// Sends a GDB remote protocol 'A' packet that delivers program
  92   /// arguments to the remote server.
  93   ///
  94   /// @param[in] argv
  95   ///     A NULL terminated array of const C strings to use as the
  96   ///     arguments.
  97   ///
  98   /// @return
  99   ///     Zero if the response was "OK", a positive value if the
 100   ///     the response was "Exx" where xx are two hex digits, or
 101   ///     -1 if the call is unsupported or any other unexpected
 102   ///     response was received.
 103   //------------------------------------------------------------------
 104   int SendArgumentsPacket(const ProcessLaunchInfo &launch_info);
 105
 106   //------------------------------------------------------------------
 107   /// Sends a "QEnvironment:NAME=VALUE" packet that will build up the
 108   /// environment that will get used when launching an application
 109   /// in conjunction with the 'A' packet. This function can be called
 110   /// multiple times in a row in order to pass on the desired
 111   /// environment that the inferior should be launched with.
 112   ///
 113   /// @param[in] name_equal_value
 114   ///     A NULL terminated C string that contains a single environment
 115   ///     in the format "NAME=VALUE".
 116   ///
 117   /// @return
 118   ///     Zero if the response was "OK", a positive value if the
 119   ///     the response was "Exx" where xx are two hex digits, or
 120   ///     -1 if the call is unsupported or any other unexpected
 121   ///     response was received.
 122   //------------------------------------------------------------------
 123   int SendEnvironmentPacket(char const *name_equal_value);
 124   int SendEnvironment(const Environment &env);
 125
 126   int SendLaunchArchPacket(const char *arch);
 127
 128   int SendLaunchEventDataPacket(const char *data,
 129                                 bool *was_supported = nullptr);
 130
 131   //------------------------------------------------------------------
 132   /// Sends a "vAttach:PID" where PID is in hex.
 133   ///
 134   /// @param[in] pid
 135   ///     A process ID for the remote gdb server to attach to.
 136   ///
 137   /// @param[out] response
 138   ///     The response received from the gdb server. If the return
 139   ///     value is zero, \a response will contain a stop reply
 140   ///     packet.
 141   ///
 142   /// @return
 143   ///     Zero if the attach was successful, or an error indicating
 144   ///     an error code.
 145   //------------------------------------------------------------------
 146   int SendAttach(lldb::pid_t pid, StringExtractorGDBRemote &response);
 147
 148   //------------------------------------------------------------------
 149   /// Sends a GDB remote protocol 'I' packet that delivers stdin
 150   /// data to the remote process.
 151   ///
 152   /// @param[in] data
 153   ///     A pointer to stdin data.
 154   ///
 155   /// @param[in] data_len
 156   ///     The number of bytes available at \a data.
 157   ///
 158   /// @return
 159   ///     Zero if the attach was successful, or an error indicating
 160   ///     an error code.
 161   //------------------------------------------------------------------
 162   int SendStdinNotification(const char *data, size_t data_len);
 163
 164   //------------------------------------------------------------------
 165   /// Sets the path to use for stdin/out/err for a process
 166   /// that will be launched with the 'A' packet.
 167   ///
 168   /// @param[in] path
 169   ///     The path to use for stdin/out/err
 170   ///
 171   /// @return
 172   ///     Zero if the for success, or an error code for failure.
 173   //------------------------------------------------------------------
 174   int SetSTDIN(const FileSpec &file_spec);
 175   int SetSTDOUT(const FileSpec &file_spec);
 176   int SetSTDERR(const FileSpec &file_spec);
 177
 178   //------------------------------------------------------------------
 179   /// Sets the disable ASLR flag to \a enable for a process that will
 180   /// be launched with the 'A' packet.
 181   ///
 182   /// @param[in] enable
 183   ///     A boolean value indicating whether to disable ASLR or not.
 184   ///
 185   /// @return
 186   ///     Zero if the for success, or an error code for failure.
 187   //------------------------------------------------------------------
 188   int SetDisableASLR(bool enable);
 189
 190   //------------------------------------------------------------------
 191   /// Sets the DetachOnError flag to \a enable for the process controlled by the
 192   /// stub.
 193   ///
 194   /// @param[in] enable
 195   ///     A boolean value indicating whether to detach on error or not.
 196   ///
 197   /// @return
 198   ///     Zero if the for success, or an error code for failure.
 199   //------------------------------------------------------------------
 200   int SetDetachOnError(bool enable);
 201
 202   //------------------------------------------------------------------
 203   /// Sets the working directory to \a path for a process that will
 204   /// be launched with the 'A' packet for non platform based
 205   /// connections. If this packet is sent to a GDB server that
 206   /// implements the platform, it will change the current working
 207   /// directory for the platform process.
 208   ///
 209   /// @param[in] working_dir
 210   ///     The path to a directory to use when launching our process
 211   ///
 212   /// @return
 213   ///     Zero if the for success, or an error code for failure.
 214   //------------------------------------------------------------------
 215   int SetWorkingDir(const FileSpec &working_dir);
 216
 217   //------------------------------------------------------------------
 218   /// Gets the current working directory of a remote platform GDB
 219   /// server.
 220   ///
 221   /// @param[out] working_dir
 222   ///     The current working directory on the remote platform.
 223   ///
 224   /// @return
 225   ///     Boolean for success
 226   //------------------------------------------------------------------
 227   bool GetWorkingDir(FileSpec &working_dir);
 228
 229   lldb::addr_t AllocateMemory(size_t size, uint32_t permissions);
 230
 231   bool DeallocateMemory(lldb::addr_t addr);
 232
 233   Status Detach(bool keep_stopped);
 234
 235   Status GetMemoryRegionInfo(lldb::addr_t addr, MemoryRegionInfo &range_info);
 236
 237   Status GetWatchpointSupportInfo(uint32_t &num);
 238
 239   Status GetWatchpointSupportInfo(uint32_t &num, bool &after,
 240                                   const ArchSpec &arch);
 241
 242   Status GetWatchpointsTriggerAfterInstruction(bool &after,
 243                                                const ArchSpec &arch);
 244
 245   const ArchSpec &GetHostArchitecture();
 246
 247   std::chrono::seconds GetHostDefaultPacketTimeout();
 248
 249   const ArchSpec &GetProcessArchitecture();
 250
 251   void GetRemoteQSupported();
 252
 253   bool GetVContSupported(char flavor);
 254
 255   bool GetpPacketSupported(lldb::tid_t tid);
 256
 257   bool GetxPacketSupported();
 258
 259   bool GetVAttachOrWaitSupported();
 260
 261   bool GetSyncThreadStateSupported();
 262
 263   void ResetDiscoverableSettings(bool did_exec);
 264
 265   bool GetHostInfo(bool force = false);
 266
 267   bool GetDefaultThreadId(lldb::tid_t &tid);
 268
 269   llvm::VersionTuple GetOSVersion();
 270
 271   bool GetOSBuildString(std::string &s);
 272
 273   bool GetOSKernelDescription(std::string &s);
 274
 275   ArchSpec GetSystemArchitecture();
 276
 277   bool GetHostname(std::string &s);
 278
 279   lldb::addr_t GetShlibInfoAddr();
 280
 281   bool GetSupportsThreadSuffix();
 282
 283   bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info);
 284
 285   uint32_t FindProcesses(const ProcessInstanceInfoMatch &process_match_info,
 286                          ProcessInstanceInfoList &process_infos);
 287
 288   bool GetUserName(uint32_t uid, std::string &name);
 289
 290   bool GetGroupName(uint32_t gid, std::string &name);
 291
 292   bool HasFullVContSupport() { return GetVContSupported('A'); }
 293
 294   bool HasAnyVContSupport() { return GetVContSupported('a'); }
 295
 296   bool GetStopReply(StringExtractorGDBRemote &response);
 297
 298   bool GetThreadStopInfo(lldb::tid_t tid, StringExtractorGDBRemote &response);
 299
 300   bool SupportsGDBStoppointPacket(GDBStoppointType type) {
 301     switch (type) {
 302     case eBreakpointSoftware:
 303       return m_supports_z0;
 304     case eBreakpointHardware:
 305       return m_supports_z1;
 306     case eWatchpointWrite:
 307       return m_supports_z2;
 308     case eWatchpointRead:
 309       return m_supports_z3;
 310     case eWatchpointReadWrite:
 311       return m_supports_z4;
 312     default:
 313       return false;
 314     }
 315   }
 316
 317   uint8_t SendGDBStoppointTypePacket(
 318       GDBStoppointType type, // Type of breakpoint or watchpoint
 319       bool insert,           // Insert or remove?
 320       lldb::addr_t addr,     // Address of breakpoint or watchpoint
 321       uint32_t length);      // Byte Size of breakpoint or watchpoint
 322
 323   bool SetNonStopMode(const bool enable);
 324
 325   void TestPacketSpeed(const uint32_t num_packets, uint32_t max_send,
 326                        uint32_t max_recv, uint64_t recv_amount, bool json,
 327                        Stream &strm);
 328
 329   // This packet is for testing the speed of the interface only. Both
 330   // the client and server need to support it, but this allows us to
 331   // measure the packet speed without any other work being done on the
 332   // other end and avoids any of that work affecting the packet send
 333   // and response times.
 334   bool SendSpeedTestPacket(uint32_t send_size, uint32_t recv_size);
 335
 336   bool SetCurrentThread(uint64_t tid);
 337
 338   bool SetCurrentThreadForRun(uint64_t tid);
 339
 340   bool GetQXferAuxvReadSupported();
 341
 342   void EnableErrorStringInPacket();
 343
 344   bool GetQXferLibrariesReadSupported();
 345
 346   bool GetQXferLibrariesSVR4ReadSupported();
 347
 348   uint64_t GetRemoteMaxPacketSize();
 349
 350   bool GetEchoSupported();
 351
 352   bool GetQPassSignalsSupported();
 353
 354   bool GetAugmentedLibrariesSVR4ReadSupported();
 355
 356   bool GetQXferFeaturesReadSupported();
 357
 358   bool GetQXferMemoryMapReadSupported();
 359
 360   LazyBool SupportsAllocDeallocMemory() // const
 361   {
 362     // Uncomment this to have lldb pretend the debug server doesn't respond to
 363     // alloc/dealloc memory packets.
 364     // m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo;
 365     return m_supports_alloc_dealloc_memory;
 366   }
 367
 368   size_t GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids,
 369                              bool &sequence_mutex_unavailable);
 370
 371   lldb::user_id_t OpenFile(const FileSpec &file_spec, uint32_t flags,
 372                            mode_t mode, Status &error);
 373
 374   bool CloseFile(lldb::user_id_t fd, Status &error);
 375
 376   lldb::user_id_t GetFileSize(const FileSpec &file_spec);
 377
 378   Status GetFilePermissions(const FileSpec &file_spec,
 379                             uint32_t &file_permissions);
 380
 381   Status SetFilePermissions(const FileSpec &file_spec,
 382                             uint32_t file_permissions);
 383
 384   uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst,
 385                     uint64_t dst_len, Status &error);
 386
 387   uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src,
 388                      uint64_t src_len, Status &error);
 389
 390   Status CreateSymlink(const FileSpec &src, const FileSpec &dst);
 391
 392   Status Unlink(const FileSpec &file_spec);
 393
 394   Status MakeDirectory(const FileSpec &file_spec, uint32_t mode);
 395
 396   bool GetFileExists(const FileSpec &file_spec);
 397
 398   Status RunShellCommand(
 399       const char *command,         // Shouldn't be nullptr
 400       const FileSpec &working_dir, // Pass empty FileSpec to use the current
 401                                    // working directory
 402       int *status_ptr, // Pass nullptr if you don't want the process exit status
 403       int *signo_ptr,  // Pass nullptr if you don't want the signal that caused
 404                        // the process to exit
 405       std::string
 406           *command_output, // Pass nullptr if you don't want the command output
 407       const Timeout<std::micro> &timeout);
 408
 409   bool CalculateMD5(const FileSpec &file_spec, uint64_t &high, uint64_t &low);
 410
 411   lldb::DataBufferSP ReadRegister(
 412       lldb::tid_t tid,
 413       uint32_t
 414           reg_num); // Must be the eRegisterKindProcessPlugin register number
 415
 416   lldb::DataBufferSP ReadAllRegisters(lldb::tid_t tid);
 417
 418   bool
 419   WriteRegister(lldb::tid_t tid,
 420                 uint32_t reg_num, // eRegisterKindProcessPlugin register number
 421                 llvm::ArrayRef<uint8_t> data);
 422
 423   bool WriteAllRegisters(lldb::tid_t tid, llvm::ArrayRef<uint8_t> data);
 424
 425   bool SaveRegisterState(lldb::tid_t tid, uint32_t &save_id);
 426
 427   bool RestoreRegisterState(lldb::tid_t tid, uint32_t save_id);
 428
 429   bool SyncThreadState(lldb::tid_t tid);
 430
 431   const char *GetGDBServerProgramName();
 432
 433   uint32_t GetGDBServerProgramVersion();
 434
 435   bool AvoidGPackets(ProcessGDBRemote *process);
 436
 437   StructuredData::ObjectSP GetThreadsInfo();
 438
 439   bool GetThreadExtendedInfoSupported();
 440
 441   bool GetLoadedDynamicLibrariesInfosSupported();
 442
 443   bool GetSharedCacheInfoSupported();
 444
 445   bool GetModuleInfo(const FileSpec &module_file_spec,
 446                      const ArchSpec &arch_spec, ModuleSpec &module_spec);
 447
 448   llvm::Optional<std::vector<ModuleSpec>>
 449   GetModulesInfo(llvm::ArrayRef<FileSpec> module_file_specs,
 450                  const llvm::Triple &triple);
 451
 452   bool ReadExtFeature(const lldb_private::ConstString object,
 453                       const lldb_private::ConstString annex, std::string &out,
 454                       lldb_private::Status &err);
 455
 456   void ServeSymbolLookups(lldb_private::Process *process);
 457
 458   // Sends QPassSignals packet to the server with given signals to ignore.
 459   Status SendSignalsToIgnore(llvm::ArrayRef<int32_t> signals);
 460
 461   //------------------------------------------------------------------
 462   /// Return the feature set supported by the gdb-remote server.
 463   ///
 464   /// This method returns the remote side's response to the qSupported
 465   /// packet.  The response is the complete string payload returned
 466   /// to the client.
 467   ///
 468   /// @return
 469   ///     The string returned by the server to the qSupported query.
 470   //------------------------------------------------------------------
 471   const std::string &GetServerSupportedFeatures() const {
 472     return m_qSupported_response;
 473   }
 474
 475   //------------------------------------------------------------------
 476   /// Return the array of async JSON packet types supported by the remote.
 477   ///
 478   /// This method returns the remote side's array of supported JSON
 479   /// packet types as a list of type names.  Each of the results are
 480   /// expected to have an Enable{type_name} command to enable and configure
 481   /// the related feature.  Each type_name for an enabled feature will
 482   /// possibly send async-style packets that contain a payload of a
 483   /// binhex-encoded JSON dictionary.  The dictionary will have a
 484   /// string field named 'type', that contains the type_name of the
 485   /// supported packet type.
 486   ///
 487   /// There is a Plugin category called structured-data plugins.
 488   /// A plugin indicates whether it knows how to handle a type_name.
 489   /// If so, it can be used to process the async JSON packet.
 490   ///
 491   /// @return
 492   ///     The string returned by the server to the qSupported query.
 493   //------------------------------------------------------------------
 494   lldb_private::StructuredData::Array *GetSupportedStructuredDataPlugins();
 495
 496   //------------------------------------------------------------------
 497   /// Configure a StructuredData feature on the remote end.
 498   ///
 499   /// @see \b Process::ConfigureStructuredData(...) for details.
 500   //------------------------------------------------------------------
 501   Status
 502   ConfigureRemoteStructuredData(const ConstString &type_name,
 503                                 const StructuredData::ObjectSP &config_sp);
 504
 505   lldb::user_id_t SendStartTracePacket(const TraceOptions &options,
 506                                        Status &error);
 507
 508   Status SendStopTracePacket(lldb::user_id_t uid, lldb::tid_t thread_id);
 509
 510   Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
 511                            llvm::MutableArrayRef<uint8_t> &buffer,
 512                            size_t offset = 0);
 513
 514   Status SendGetMetaDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
 515                                llvm::MutableArrayRef<uint8_t> &buffer,
 516                                size_t offset = 0);
 517
 518   Status SendGetTraceConfigPacket(lldb::user_id_t uid, TraceOptions &options);
 519
 520 protected:
 521   LazyBool m_supports_not_sending_acks;
 522   LazyBool m_supports_thread_suffix;
 523   LazyBool m_supports_threads_in_stop_reply;
 524   LazyBool m_supports_vCont_all;
 525   LazyBool m_supports_vCont_any;
 526   LazyBool m_supports_vCont_c;
 527   LazyBool m_supports_vCont_C;
 528   LazyBool m_supports_vCont_s;
 529   LazyBool m_supports_vCont_S;
 530   LazyBool m_qHostInfo_is_valid;
 531   LazyBool m_curr_pid_is_valid;
 532   LazyBool m_qProcessInfo_is_valid;
 533   LazyBool m_qGDBServerVersion_is_valid;
 534   LazyBool m_supports_alloc_dealloc_memory;
 535   LazyBool m_supports_memory_region_info;
 536   LazyBool m_supports_watchpoint_support_info;
 537   LazyBool m_supports_detach_stay_stopped;
 538   LazyBool m_watchpoints_trigger_after_instruction;
 539   LazyBool m_attach_or_wait_reply;
 540   LazyBool m_prepare_for_reg_writing_reply;
 541   LazyBool m_supports_p;
 542   LazyBool m_supports_x;
 543   LazyBool m_avoid_g_packets;
 544   LazyBool m_supports_QSaveRegisterState;
 545   LazyBool m_supports_qXfer_auxv_read;
 546   LazyBool m_supports_qXfer_libraries_read;
 547   LazyBool m_supports_qXfer_libraries_svr4_read;
 548   LazyBool m_supports_qXfer_features_read;
 549   LazyBool m_supports_qXfer_memory_map_read;
 550   LazyBool m_supports_augmented_libraries_svr4_read;
 551   LazyBool m_supports_jThreadExtendedInfo;
 552   LazyBool m_supports_jLoadedDynamicLibrariesInfos;
 553   LazyBool m_supports_jGetSharedCacheInfo;
 554   LazyBool m_supports_QPassSignals;
 555   LazyBool m_supports_error_string_reply;
 556
 557   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
 558       m_supports_qUserName : 1, m_supports_qGroupName : 1,
 559       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
 560       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
 561       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
 562       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
 563       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,
 564       m_supports_jModulesInfo : 1;
 565
 566   lldb::pid_t m_curr_pid;
 567   lldb::tid_t m_curr_tid; // Current gdb remote protocol thread index for all
 568                           // other operations
 569   lldb::tid_t m_curr_tid_run; // Current gdb remote protocol thread index for
 570                               // continue, step, etc
 571
 572   uint32_t m_num_supported_hardware_watchpoints;
 573
 574   ArchSpec m_host_arch;
 575   ArchSpec m_process_arch;
 576   llvm::VersionTuple m_os_version;
 577   std::string m_os_build;
 578   std::string m_os_kernel;
 579   std::string m_hostname;
 580   std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if
 581                                  // qGDBServerVersion is not supported
 582   uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if
 583                                  // qGDBServerVersion is not supported
 584   std::chrono::seconds m_default_packet_timeout;
 585   uint64_t m_max_packet_size;        // as returned by qSupported
 586   std::string m_qSupported_response; // the complete response to qSupported
 587
 588   bool m_supported_async_json_packets_is_valid;
 589   lldb_private::StructuredData::ObjectSP m_supported_async_json_packets_sp;
 590
 591   std::vector<MemoryRegionInfo> m_qXfer_memory_map;
 592   bool m_qXfer_memory_map_loaded;
 593
 594   bool GetCurrentProcessInfo(bool allow_lazy_pid = true);
 595
 596   bool GetGDBServerVersion();
 597
 598   // Given the list of compression types that the remote debug stub can support,
 599   // possibly enable compression if we find an encoding we can handle.
 600   void MaybeEnableCompression(std::vector<std::string> supported_compressions);
 601
 602   bool DecodeProcessInfoResponse(StringExtractorGDBRemote &response,
 603                                  ProcessInstanceInfo &process_info);
 604
 605   void OnRunPacketSent(bool first) override;
 606
 607   PacketResult SendThreadSpecificPacketAndWaitForResponse(
 608       lldb::tid_t tid, StreamString &&payload,
 609       StringExtractorGDBRemote &response, bool send_async);
 610
 611   Status SendGetTraceDataPacket(StreamGDBRemote &packet, lldb::user_id_t uid,
 612                                 lldb::tid_t thread_id,
 613                                 llvm::MutableArrayRef<uint8_t> &buffer,
 614                                 size_t offset);
 615
 616   Status LoadQXferMemoryMap();
 617
 618   Status GetQXferMemoryMapRegionInfo(lldb::addr_t addr,
 619                                      MemoryRegionInfo &region);
 620
 621 private:
 622   DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationClient);
 623 };
 624
 625 } // namespace process_gdb_remote
 626 } // namespace lldb_private
 627
 628 #endif // liblldb_GDBRemoteCommunicationClient_h_