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