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