1//===-- ProcessGDBRemote.cpp ----------------------------------------------===//
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#include "lldb/Host/Config.h"
10
11#include <cerrno>
12#include <cstdlib>
13#if LLDB_ENABLE_POSIX
14#include <netinet/in.h>
15#include <sys/mman.h>
16#include <sys/socket.h>
17#include <unistd.h>
18#endif
19#include <sys/stat.h>
20#if defined(__APPLE__)
21#include <sys/sysctl.h>
22#endif
23#include <ctime>
24#include <sys/types.h>
25
26#include "lldb/Breakpoint/Watchpoint.h"
27#include "lldb/Breakpoint/WatchpointAlgorithms.h"
28#include "lldb/Breakpoint/WatchpointResource.h"
29#include "lldb/Core/Debugger.h"
30#include "lldb/Core/Module.h"
31#include "lldb/Core/ModuleSpec.h"
32#include "lldb/Core/PluginManager.h"
33#include "lldb/Core/Value.h"
34#include "lldb/DataFormatters/FormatManager.h"
35#include "lldb/Host/ConnectionFileDescriptor.h"
36#include "lldb/Host/FileSystem.h"
37#include "lldb/Host/HostThread.h"
38#include "lldb/Host/PosixApi.h"
39#include "lldb/Host/PseudoTerminal.h"
40#include "lldb/Host/StreamFile.h"
41#include "lldb/Host/ThreadLauncher.h"
42#include "lldb/Host/XML.h"
43#include "lldb/Interpreter/CommandInterpreter.h"
44#include "lldb/Interpreter/CommandObject.h"
45#include "lldb/Interpreter/CommandObjectMultiword.h"
46#include "lldb/Interpreter/CommandReturnObject.h"
47#include "lldb/Interpreter/OptionArgParser.h"
48#include "lldb/Interpreter/OptionGroupBoolean.h"
49#include "lldb/Interpreter/OptionGroupUInt64.h"
50#include "lldb/Interpreter/OptionValueProperties.h"
51#include "lldb/Interpreter/Options.h"
52#include "lldb/Interpreter/Property.h"
53#include "lldb/Symbol/ObjectFile.h"
54#include "lldb/Target/ABI.h"
55#include "lldb/Target/DynamicLoader.h"
56#include "lldb/Target/MemoryRegionInfo.h"
57#include "lldb/Target/RegisterFlags.h"
58#include "lldb/Target/SystemRuntime.h"
59#include "lldb/Target/Target.h"
60#include "lldb/Target/TargetList.h"
61#include "lldb/Target/ThreadPlanCallFunction.h"
62#include "lldb/Utility/Args.h"
63#include "lldb/Utility/FileSpec.h"
64#include "lldb/Utility/LLDBLog.h"
65#include "lldb/Utility/State.h"
66#include "lldb/Utility/StreamString.h"
67#include "lldb/Utility/Timer.h"
68#include <algorithm>
69#include <csignal>
70#include <map>
71#include <memory>
72#include <mutex>
73#include <optional>
74#include <sstream>
75#include <thread>
76
77#include "GDBRemoteRegisterContext.h"
78#include "GDBRemoteRegisterFallback.h"
79#include "Plugins/Process/Utility/GDBRemoteSignals.h"
80#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
81#include "Plugins/Process/Utility/StopInfoMachException.h"
82#include "ProcessGDBRemote.h"
83#include "ProcessGDBRemoteLog.h"
84#include "ThreadGDBRemote.h"
85#include "lldb/Host/Host.h"
86#include "lldb/Utility/StringExtractorGDBRemote.h"
87
88#include "llvm/ADT/ScopeExit.h"
89#include "llvm/ADT/StringMap.h"
90#include "llvm/ADT/StringSwitch.h"
91#include "llvm/Support/FormatAdapters.h"
92#include "llvm/Support/Threading.h"
93#include "llvm/Support/raw_ostream.h"
94
95#define DEBUGSERVER_BASENAME "debugserver"
96using namespace lldb;
97using namespace lldb_private;
98using namespace lldb_private::process_gdb_remote;
99
100LLDB_PLUGIN_DEFINE(ProcessGDBRemote)
101
102namespace lldb {
103// Provide a function that can easily dump the packet history if we know a
104// ProcessGDBRemote * value (which we can get from logs or from debugging). We
105// need the function in the lldb namespace so it makes it into the final
106// executable since the LLDB shared library only exports stuff in the lldb
107// namespace. This allows you to attach with a debugger and call this function
108// and get the packet history dumped to a file.
109void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
110 auto file = FileSystem::Instance().Open(
111 file_spec: FileSpec(path), options: File::eOpenOptionWriteOnly | File::eOpenOptionCanCreate);
112 if (!file) {
113 llvm::consumeError(Err: file.takeError());
114 return;
115 }
116 StreamFile stream(std::move(file.get()));
117 ((Process *)p)->DumpPluginHistory(s&: stream);
118}
119} // namespace lldb
120
121namespace {
122
123#define LLDB_PROPERTIES_processgdbremote
124#include "ProcessGDBRemoteProperties.inc"
125
126enum {
127#define LLDB_PROPERTIES_processgdbremote
128#include "ProcessGDBRemotePropertiesEnum.inc"
129};
130
131class PluginProperties : public Properties {
132public:
133 static llvm::StringRef GetSettingName() {
134 return ProcessGDBRemote::GetPluginNameStatic();
135 }
136
137 PluginProperties() : Properties() {
138 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
139 m_collection_sp->Initialize(g_processgdbremote_properties);
140 }
141
142 ~PluginProperties() override = default;
143
144 uint64_t GetPacketTimeout() {
145 const uint32_t idx = ePropertyPacketTimeout;
146 return GetPropertyAtIndexAs<uint64_t>(
147 idx, g_processgdbremote_properties[idx].default_uint_value);
148 }
149
150 bool SetPacketTimeout(uint64_t timeout) {
151 const uint32_t idx = ePropertyPacketTimeout;
152 return SetPropertyAtIndex(idx, timeout);
153 }
154
155 FileSpec GetTargetDefinitionFile() const {
156 const uint32_t idx = ePropertyTargetDefinitionFile;
157 return GetPropertyAtIndexAs<FileSpec>(idx, {});
158 }
159
160 bool GetUseSVR4() const {
161 const uint32_t idx = ePropertyUseSVR4;
162 return GetPropertyAtIndexAs<bool>(
163 idx, g_processgdbremote_properties[idx].default_uint_value != 0);
164 }
165
166 bool GetUseGPacketForReading() const {
167 const uint32_t idx = ePropertyUseGPacketForReading;
168 return GetPropertyAtIndexAs<bool>(idx, true);
169 }
170};
171
172std::chrono::seconds ResumeTimeout() { return std::chrono::seconds(5); }
173
174} // namespace
175
176static PluginProperties &GetGlobalPluginProperties() {
177 static PluginProperties g_settings;
178 return g_settings;
179}
180
181// TODO Randomly assigning a port is unsafe. We should get an unused
182// ephemeral port from the kernel and make sure we reserve it before passing it
183// to debugserver.
184
185#if defined(__APPLE__)
186#define LOW_PORT (IPPORT_RESERVED)
187#define HIGH_PORT (IPPORT_HIFIRSTAUTO)
188#else
189#define LOW_PORT (1024u)
190#define HIGH_PORT (49151u)
191#endif
192
193llvm::StringRef ProcessGDBRemote::GetPluginDescriptionStatic() {
194 return "GDB Remote protocol based debugging plug-in.";
195}
196
197void ProcessGDBRemote::Terminate() {
198 PluginManager::UnregisterPlugin(create_callback: ProcessGDBRemote::CreateInstance);
199}
200
201lldb::ProcessSP ProcessGDBRemote::CreateInstance(
202 lldb::TargetSP target_sp, ListenerSP listener_sp,
203 const FileSpec *crash_file_path, bool can_connect) {
204 lldb::ProcessSP process_sp;
205 if (crash_file_path == nullptr)
206 process_sp = std::shared_ptr<ProcessGDBRemote>(
207 new ProcessGDBRemote(target_sp, listener_sp));
208 return process_sp;
209}
210
211void ProcessGDBRemote::DumpPluginHistory(Stream &s) {
212 GDBRemoteCommunicationClient &gdb_comm(GetGDBRemote());
213 gdb_comm.DumpHistory(strm&: s);
214}
215
216std::chrono::seconds ProcessGDBRemote::GetPacketTimeout() {
217 return std::chrono::seconds(GetGlobalPluginProperties().GetPacketTimeout());
218}
219
220ArchSpec ProcessGDBRemote::GetSystemArchitecture() {
221 return m_gdb_comm.GetHostArchitecture();
222}
223
224bool ProcessGDBRemote::CanDebug(lldb::TargetSP target_sp,
225 bool plugin_specified_by_name) {
226 if (plugin_specified_by_name)
227 return true;
228
229 // For now we are just making sure the file exists for a given module
230 Module *exe_module = target_sp->GetExecutableModulePointer();
231 if (exe_module) {
232 ObjectFile *exe_objfile = exe_module->GetObjectFile();
233 // We can't debug core files...
234 switch (exe_objfile->GetType()) {
235 case ObjectFile::eTypeInvalid:
236 case ObjectFile::eTypeCoreFile:
237 case ObjectFile::eTypeDebugInfo:
238 case ObjectFile::eTypeObjectFile:
239 case ObjectFile::eTypeSharedLibrary:
240 case ObjectFile::eTypeStubLibrary:
241 case ObjectFile::eTypeJIT:
242 return false;
243 case ObjectFile::eTypeExecutable:
244 case ObjectFile::eTypeDynamicLinker:
245 case ObjectFile::eTypeUnknown:
246 break;
247 }
248 return FileSystem::Instance().Exists(file_spec: exe_module->GetFileSpec());
249 }
250 // However, if there is no executable module, we return true since we might
251 // be preparing to attach.
252 return true;
253}
254
255// ProcessGDBRemote constructor
256ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp,
257 ListenerSP listener_sp)
258 : Process(target_sp, listener_sp),
259 m_debugserver_pid(LLDB_INVALID_PROCESS_ID), m_register_info_sp(nullptr),
260 m_async_broadcaster(nullptr, "lldb.process.gdb-remote.async-broadcaster"),
261 m_async_listener_sp(
262 Listener::MakeListener(name: "lldb.process.gdb-remote.async-listener")),
263 m_async_thread_state_mutex(), m_thread_ids(), m_thread_pcs(),
264 m_jstopinfo_sp(), m_jthreadsinfo_sp(), m_continue_c_tids(),
265 m_continue_C_tids(), m_continue_s_tids(), m_continue_S_tids(),
266 m_max_memory_size(0), m_remote_stub_max_memory_size(0),
267 m_addr_to_mmap_size(), m_thread_create_bp_sp(),
268 m_waiting_for_attach(false), m_command_sp(), m_breakpoint_pc_offset(0),
269 m_initial_tid(LLDB_INVALID_THREAD_ID), m_allow_flash_writes(false),
270 m_erased_flash_ranges(), m_vfork_in_progress_count(0) {
271 m_async_broadcaster.SetEventName(event_mask: eBroadcastBitAsyncThreadShouldExit,
272 name: "async thread should exit");
273 m_async_broadcaster.SetEventName(event_mask: eBroadcastBitAsyncContinue,
274 name: "async thread continue");
275 m_async_broadcaster.SetEventName(event_mask: eBroadcastBitAsyncThreadDidExit,
276 name: "async thread did exit");
277
278 Log *log = GetLog(mask: GDBRLog::Async);
279
280 const uint32_t async_event_mask =
281 eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
282
283 if (m_async_listener_sp->StartListeningForEvents(
284 broadcaster: &m_async_broadcaster, event_mask: async_event_mask) != async_event_mask) {
285 LLDB_LOGF(log,
286 "ProcessGDBRemote::%s failed to listen for "
287 "m_async_broadcaster events",
288 __FUNCTION__);
289 }
290
291 const uint64_t timeout_seconds =
292 GetGlobalPluginProperties().GetPacketTimeout();
293 if (timeout_seconds > 0)
294 m_gdb_comm.SetPacketTimeout(std::chrono::seconds(timeout_seconds));
295
296 m_use_g_packet_for_reading =
297 GetGlobalPluginProperties().GetUseGPacketForReading();
298}
299
300// Destructor
301ProcessGDBRemote::~ProcessGDBRemote() {
302 // m_mach_process.UnregisterNotificationCallbacks (this);
303 Clear();
304 // We need to call finalize on the process before destroying ourselves to
305 // make sure all of the broadcaster cleanup goes as planned. If we destruct
306 // this class, then Process::~Process() might have problems trying to fully
307 // destroy the broadcaster.
308 Finalize(destructing: true /* destructing */);
309
310 // The general Finalize is going to try to destroy the process and that
311 // SHOULD shut down the async thread. However, if we don't kill it it will
312 // get stranded and its connection will go away so when it wakes up it will
313 // crash. So kill it for sure here.
314 StopAsyncThread();
315 KillDebugserverProcess();
316}
317
318bool ProcessGDBRemote::ParsePythonTargetDefinition(
319 const FileSpec &target_definition_fspec) {
320 ScriptInterpreter *interpreter =
321 GetTarget().GetDebugger().GetScriptInterpreter();
322 Status error;
323 StructuredData::ObjectSP module_object_sp(
324 interpreter->LoadPluginModule(file_spec: target_definition_fspec, error));
325 if (module_object_sp) {
326 StructuredData::DictionarySP target_definition_sp(
327 interpreter->GetDynamicSettings(plugin_module_sp: module_object_sp, target: &GetTarget(),
328 setting_name: "gdb-server-target-definition", error));
329
330 if (target_definition_sp) {
331 StructuredData::ObjectSP target_object(
332 target_definition_sp->GetValueForKey(key: "host-info"));
333 if (target_object) {
334 if (auto host_info_dict = target_object->GetAsDictionary()) {
335 StructuredData::ObjectSP triple_value =
336 host_info_dict->GetValueForKey(key: "triple");
337 if (auto triple_string_value = triple_value->GetAsString()) {
338 std::string triple_string =
339 std::string(triple_string_value->GetValue());
340 ArchSpec host_arch(triple_string.c_str());
341 if (!host_arch.IsCompatibleMatch(rhs: GetTarget().GetArchitecture())) {
342 GetTarget().SetArchitecture(arch_spec: host_arch);
343 }
344 }
345 }
346 }
347 m_breakpoint_pc_offset = 0;
348 StructuredData::ObjectSP breakpoint_pc_offset_value =
349 target_definition_sp->GetValueForKey(key: "breakpoint-pc-offset");
350 if (breakpoint_pc_offset_value) {
351 if (auto breakpoint_pc_int_value =
352 breakpoint_pc_offset_value->GetAsSignedInteger())
353 m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue();
354 }
355
356 if (m_register_info_sp->SetRegisterInfo(
357 dict: *target_definition_sp, arch: GetTarget().GetArchitecture()) > 0) {
358 return true;
359 }
360 }
361 }
362 return false;
363}
364
365static size_t SplitCommaSeparatedRegisterNumberString(
366 const llvm::StringRef &comma_separated_register_numbers,
367 std::vector<uint32_t> &regnums, int base) {
368 regnums.clear();
369 for (llvm::StringRef x : llvm::split(Str: comma_separated_register_numbers, Separator: ',')) {
370 uint32_t reg;
371 if (llvm::to_integer(S: x, Num&: reg, Base: base))
372 regnums.push_back(x: reg);
373 }
374 return regnums.size();
375}
376
377void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
378 if (!force && m_register_info_sp)
379 return;
380
381 m_register_info_sp = std::make_shared<GDBRemoteDynamicRegisterInfo>();
382
383 // Check if qHostInfo specified a specific packet timeout for this
384 // connection. If so then lets update our setting so the user knows what the
385 // timeout is and can see it.
386 const auto host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
387 if (host_packet_timeout > std::chrono::seconds(0)) {
388 GetGlobalPluginProperties().SetPacketTimeout(host_packet_timeout.count());
389 }
390
391 // Register info search order:
392 // 1 - Use the target definition python file if one is specified.
393 // 2 - If the target definition doesn't have any of the info from the
394 // target.xml (registers) then proceed to read the target.xml.
395 // 3 - Fall back on the qRegisterInfo packets.
396 // 4 - Use hardcoded defaults if available.
397
398 FileSpec target_definition_fspec =
399 GetGlobalPluginProperties().GetTargetDefinitionFile();
400 if (!FileSystem::Instance().Exists(file_spec: target_definition_fspec)) {
401 // If the filename doesn't exist, it may be a ~ not having been expanded -
402 // try to resolve it.
403 FileSystem::Instance().Resolve(file_spec&: target_definition_fspec);
404 }
405 if (target_definition_fspec) {
406 // See if we can get register definitions from a python file
407 if (ParsePythonTargetDefinition(target_definition_fspec))
408 return;
409
410 Debugger::ReportError(message: "target description file " +
411 target_definition_fspec.GetPath() +
412 " failed to parse",
413 debugger_id: GetTarget().GetDebugger().GetID());
414 }
415
416 const ArchSpec &target_arch = GetTarget().GetArchitecture();
417 const ArchSpec &remote_host_arch = m_gdb_comm.GetHostArchitecture();
418 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
419
420 // Use the process' architecture instead of the host arch, if available
421 ArchSpec arch_to_use;
422 if (remote_process_arch.IsValid())
423 arch_to_use = remote_process_arch;
424 else
425 arch_to_use = remote_host_arch;
426
427 if (!arch_to_use.IsValid())
428 arch_to_use = target_arch;
429
430 if (GetGDBServerRegisterInfo(arch&: arch_to_use))
431 return;
432
433 char packet[128];
434 std::vector<DynamicRegisterInfo::Register> registers;
435 uint32_t reg_num = 0;
436 for (StringExtractorGDBRemote::ResponseType response_type =
437 StringExtractorGDBRemote::eResponse;
438 response_type == StringExtractorGDBRemote::eResponse; ++reg_num) {
439 const int packet_len =
440 ::snprintf(s: packet, maxlen: sizeof(packet), format: "qRegisterInfo%x", reg_num);
441 assert(packet_len < (int)sizeof(packet));
442 UNUSED_IF_ASSERT_DISABLED(packet_len);
443 StringExtractorGDBRemote response;
444 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet, response) ==
445 GDBRemoteCommunication::PacketResult::Success) {
446 response_type = response.GetResponseType();
447 if (response_type == StringExtractorGDBRemote::eResponse) {
448 llvm::StringRef name;
449 llvm::StringRef value;
450 DynamicRegisterInfo::Register reg_info;
451
452 while (response.GetNameColonValue(name, value)) {
453 if (name == "name") {
454 reg_info.name.SetString(value);
455 } else if (name == "alt-name") {
456 reg_info.alt_name.SetString(value);
457 } else if (name == "bitsize") {
458 if (!value.getAsInteger(Radix: 0, Result&: reg_info.byte_size))
459 reg_info.byte_size /= CHAR_BIT;
460 } else if (name == "offset") {
461 value.getAsInteger(Radix: 0, Result&: reg_info.byte_offset);
462 } else if (name == "encoding") {
463 const Encoding encoding = Args::StringToEncoding(s: value);
464 if (encoding != eEncodingInvalid)
465 reg_info.encoding = encoding;
466 } else if (name == "format") {
467 if (!OptionArgParser::ToFormat(s: value.str().c_str(), format&: reg_info.format, byte_size_ptr: nullptr)
468 .Success())
469 reg_info.format =
470 llvm::StringSwitch<Format>(value)
471 .Case(S: "binary", Value: eFormatBinary)
472 .Case(S: "decimal", Value: eFormatDecimal)
473 .Case(S: "hex", Value: eFormatHex)
474 .Case(S: "float", Value: eFormatFloat)
475 .Case(S: "vector-sint8", Value: eFormatVectorOfSInt8)
476 .Case(S: "vector-uint8", Value: eFormatVectorOfUInt8)
477 .Case(S: "vector-sint16", Value: eFormatVectorOfSInt16)
478 .Case(S: "vector-uint16", Value: eFormatVectorOfUInt16)
479 .Case(S: "vector-sint32", Value: eFormatVectorOfSInt32)
480 .Case(S: "vector-uint32", Value: eFormatVectorOfUInt32)
481 .Case(S: "vector-float32", Value: eFormatVectorOfFloat32)
482 .Case(S: "vector-uint64", Value: eFormatVectorOfUInt64)
483 .Case(S: "vector-uint128", Value: eFormatVectorOfUInt128)
484 .Default(Value: eFormatInvalid);
485 } else if (name == "set") {
486 reg_info.set_name.SetString(value);
487 } else if (name == "gcc" || name == "ehframe") {
488 value.getAsInteger(Radix: 0, Result&: reg_info.regnum_ehframe);
489 } else if (name == "dwarf") {
490 value.getAsInteger(Radix: 0, Result&: reg_info.regnum_dwarf);
491 } else if (name == "generic") {
492 reg_info.regnum_generic = Args::StringToGenericRegister(s: value);
493 } else if (name == "container-regs") {
494 SplitCommaSeparatedRegisterNumberString(comma_separated_register_numbers: value, regnums&: reg_info.value_regs, base: 16);
495 } else if (name == "invalidate-regs") {
496 SplitCommaSeparatedRegisterNumberString(comma_separated_register_numbers: value, regnums&: reg_info.invalidate_regs, base: 16);
497 }
498 }
499
500 assert(reg_info.byte_size != 0);
501 registers.push_back(x: reg_info);
502 } else {
503 break; // ensure exit before reg_num is incremented
504 }
505 } else {
506 break;
507 }
508 }
509
510 if (registers.empty())
511 registers = GetFallbackRegisters(arch_to_use);
512
513 AddRemoteRegisters(registers, arch_to_use);
514}
515
516Status ProcessGDBRemote::DoWillLaunch(lldb_private::Module *module) {
517 return WillLaunchOrAttach();
518}
519
520Status ProcessGDBRemote::DoWillAttachToProcessWithID(lldb::pid_t pid) {
521 return WillLaunchOrAttach();
522}
523
524Status ProcessGDBRemote::DoWillAttachToProcessWithName(const char *process_name,
525 bool wait_for_launch) {
526 return WillLaunchOrAttach();
527}
528
529Status ProcessGDBRemote::DoConnectRemote(llvm::StringRef remote_url) {
530 Log *log = GetLog(mask: GDBRLog::Process);
531
532 Status error(WillLaunchOrAttach());
533 if (error.Fail())
534 return error;
535
536 error = ConnectToDebugserver(host_port: remote_url);
537 if (error.Fail())
538 return error;
539
540 StartAsyncThread();
541
542 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
543 if (pid == LLDB_INVALID_PROCESS_ID) {
544 // We don't have a valid process ID, so note that we are connected and
545 // could now request to launch or attach, or get remote process listings...
546 SetPrivateState(eStateConnected);
547 } else {
548 // We have a valid process
549 SetID(pid);
550 GetThreadList();
551 StringExtractorGDBRemote response;
552 if (m_gdb_comm.GetStopReply(response)) {
553 SetLastStopPacket(response);
554
555 Target &target = GetTarget();
556 if (!target.GetArchitecture().IsValid()) {
557 if (m_gdb_comm.GetProcessArchitecture().IsValid()) {
558 target.SetArchitecture(arch_spec: m_gdb_comm.GetProcessArchitecture());
559 } else {
560 if (m_gdb_comm.GetHostArchitecture().IsValid()) {
561 target.SetArchitecture(arch_spec: m_gdb_comm.GetHostArchitecture());
562 }
563 }
564 }
565
566 const StateType state = SetThreadStopInfo(response);
567 if (state != eStateInvalid) {
568 SetPrivateState(state);
569 } else
570 error = Status::FromErrorStringWithFormat(
571 format: "Process %" PRIu64 " was reported after connecting to "
572 "'%s', but state was not stopped: %s",
573 pid, remote_url.str().c_str(), StateAsCString(state));
574 } else
575 error = Status::FromErrorStringWithFormat(
576 format: "Process %" PRIu64 " was reported after connecting to '%s', "
577 "but no stop reply packet was received",
578 pid, remote_url.str().c_str());
579 }
580
581 LLDB_LOGF(log,
582 "ProcessGDBRemote::%s pid %" PRIu64
583 ": normalizing target architecture initial triple: %s "
584 "(GetTarget().GetArchitecture().IsValid() %s, "
585 "m_gdb_comm.GetHostArchitecture().IsValid(): %s)",
586 __FUNCTION__, GetID(),
587 GetTarget().GetArchitecture().GetTriple().getTriple().c_str(),
588 GetTarget().GetArchitecture().IsValid() ? "true" : "false",
589 m_gdb_comm.GetHostArchitecture().IsValid() ? "true" : "false");
590
591 if (error.Success() && !GetTarget().GetArchitecture().IsValid() &&
592 m_gdb_comm.GetHostArchitecture().IsValid()) {
593 // Prefer the *process'* architecture over that of the *host*, if
594 // available.
595 if (m_gdb_comm.GetProcessArchitecture().IsValid())
596 GetTarget().SetArchitecture(arch_spec: m_gdb_comm.GetProcessArchitecture());
597 else
598 GetTarget().SetArchitecture(arch_spec: m_gdb_comm.GetHostArchitecture());
599 }
600
601 LLDB_LOGF(log,
602 "ProcessGDBRemote::%s pid %" PRIu64
603 ": normalized target architecture triple: %s",
604 __FUNCTION__, GetID(),
605 GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
606
607 return error;
608}
609
610Status ProcessGDBRemote::WillLaunchOrAttach() {
611 Status error;
612 m_stdio_communication.Clear();
613 return error;
614}
615
616// Process Control
617Status ProcessGDBRemote::DoLaunch(lldb_private::Module *exe_module,
618 ProcessLaunchInfo &launch_info) {
619 Log *log = GetLog(mask: GDBRLog::Process);
620 Status error;
621
622 LLDB_LOGF(log, "ProcessGDBRemote::%s() entered", __FUNCTION__);
623
624 uint32_t launch_flags = launch_info.GetFlags().Get();
625 FileSpec stdin_file_spec{};
626 FileSpec stdout_file_spec{};
627 FileSpec stderr_file_spec{};
628 FileSpec working_dir = launch_info.GetWorkingDirectory();
629
630 const FileAction *file_action;
631 file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
632 if (file_action) {
633 if (file_action->GetAction() == FileAction::eFileActionOpen)
634 stdin_file_spec = file_action->GetFileSpec();
635 }
636 file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
637 if (file_action) {
638 if (file_action->GetAction() == FileAction::eFileActionOpen)
639 stdout_file_spec = file_action->GetFileSpec();
640 }
641 file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
642 if (file_action) {
643 if (file_action->GetAction() == FileAction::eFileActionOpen)
644 stderr_file_spec = file_action->GetFileSpec();
645 }
646
647 if (log) {
648 if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
649 LLDB_LOGF(log,
650 "ProcessGDBRemote::%s provided with STDIO paths via "
651 "launch_info: stdin=%s, stdout=%s, stderr=%s",
652 __FUNCTION__,
653 stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
654 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
655 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
656 else
657 LLDB_LOGF(log,
658 "ProcessGDBRemote::%s no STDIO paths given via launch_info",
659 __FUNCTION__);
660 }
661
662 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
663 if (stdin_file_spec || disable_stdio) {
664 // the inferior will be reading stdin from the specified file or stdio is
665 // completely disabled
666 m_stdin_forward = false;
667 } else {
668 m_stdin_forward = true;
669 }
670
671 // ::LogSetBitMask (GDBR_LOG_DEFAULT);
672 // ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE |
673 // LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
674 // LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
675 // ::LogSetLogFile ("/dev/stdout");
676
677 error = EstablishConnectionIfNeeded(process_info: launch_info);
678 if (error.Success()) {
679 PseudoTerminal pty;
680 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
681
682 PlatformSP platform_sp(GetTarget().GetPlatform());
683 if (disable_stdio) {
684 // set to /dev/null unless redirected to a file above
685 if (!stdin_file_spec)
686 stdin_file_spec.SetFile(path: FileSystem::DEV_NULL,
687 style: FileSpec::Style::native);
688 if (!stdout_file_spec)
689 stdout_file_spec.SetFile(path: FileSystem::DEV_NULL,
690 style: FileSpec::Style::native);
691 if (!stderr_file_spec)
692 stderr_file_spec.SetFile(path: FileSystem::DEV_NULL,
693 style: FileSpec::Style::native);
694 } else if (platform_sp && platform_sp->IsHost()) {
695 // If the debugserver is local and we aren't disabling STDIO, lets use
696 // a pseudo terminal to instead of relying on the 'O' packets for stdio
697 // since 'O' packets can really slow down debugging if the inferior
698 // does a lot of output.
699 if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
700 !errorToBool(Err: pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY))) {
701 FileSpec secondary_name(pty.GetSecondaryName());
702
703 if (!stdin_file_spec)
704 stdin_file_spec = secondary_name;
705
706 if (!stdout_file_spec)
707 stdout_file_spec = secondary_name;
708
709 if (!stderr_file_spec)
710 stderr_file_spec = secondary_name;
711 }
712 LLDB_LOGF(
713 log,
714 "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
715 "(IsHost() is true) using secondary: stdin=%s, stdout=%s, "
716 "stderr=%s",
717 __FUNCTION__,
718 stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
719 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
720 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
721 }
722
723 LLDB_LOGF(log,
724 "ProcessGDBRemote::%s final STDIO paths after all "
725 "adjustments: stdin=%s, stdout=%s, stderr=%s",
726 __FUNCTION__,
727 stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
728 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
729 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
730
731 if (stdin_file_spec)
732 m_gdb_comm.SetSTDIN(stdin_file_spec);
733 if (stdout_file_spec)
734 m_gdb_comm.SetSTDOUT(stdout_file_spec);
735 if (stderr_file_spec)
736 m_gdb_comm.SetSTDERR(stderr_file_spec);
737
738 m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
739 m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
740
741 m_gdb_comm.SendLaunchArchPacket(
742 arch: GetTarget().GetArchitecture().GetArchitectureName());
743
744 const char *launch_event_data = launch_info.GetLaunchEventData();
745 if (launch_event_data != nullptr && *launch_event_data != '\0')
746 m_gdb_comm.SendLaunchEventDataPacket(data: launch_event_data);
747
748 if (working_dir) {
749 m_gdb_comm.SetWorkingDir(working_dir);
750 }
751
752 // Send the environment and the program + arguments after we connect
753 m_gdb_comm.SendEnvironment(env: launch_info.GetEnvironment());
754
755 {
756 // Scope for the scoped timeout object
757 GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
758 std::chrono::seconds(10));
759
760 // Since we can't send argv0 separate from the executable path, we need to
761 // make sure to use the actual executable path found in the launch_info...
762 Args args = launch_info.GetArguments();
763 if (FileSpec exe_file = launch_info.GetExecutableFile())
764 args.ReplaceArgumentAtIndex(idx: 0, arg_str: exe_file.GetPath(denormalize: false));
765 if (llvm::Error err = m_gdb_comm.LaunchProcess(args)) {
766 error = Status::FromErrorStringWithFormatv(
767 format: "Cannot launch '{0}': {1}", args: args.GetArgumentAtIndex(idx: 0),
768 args: llvm::fmt_consume(Item: std::move(err)));
769 } else {
770 SetID(m_gdb_comm.GetCurrentProcessID());
771 }
772 }
773
774 if (GetID() == LLDB_INVALID_PROCESS_ID) {
775 LLDB_LOGF(log, "failed to connect to debugserver: %s",
776 error.AsCString());
777 KillDebugserverProcess();
778 return error;
779 }
780
781 StringExtractorGDBRemote response;
782 if (m_gdb_comm.GetStopReply(response)) {
783 SetLastStopPacket(response);
784
785 const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
786
787 if (process_arch.IsValid()) {
788 GetTarget().MergeArchitecture(arch_spec: process_arch);
789 } else {
790 const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
791 if (host_arch.IsValid())
792 GetTarget().MergeArchitecture(arch_spec: host_arch);
793 }
794
795 SetPrivateState(SetThreadStopInfo(response));
796
797 if (!disable_stdio) {
798 if (pty.GetPrimaryFileDescriptor() != PseudoTerminal::invalid_fd)
799 SetSTDIOFileDescriptor(pty.ReleasePrimaryFileDescriptor());
800 }
801 }
802 } else {
803 LLDB_LOGF(log, "failed to connect to debugserver: %s", error.AsCString());
804 }
805 return error;
806}
807
808Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
809 Status error;
810 // Only connect if we have a valid connect URL
811 Log *log = GetLog(mask: GDBRLog::Process);
812
813 if (!connect_url.empty()) {
814 LLDB_LOGF(log, "ProcessGDBRemote::%s Connecting to %s", __FUNCTION__,
815 connect_url.str().c_str());
816 std::unique_ptr<ConnectionFileDescriptor> conn_up(
817 new ConnectionFileDescriptor());
818 if (conn_up) {
819 const uint32_t max_retry_count = 50;
820 uint32_t retry_count = 0;
821 while (!m_gdb_comm.IsConnected()) {
822 if (conn_up->Connect(url: connect_url, error_ptr: &error) == eConnectionStatusSuccess) {
823 m_gdb_comm.SetConnection(std::move(conn_up));
824 break;
825 }
826
827 retry_count++;
828
829 if (retry_count >= max_retry_count)
830 break;
831
832 std::this_thread::sleep_for(rtime: std::chrono::milliseconds(100));
833 }
834 }
835 }
836
837 if (!m_gdb_comm.IsConnected()) {
838 if (error.Success())
839 error = Status::FromErrorString(str: "not connected to remote gdb server");
840 return error;
841 }
842
843 // We always seem to be able to open a connection to a local port so we need
844 // to make sure we can then send data to it. If we can't then we aren't
845 // actually connected to anything, so try and do the handshake with the
846 // remote GDB server and make sure that goes alright.
847 if (!m_gdb_comm.HandshakeWithServer(error_ptr: &error)) {
848 m_gdb_comm.Disconnect();
849 if (error.Success())
850 error = Status::FromErrorString(str: "not connected to remote gdb server");
851 return error;
852 }
853
854 m_gdb_comm.GetEchoSupported();
855 m_gdb_comm.GetThreadSuffixSupported();
856 m_gdb_comm.GetListThreadsInStopReplySupported();
857 m_gdb_comm.GetHostInfo();
858 m_gdb_comm.GetVContSupported(flavor: 'c');
859 m_gdb_comm.GetVAttachOrWaitSupported();
860 m_gdb_comm.EnableErrorStringInPacket();
861
862 // First dispatch any commands from the platform:
863 auto handle_cmds = [&] (const Args &args) -> void {
864 for (const Args::ArgEntry &entry : args) {
865 StringExtractorGDBRemote response;
866 m_gdb_comm.SendPacketAndWaitForResponse(
867 payload: entry.c_str(), response);
868 }
869 };
870
871 PlatformSP platform_sp = GetTarget().GetPlatform();
872 if (platform_sp) {
873 handle_cmds(platform_sp->GetExtraStartupCommands());
874 }
875
876 // Then dispatch any process commands:
877 handle_cmds(GetExtraStartupCommands());
878
879 return error;
880}
881
882void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
883 Log *log = GetLog(mask: GDBRLog::Process);
884 BuildDynamicRegisterInfo(force: false);
885
886 // See if the GDB server supports qHostInfo or qProcessInfo packets. Prefer
887 // qProcessInfo as it will be more specific to our process.
888
889 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
890 if (remote_process_arch.IsValid()) {
891 process_arch = remote_process_arch;
892 LLDB_LOG(log, "gdb-remote had process architecture, using {0} {1}",
893 process_arch.GetArchitectureName(),
894 process_arch.GetTriple().getTriple());
895 } else {
896 process_arch = m_gdb_comm.GetHostArchitecture();
897 LLDB_LOG(log,
898 "gdb-remote did not have process architecture, using gdb-remote "
899 "host architecture {0} {1}",
900 process_arch.GetArchitectureName(),
901 process_arch.GetTriple().getTriple());
902 }
903
904 AddressableBits addressable_bits = m_gdb_comm.GetAddressableBits();
905 SetAddressableBitMasks(addressable_bits);
906
907 if (process_arch.IsValid()) {
908 const ArchSpec &target_arch = GetTarget().GetArchitecture();
909 if (target_arch.IsValid()) {
910 LLDB_LOG(log, "analyzing target arch, currently {0} {1}",
911 target_arch.GetArchitectureName(),
912 target_arch.GetTriple().getTriple());
913
914 // If the remote host is ARM and we have apple as the vendor, then
915 // ARM executables and shared libraries can have mixed ARM
916 // architectures.
917 // You can have an armv6 executable, and if the host is armv7, then the
918 // system will load the best possible architecture for all shared
919 // libraries it has, so we really need to take the remote host
920 // architecture as our defacto architecture in this case.
921
922 if ((process_arch.GetMachine() == llvm::Triple::arm ||
923 process_arch.GetMachine() == llvm::Triple::thumb) &&
924 process_arch.GetTriple().getVendor() == llvm::Triple::Apple) {
925 GetTarget().SetArchitecture(arch_spec: process_arch);
926 LLDB_LOG(log,
927 "remote process is ARM/Apple, "
928 "setting target arch to {0} {1}",
929 process_arch.GetArchitectureName(),
930 process_arch.GetTriple().getTriple());
931 } else {
932 // Fill in what is missing in the triple
933 const llvm::Triple &remote_triple = process_arch.GetTriple();
934 llvm::Triple new_target_triple = target_arch.GetTriple();
935 if (new_target_triple.getVendorName().size() == 0) {
936 new_target_triple.setVendor(remote_triple.getVendor());
937
938 if (new_target_triple.getOSName().size() == 0) {
939 new_target_triple.setOS(remote_triple.getOS());
940
941 if (new_target_triple.getEnvironmentName().size() == 0)
942 new_target_triple.setEnvironment(remote_triple.getEnvironment());
943 }
944
945 ArchSpec new_target_arch = target_arch;
946 new_target_arch.SetTriple(new_target_triple);
947 GetTarget().SetArchitecture(arch_spec: new_target_arch);
948 }
949 }
950
951 LLDB_LOG(log,
952 "final target arch after adjustments for remote architecture: "
953 "{0} {1}",
954 target_arch.GetArchitectureName(),
955 target_arch.GetTriple().getTriple());
956 } else {
957 // The target doesn't have a valid architecture yet, set it from the
958 // architecture we got from the remote GDB server
959 GetTarget().SetArchitecture(arch_spec: process_arch);
960 }
961 }
962
963 // Target and Process are reasonably initailized;
964 // load any binaries we have metadata for / set load address.
965 LoadStubBinaries();
966 MaybeLoadExecutableModule();
967
968 // Find out which StructuredDataPlugins are supported by the debug monitor.
969 // These plugins transmit data over async $J packets.
970 if (StructuredData::Array *supported_packets =
971 m_gdb_comm.GetSupportedStructuredDataPlugins())
972 MapSupportedStructuredDataPlugins(supported_type_names: *supported_packets);
973
974 // If connected to LLDB ("native-signals+"), use signal defs for
975 // the remote platform. If connected to GDB, just use the standard set.
976 if (!m_gdb_comm.UsesNativeSignals()) {
977 SetUnixSignals(std::make_shared<GDBRemoteSignals>());
978 } else {
979 PlatformSP platform_sp = GetTarget().GetPlatform();
980 if (platform_sp && platform_sp->IsConnected())
981 SetUnixSignals(platform_sp->GetUnixSignals());
982 else
983 SetUnixSignals(UnixSignals::Create(arch: GetTarget().GetArchitecture()));
984 }
985}
986
987void ProcessGDBRemote::LoadStubBinaries() {
988 // The remote stub may know about the "main binary" in
989 // the context of a firmware debug session, and can
990 // give us a UUID and an address/slide of where the
991 // binary is loaded in memory.
992 UUID standalone_uuid;
993 addr_t standalone_value;
994 bool standalone_value_is_offset;
995 if (m_gdb_comm.GetProcessStandaloneBinary(uuid&: standalone_uuid, value&: standalone_value,
996 value_is_offset&: standalone_value_is_offset)) {
997 ModuleSP module_sp;
998
999 if (standalone_uuid.IsValid()) {
1000 const bool force_symbol_search = true;
1001 const bool notify = true;
1002 const bool set_address_in_target = true;
1003 const bool allow_memory_image_last_resort = false;
1004 DynamicLoader::LoadBinaryWithUUIDAndAddress(
1005 process: this, name: "", uuid: standalone_uuid, value: standalone_value,
1006 value_is_offset: standalone_value_is_offset, force_symbol_search, notify,
1007 set_address_in_target, allow_memory_image_last_resort);
1008 }
1009 }
1010
1011 // The remote stub may know about a list of binaries to
1012 // force load into the process -- a firmware type situation
1013 // where multiple binaries are present in virtual memory,
1014 // and we are only given the addresses of the binaries.
1015 // Not intended for use with userland debugging, when we use
1016 // a DynamicLoader plugin that knows how to find the loaded
1017 // binaries, and will track updates as binaries are added.
1018
1019 std::vector<addr_t> bin_addrs = m_gdb_comm.GetProcessStandaloneBinaries();
1020 if (bin_addrs.size()) {
1021 UUID uuid;
1022 const bool value_is_slide = false;
1023 for (addr_t addr : bin_addrs) {
1024 const bool notify = true;
1025 // First see if this is a special platform
1026 // binary that may determine the DynamicLoader and
1027 // Platform to be used in this Process and Target.
1028 if (GetTarget()
1029 .GetDebugger()
1030 .GetPlatformList()
1031 .LoadPlatformBinaryAndSetup(process: this, addr, notify))
1032 continue;
1033
1034 const bool force_symbol_search = true;
1035 const bool set_address_in_target = true;
1036 const bool allow_memory_image_last_resort = false;
1037 // Second manually load this binary into the Target.
1038 DynamicLoader::LoadBinaryWithUUIDAndAddress(
1039 process: this, name: llvm::StringRef(), uuid, value: addr, value_is_offset: value_is_slide,
1040 force_symbol_search, notify, set_address_in_target,
1041 allow_memory_image_last_resort);
1042 }
1043 }
1044}
1045
1046void ProcessGDBRemote::MaybeLoadExecutableModule() {
1047 ModuleSP module_sp = GetTarget().GetExecutableModule();
1048 if (!module_sp)
1049 return;
1050
1051 std::optional<QOffsets> offsets = m_gdb_comm.GetQOffsets();
1052 if (!offsets)
1053 return;
1054
1055 bool is_uniform =
1056 size_t(llvm::count(Range&: offsets->offsets, Element: offsets->offsets[0])) ==
1057 offsets->offsets.size();
1058 if (!is_uniform)
1059 return; // TODO: Handle non-uniform responses.
1060
1061 bool changed = false;
1062 module_sp->SetLoadAddress(target&: GetTarget(), value: offsets->offsets[0],
1063 /*value_is_offset=*/true, changed);
1064 if (changed) {
1065 ModuleList list;
1066 list.Append(module_sp);
1067 m_process->GetTarget().ModulesDidLoad(module_list&: list);
1068 }
1069}
1070
1071void ProcessGDBRemote::DidLaunch() {
1072 ArchSpec process_arch;
1073 DidLaunchOrAttach(process_arch);
1074}
1075
1076Status ProcessGDBRemote::DoAttachToProcessWithID(
1077 lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info) {
1078 Log *log = GetLog(mask: GDBRLog::Process);
1079 Status error;
1080
1081 LLDB_LOGF(log, "ProcessGDBRemote::%s()", __FUNCTION__);
1082
1083 // Clear out and clean up from any current state
1084 Clear();
1085 if (attach_pid != LLDB_INVALID_PROCESS_ID) {
1086 error = EstablishConnectionIfNeeded(process_info: attach_info);
1087 if (error.Success()) {
1088 m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
1089
1090 char packet[64];
1091 const int packet_len =
1092 ::snprintf(s: packet, maxlen: sizeof(packet), format: "vAttach;%" PRIx64, attach_pid);
1093 SetID(attach_pid);
1094 auto data_sp =
1095 std::make_shared<EventDataBytes>(args: llvm::StringRef(packet, packet_len));
1096 m_async_broadcaster.BroadcastEvent(event_type: eBroadcastBitAsyncContinue, event_data_sp: data_sp);
1097 } else
1098 SetExitStatus(exit_status: -1, exit_string: error.AsCString());
1099 }
1100
1101 return error;
1102}
1103
1104Status ProcessGDBRemote::DoAttachToProcessWithName(
1105 const char *process_name, const ProcessAttachInfo &attach_info) {
1106 Status error;
1107 // Clear out and clean up from any current state
1108 Clear();
1109
1110 if (process_name && process_name[0]) {
1111 error = EstablishConnectionIfNeeded(process_info: attach_info);
1112 if (error.Success()) {
1113 StreamString packet;
1114
1115 m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
1116
1117 if (attach_info.GetWaitForLaunch()) {
1118 if (!m_gdb_comm.GetVAttachOrWaitSupported()) {
1119 packet.PutCString(cstr: "vAttachWait");
1120 } else {
1121 if (attach_info.GetIgnoreExisting())
1122 packet.PutCString(cstr: "vAttachWait");
1123 else
1124 packet.PutCString(cstr: "vAttachOrWait");
1125 }
1126 } else
1127 packet.PutCString(cstr: "vAttachName");
1128 packet.PutChar(ch: ';');
1129 packet.PutBytesAsRawHex8(src: process_name, src_len: strlen(s: process_name),
1130 src_byte_order: endian::InlHostByteOrder(),
1131 dst_byte_order: endian::InlHostByteOrder());
1132
1133 auto data_sp = std::make_shared<EventDataBytes>(args: packet.GetString());
1134 m_async_broadcaster.BroadcastEvent(event_type: eBroadcastBitAsyncContinue, event_data_sp: data_sp);
1135
1136 } else
1137 SetExitStatus(exit_status: -1, exit_string: error.AsCString());
1138 }
1139 return error;
1140}
1141
1142llvm::Expected<TraceSupportedResponse> ProcessGDBRemote::TraceSupported() {
1143 return m_gdb_comm.SendTraceSupported(interrupt_timeout: GetInterruptTimeout());
1144}
1145
1146llvm::Error ProcessGDBRemote::TraceStop(const TraceStopRequest &request) {
1147 return m_gdb_comm.SendTraceStop(request, interrupt_timeout: GetInterruptTimeout());
1148}
1149
1150llvm::Error ProcessGDBRemote::TraceStart(const llvm::json::Value &request) {
1151 return m_gdb_comm.SendTraceStart(request, interrupt_timeout: GetInterruptTimeout());
1152}
1153
1154llvm::Expected<std::string>
1155ProcessGDBRemote::TraceGetState(llvm::StringRef type) {
1156 return m_gdb_comm.SendTraceGetState(type, interrupt_timeout: GetInterruptTimeout());
1157}
1158
1159llvm::Expected<std::vector<uint8_t>>
1160ProcessGDBRemote::TraceGetBinaryData(const TraceGetBinaryDataRequest &request) {
1161 return m_gdb_comm.SendTraceGetBinaryData(request, interrupt_timeout: GetInterruptTimeout());
1162}
1163
1164void ProcessGDBRemote::DidExit() {
1165 // When we exit, disconnect from the GDB server communications
1166 m_gdb_comm.Disconnect();
1167}
1168
1169void ProcessGDBRemote::DidAttach(ArchSpec &process_arch) {
1170 // If you can figure out what the architecture is, fill it in here.
1171 process_arch.Clear();
1172 DidLaunchOrAttach(process_arch);
1173}
1174
1175Status ProcessGDBRemote::WillResume() {
1176 m_continue_c_tids.clear();
1177 m_continue_C_tids.clear();
1178 m_continue_s_tids.clear();
1179 m_continue_S_tids.clear();
1180 m_jstopinfo_sp.reset();
1181 m_jthreadsinfo_sp.reset();
1182 return Status();
1183}
1184
1185bool ProcessGDBRemote::SupportsReverseDirection() {
1186 return m_gdb_comm.GetReverseStepSupported() ||
1187 m_gdb_comm.GetReverseContinueSupported();
1188}
1189
1190Status ProcessGDBRemote::DoResume(RunDirection direction) {
1191 Status error;
1192 Log *log = GetLog(mask: GDBRLog::Process);
1193 LLDB_LOGF(log, "ProcessGDBRemote::Resume(%s)",
1194 direction == RunDirection::eRunForward ? "" : "reverse");
1195
1196 ListenerSP listener_sp(
1197 Listener::MakeListener(name: "gdb-remote.resume-packet-sent"));
1198 if (listener_sp->StartListeningForEvents(
1199 broadcaster: &m_gdb_comm, event_mask: GDBRemoteClientBase::eBroadcastBitRunPacketSent)) {
1200 listener_sp->StartListeningForEvents(
1201 broadcaster: &m_async_broadcaster,
1202 event_mask: ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit);
1203
1204 const size_t num_threads = GetThreadList().GetSize();
1205
1206 StreamString continue_packet;
1207 bool continue_packet_error = false;
1208 // Number of threads continuing with "c", i.e. continuing without a signal
1209 // to deliver.
1210 const size_t num_continue_c_tids = m_continue_c_tids.size();
1211 // Number of threads continuing with "C", i.e. continuing with a signal to
1212 // deliver.
1213 const size_t num_continue_C_tids = m_continue_C_tids.size();
1214 // Number of threads continuing with "s", i.e. single-stepping.
1215 const size_t num_continue_s_tids = m_continue_s_tids.size();
1216 // Number of threads continuing with "S", i.e. single-stepping with a signal
1217 // to deliver.
1218 const size_t num_continue_S_tids = m_continue_S_tids.size();
1219 if (direction == RunDirection::eRunForward &&
1220 m_gdb_comm.HasAnyVContSupport()) {
1221 std::string pid_prefix;
1222 if (m_gdb_comm.GetMultiprocessSupported())
1223 pid_prefix = llvm::formatv(Fmt: "p{0:x-}.", Vals: GetID());
1224
1225 if (num_continue_c_tids == num_threads ||
1226 (m_continue_c_tids.empty() && m_continue_C_tids.empty() &&
1227 m_continue_s_tids.empty() && m_continue_S_tids.empty())) {
1228 // All threads are continuing
1229 if (m_gdb_comm.GetMultiprocessSupported())
1230 continue_packet.Format(format: "vCont;c:{0}-1", args&: pid_prefix);
1231 else
1232 continue_packet.PutCString(cstr: "c");
1233 } else {
1234 continue_packet.PutCString(cstr: "vCont");
1235
1236 if (!m_continue_c_tids.empty()) {
1237 if (m_gdb_comm.GetVContSupported(flavor: 'c')) {
1238 for (tid_collection::const_iterator
1239 t_pos = m_continue_c_tids.begin(),
1240 t_end = m_continue_c_tids.end();
1241 t_pos != t_end; ++t_pos)
1242 continue_packet.Format(format: ";c:{0}{1:x-}", args&: pid_prefix, args: *t_pos);
1243 } else
1244 continue_packet_error = true;
1245 }
1246
1247 if (!continue_packet_error && !m_continue_C_tids.empty()) {
1248 if (m_gdb_comm.GetVContSupported(flavor: 'C')) {
1249 for (tid_sig_collection::const_iterator
1250 s_pos = m_continue_C_tids.begin(),
1251 s_end = m_continue_C_tids.end();
1252 s_pos != s_end; ++s_pos)
1253 continue_packet.Format(format: ";C{0:x-2}:{1}{2:x-}", args: s_pos->second,
1254 args&: pid_prefix, args: s_pos->first);
1255 } else
1256 continue_packet_error = true;
1257 }
1258
1259 if (!continue_packet_error && !m_continue_s_tids.empty()) {
1260 if (m_gdb_comm.GetVContSupported(flavor: 's')) {
1261 for (tid_collection::const_iterator
1262 t_pos = m_continue_s_tids.begin(),
1263 t_end = m_continue_s_tids.end();
1264 t_pos != t_end; ++t_pos)
1265 continue_packet.Format(format: ";s:{0}{1:x-}", args&: pid_prefix, args: *t_pos);
1266 } else
1267 continue_packet_error = true;
1268 }
1269
1270 if (!continue_packet_error && !m_continue_S_tids.empty()) {
1271 if (m_gdb_comm.GetVContSupported(flavor: 'S')) {
1272 for (tid_sig_collection::const_iterator
1273 s_pos = m_continue_S_tids.begin(),
1274 s_end = m_continue_S_tids.end();
1275 s_pos != s_end; ++s_pos)
1276 continue_packet.Format(format: ";S{0:x-2}:{1}{2:x-}", args: s_pos->second,
1277 args&: pid_prefix, args: s_pos->first);
1278 } else
1279 continue_packet_error = true;
1280 }
1281
1282 if (continue_packet_error)
1283 continue_packet.Clear();
1284 }
1285 } else
1286 continue_packet_error = true;
1287
1288 if (direction == RunDirection::eRunForward && continue_packet_error) {
1289 // Either no vCont support, or we tried to use part of the vCont packet
1290 // that wasn't supported by the remote GDB server. We need to try and
1291 // make a simple packet that can do our continue.
1292 if (num_continue_c_tids > 0) {
1293 if (num_continue_c_tids == num_threads) {
1294 // All threads are resuming...
1295 m_gdb_comm.SetCurrentThreadForRun(tid: -1);
1296 continue_packet.PutChar(ch: 'c');
1297 continue_packet_error = false;
1298 } else if (num_continue_c_tids == 1 && num_continue_C_tids == 0 &&
1299 num_continue_s_tids == 0 && num_continue_S_tids == 0) {
1300 // Only one thread is continuing
1301 m_gdb_comm.SetCurrentThreadForRun(tid: m_continue_c_tids.front());
1302 continue_packet.PutChar(ch: 'c');
1303 continue_packet_error = false;
1304 }
1305 }
1306
1307 if (continue_packet_error && num_continue_C_tids > 0) {
1308 if ((num_continue_C_tids + num_continue_c_tids) == num_threads &&
1309 num_continue_C_tids > 0 && num_continue_s_tids == 0 &&
1310 num_continue_S_tids == 0) {
1311 const int continue_signo = m_continue_C_tids.front().second;
1312 // Only one thread is continuing
1313 if (num_continue_C_tids > 1) {
1314 // More that one thread with a signal, yet we don't have vCont
1315 // support and we are being asked to resume each thread with a
1316 // signal, we need to make sure they are all the same signal, or we
1317 // can't issue the continue accurately with the current support...
1318 if (num_continue_C_tids > 1) {
1319 continue_packet_error = false;
1320 for (size_t i = 1; i < m_continue_C_tids.size(); ++i) {
1321 if (m_continue_C_tids[i].second != continue_signo)
1322 continue_packet_error = true;
1323 }
1324 }
1325 if (!continue_packet_error)
1326 m_gdb_comm.SetCurrentThreadForRun(tid: -1);
1327 } else {
1328 // Set the continue thread ID
1329 continue_packet_error = false;
1330 m_gdb_comm.SetCurrentThreadForRun(tid: m_continue_C_tids.front().first);
1331 }
1332 if (!continue_packet_error) {
1333 // Add threads continuing with the same signo...
1334 continue_packet.Printf(format: "C%2.2x", continue_signo);
1335 }
1336 }
1337 }
1338
1339 if (continue_packet_error && num_continue_s_tids > 0) {
1340 if (num_continue_s_tids == num_threads) {
1341 // All threads are resuming...
1342 m_gdb_comm.SetCurrentThreadForRun(tid: -1);
1343
1344 continue_packet.PutChar(ch: 's');
1345
1346 continue_packet_error = false;
1347 } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1348 num_continue_s_tids == 1 && num_continue_S_tids == 0) {
1349 // Only one thread is stepping
1350 m_gdb_comm.SetCurrentThreadForRun(tid: m_continue_s_tids.front());
1351 continue_packet.PutChar(ch: 's');
1352 continue_packet_error = false;
1353 }
1354 }
1355
1356 if (!continue_packet_error && num_continue_S_tids > 0) {
1357 if (num_continue_S_tids == num_threads) {
1358 const int step_signo = m_continue_S_tids.front().second;
1359 // Are all threads trying to step with the same signal?
1360 continue_packet_error = false;
1361 if (num_continue_S_tids > 1) {
1362 for (size_t i = 1; i < num_threads; ++i) {
1363 if (m_continue_S_tids[i].second != step_signo)
1364 continue_packet_error = true;
1365 }
1366 }
1367 if (!continue_packet_error) {
1368 // Add threads stepping with the same signo...
1369 m_gdb_comm.SetCurrentThreadForRun(tid: -1);
1370 continue_packet.Printf(format: "S%2.2x", step_signo);
1371 }
1372 } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1373 num_continue_s_tids == 0 && num_continue_S_tids == 1) {
1374 // Only one thread is stepping with signal
1375 m_gdb_comm.SetCurrentThreadForRun(tid: m_continue_S_tids.front().first);
1376 continue_packet.Printf(format: "S%2.2x", m_continue_S_tids.front().second);
1377 continue_packet_error = false;
1378 }
1379 }
1380 }
1381
1382 if (direction == RunDirection::eRunReverse) {
1383 if (num_continue_s_tids > 0 || num_continue_S_tids > 0) {
1384 if (!m_gdb_comm.GetReverseStepSupported()) {
1385 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: target does not "
1386 "support reverse-stepping");
1387 return Status::FromErrorString(
1388 str: "target does not support reverse-stepping");
1389 }
1390
1391 if (num_continue_S_tids > 0) {
1392 LLDB_LOGF(
1393 log,
1394 "ProcessGDBRemote::DoResume: Signals not supported in reverse");
1395 return Status::FromErrorString(
1396 str: "can't deliver signals while running in reverse");
1397 }
1398
1399 if (num_continue_s_tids > 1) {
1400 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: can't step multiple "
1401 "threads in reverse");
1402 return Status::FromErrorString(
1403 str: "can't step multiple threads while reverse-stepping");
1404 }
1405
1406 m_gdb_comm.SetCurrentThreadForRun(tid: m_continue_s_tids.front());
1407 continue_packet.PutCString(cstr: "bs");
1408 } else {
1409 if (!m_gdb_comm.GetReverseContinueSupported()) {
1410 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: target does not "
1411 "support reverse-continue");
1412 return Status::FromErrorString(
1413 str: "target does not support reverse execution of processes");
1414 }
1415
1416 if (num_continue_C_tids > 0) {
1417 LLDB_LOGF(
1418 log,
1419 "ProcessGDBRemote::DoResume: Signals not supported in reverse");
1420 return Status::FromErrorString(
1421 str: "can't deliver signals while running in reverse");
1422 }
1423
1424 // All threads continue whether requested or not ---
1425 // we can't change how threads ran in the past.
1426 continue_packet.PutCString(cstr: "bc");
1427 }
1428
1429 continue_packet_error = false;
1430 }
1431
1432 if (continue_packet_error) {
1433 return Status::FromErrorString(
1434 str: "can't make continue packet for this resume");
1435 } else {
1436 EventSP event_sp;
1437 if (!m_async_thread.IsJoinable()) {
1438 error = Status::FromErrorString(
1439 str: "Trying to resume but the async thread is dead.");
1440 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: Trying to resume but the "
1441 "async thread is dead.");
1442 return error;
1443 }
1444
1445 auto data_sp =
1446 std::make_shared<EventDataBytes>(args: continue_packet.GetString());
1447 m_async_broadcaster.BroadcastEvent(event_type: eBroadcastBitAsyncContinue, event_data_sp: data_sp);
1448
1449 if (!listener_sp->GetEvent(event_sp, timeout: ResumeTimeout())) {
1450 error = Status::FromErrorString(str: "Resume timed out.");
1451 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: Resume timed out.");
1452 } else if (event_sp->BroadcasterIs(broadcaster: &m_async_broadcaster)) {
1453 error = Status::FromErrorString(
1454 str: "Broadcast continue, but the async thread was "
1455 "killed before we got an ack back.");
1456 LLDB_LOGF(log,
1457 "ProcessGDBRemote::DoResume: Broadcast continue, but the "
1458 "async thread was killed before we got an ack back.");
1459 return error;
1460 }
1461 }
1462 }
1463
1464 return error;
1465}
1466
1467void ProcessGDBRemote::ClearThreadIDList() {
1468 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1469 m_thread_ids.clear();
1470 m_thread_pcs.clear();
1471}
1472
1473size_t ProcessGDBRemote::UpdateThreadIDsFromStopReplyThreadsValue(
1474 llvm::StringRef value) {
1475 m_thread_ids.clear();
1476 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
1477 StringExtractorGDBRemote thread_ids{value};
1478
1479 do {
1480 auto pid_tid = thread_ids.GetPidTid(default_pid: pid);
1481 if (pid_tid && pid_tid->first == pid) {
1482 lldb::tid_t tid = pid_tid->second;
1483 if (tid != LLDB_INVALID_THREAD_ID &&
1484 tid != StringExtractorGDBRemote::AllProcesses)
1485 m_thread_ids.push_back(x: tid);
1486 }
1487 } while (thread_ids.GetChar() == ',');
1488
1489 return m_thread_ids.size();
1490}
1491
1492size_t ProcessGDBRemote::UpdateThreadPCsFromStopReplyThreadsValue(
1493 llvm::StringRef value) {
1494 m_thread_pcs.clear();
1495 for (llvm::StringRef x : llvm::split(Str: value, Separator: ',')) {
1496 lldb::addr_t pc;
1497 if (llvm::to_integer(S: x, Num&: pc, Base: 16))
1498 m_thread_pcs.push_back(x: pc);
1499 }
1500 return m_thread_pcs.size();
1501}
1502
1503bool ProcessGDBRemote::UpdateThreadIDList() {
1504 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1505
1506 if (m_jthreadsinfo_sp) {
1507 // If we have the JSON threads info, we can get the thread list from that
1508 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
1509 if (thread_infos && thread_infos->GetSize() > 0) {
1510 m_thread_ids.clear();
1511 m_thread_pcs.clear();
1512 thread_infos->ForEach(foreach_callback: [this](StructuredData::Object *object) -> bool {
1513 StructuredData::Dictionary *thread_dict = object->GetAsDictionary();
1514 if (thread_dict) {
1515 // Set the thread stop info from the JSON dictionary
1516 SetThreadStopInfo(thread_dict);
1517 lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
1518 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>(key: "tid", result&: tid))
1519 m_thread_ids.push_back(x: tid);
1520 }
1521 return true; // Keep iterating through all thread_info objects
1522 });
1523 }
1524 if (!m_thread_ids.empty())
1525 return true;
1526 } else {
1527 // See if we can get the thread IDs from the current stop reply packets
1528 // that might contain a "threads" key/value pair
1529
1530 if (m_last_stop_packet) {
1531 // Get the thread stop info
1532 StringExtractorGDBRemote &stop_info = *m_last_stop_packet;
1533 const std::string &stop_info_str = std::string(stop_info.GetStringRef());
1534
1535 m_thread_pcs.clear();
1536 const size_t thread_pcs_pos = stop_info_str.find(s: ";thread-pcs:");
1537 if (thread_pcs_pos != std::string::npos) {
1538 const size_t start = thread_pcs_pos + strlen(s: ";thread-pcs:");
1539 const size_t end = stop_info_str.find(c: ';', pos: start);
1540 if (end != std::string::npos) {
1541 std::string value = stop_info_str.substr(pos: start, n: end - start);
1542 UpdateThreadPCsFromStopReplyThreadsValue(value);
1543 }
1544 }
1545
1546 const size_t threads_pos = stop_info_str.find(s: ";threads:");
1547 if (threads_pos != std::string::npos) {
1548 const size_t start = threads_pos + strlen(s: ";threads:");
1549 const size_t end = stop_info_str.find(c: ';', pos: start);
1550 if (end != std::string::npos) {
1551 std::string value = stop_info_str.substr(pos: start, n: end - start);
1552 if (UpdateThreadIDsFromStopReplyThreadsValue(value))
1553 return true;
1554 }
1555 }
1556 }
1557 }
1558
1559 bool sequence_mutex_unavailable = false;
1560 m_gdb_comm.GetCurrentThreadIDs(thread_ids&: m_thread_ids, sequence_mutex_unavailable);
1561 if (sequence_mutex_unavailable) {
1562 return false; // We just didn't get the list
1563 }
1564 return true;
1565}
1566
1567bool ProcessGDBRemote::DoUpdateThreadList(ThreadList &old_thread_list,
1568 ThreadList &new_thread_list) {
1569 // locker will keep a mutex locked until it goes out of scope
1570 Log *log = GetLog(mask: GDBRLog::Thread);
1571 LLDB_LOGV(log, "pid = {0}", GetID());
1572
1573 size_t num_thread_ids = m_thread_ids.size();
1574 // The "m_thread_ids" thread ID list should always be updated after each stop
1575 // reply packet, but in case it isn't, update it here.
1576 if (num_thread_ids == 0) {
1577 if (!UpdateThreadIDList())
1578 return false;
1579 num_thread_ids = m_thread_ids.size();
1580 }
1581
1582 ThreadList old_thread_list_copy(old_thread_list);
1583 if (num_thread_ids > 0) {
1584 for (size_t i = 0; i < num_thread_ids; ++i) {
1585 lldb::tid_t tid = m_thread_ids[i];
1586 ThreadSP thread_sp(
1587 old_thread_list_copy.RemoveThreadByProtocolID(tid, can_update: false));
1588 if (!thread_sp) {
1589 thread_sp = std::make_shared<ThreadGDBRemote>(args&: *this, args&: tid);
1590 LLDB_LOGV(log, "Making new thread: {0} for thread ID: {1:x}.",
1591 thread_sp.get(), thread_sp->GetID());
1592 } else {
1593 LLDB_LOGV(log, "Found old thread: {0} for thread ID: {1:x}.",
1594 thread_sp.get(), thread_sp->GetID());
1595 }
1596
1597 SetThreadPc(thread_sp, index: i);
1598 new_thread_list.AddThreadSortedByIndexID(thread_sp);
1599 }
1600 }
1601
1602 // Whatever that is left in old_thread_list_copy are not present in
1603 // new_thread_list. Remove non-existent threads from internal id table.
1604 size_t old_num_thread_ids = old_thread_list_copy.GetSize(can_update: false);
1605 for (size_t i = 0; i < old_num_thread_ids; i++) {
1606 ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(idx: i, can_update: false));
1607 if (old_thread_sp) {
1608 lldb::tid_t old_thread_id = old_thread_sp->GetProtocolID();
1609 m_thread_id_to_index_id_map.erase(x: old_thread_id);
1610 }
1611 }
1612
1613 return true;
1614}
1615
1616void ProcessGDBRemote::SetThreadPc(const ThreadSP &thread_sp, uint64_t index) {
1617 if (m_thread_ids.size() == m_thread_pcs.size() && thread_sp.get() &&
1618 GetByteOrder() != eByteOrderInvalid) {
1619 ThreadGDBRemote *gdb_thread =
1620 static_cast<ThreadGDBRemote *>(thread_sp.get());
1621 RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
1622 if (reg_ctx_sp) {
1623 uint32_t pc_regnum = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1624 kind: eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1625 if (pc_regnum != LLDB_INVALID_REGNUM) {
1626 gdb_thread->PrivateSetRegisterValue(reg: pc_regnum, regval: m_thread_pcs[index]);
1627 }
1628 }
1629 }
1630}
1631
1632bool ProcessGDBRemote::GetThreadStopInfoFromJSON(
1633 ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp) {
1634 // See if we got thread stop infos for all threads via the "jThreadsInfo"
1635 // packet
1636 if (thread_infos_sp) {
1637 StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray();
1638 if (thread_infos) {
1639 lldb::tid_t tid;
1640 const size_t n = thread_infos->GetSize();
1641 for (size_t i = 0; i < n; ++i) {
1642 StructuredData::Dictionary *thread_dict =
1643 thread_infos->GetItemAtIndex(idx: i)->GetAsDictionary();
1644 if (thread_dict) {
1645 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>(
1646 key: "tid", result&: tid, LLDB_INVALID_THREAD_ID)) {
1647 if (tid == thread->GetID())
1648 return (bool)SetThreadStopInfo(thread_dict);
1649 }
1650 }
1651 }
1652 }
1653 }
1654 return false;
1655}
1656
1657bool ProcessGDBRemote::CalculateThreadStopInfo(ThreadGDBRemote *thread) {
1658 // See if we got thread stop infos for all threads via the "jThreadsInfo"
1659 // packet
1660 if (GetThreadStopInfoFromJSON(thread, thread_infos_sp: m_jthreadsinfo_sp))
1661 return true;
1662
1663 // See if we got thread stop info for any threads valid stop info reasons
1664 // threads via the "jstopinfo" packet stop reply packet key/value pair?
1665 if (m_jstopinfo_sp) {
1666 // If we have "jstopinfo" then we have stop descriptions for all threads
1667 // that have stop reasons, and if there is no entry for a thread, then it
1668 // has no stop reason.
1669 if (!GetThreadStopInfoFromJSON(thread, thread_infos_sp: m_jstopinfo_sp))
1670 thread->SetStopInfo(StopInfoSP());
1671 return true;
1672 }
1673
1674 // Fall back to using the qThreadStopInfo packet
1675 StringExtractorGDBRemote stop_packet;
1676 if (GetGDBRemote().GetThreadStopInfo(tid: thread->GetProtocolID(), response&: stop_packet))
1677 return SetThreadStopInfo(stop_packet) == eStateStopped;
1678 return false;
1679}
1680
1681void ProcessGDBRemote::ParseExpeditedRegisters(
1682 ExpeditedRegisterMap &expedited_register_map, ThreadSP thread_sp) {
1683 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *>(thread_sp.get());
1684 RegisterContextSP gdb_reg_ctx_sp(gdb_thread->GetRegisterContext());
1685
1686 for (const auto &pair : expedited_register_map) {
1687 StringExtractor reg_value_extractor(pair.second);
1688 WritableDataBufferSP buffer_sp(
1689 new DataBufferHeap(reg_value_extractor.GetStringRef().size() / 2, 0));
1690 reg_value_extractor.GetHexBytes(dest: buffer_sp->GetData(), fail_fill_value: '\xcc');
1691 uint32_t lldb_regnum = gdb_reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1692 kind: eRegisterKindProcessPlugin, num: pair.first);
1693 gdb_thread->PrivateSetRegisterValue(reg: lldb_regnum, data: buffer_sp->GetData());
1694 }
1695}
1696
1697ThreadSP ProcessGDBRemote::SetThreadStopInfo(
1698 lldb::tid_t tid, ExpeditedRegisterMap &expedited_register_map,
1699 uint8_t signo, const std::string &thread_name, const std::string &reason,
1700 const std::string &description, uint32_t exc_type,
1701 const std::vector<addr_t> &exc_data, addr_t thread_dispatch_qaddr,
1702 bool queue_vars_valid, // Set to true if queue_name, queue_kind and
1703 // queue_serial are valid
1704 LazyBool associated_with_dispatch_queue, addr_t dispatch_queue_t,
1705 std::string &queue_name, QueueKind queue_kind, uint64_t queue_serial) {
1706
1707 if (tid == LLDB_INVALID_THREAD_ID)
1708 return nullptr;
1709
1710 ThreadSP thread_sp;
1711 // Scope for "locker" below
1712 {
1713 // m_thread_list_real does have its own mutex, but we need to hold onto the
1714 // mutex between the call to m_thread_list_real.FindThreadByID(...) and the
1715 // m_thread_list_real.AddThread(...) so it doesn't change on us
1716 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1717 thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, can_update: false);
1718
1719 if (!thread_sp) {
1720 // Create the thread if we need to
1721 thread_sp = std::make_shared<ThreadGDBRemote>(args&: *this, args&: tid);
1722 m_thread_list_real.AddThread(thread_sp);
1723 }
1724 }
1725
1726 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *>(thread_sp.get());
1727 RegisterContextSP reg_ctx_sp(gdb_thread->GetRegisterContext());
1728
1729 reg_ctx_sp->InvalidateIfNeeded(force: true);
1730
1731 auto iter = llvm::find(Range&: m_thread_ids, Val: tid);
1732 if (iter != m_thread_ids.end())
1733 SetThreadPc(thread_sp, index: iter - m_thread_ids.begin());
1734
1735 ParseExpeditedRegisters(expedited_register_map, thread_sp);
1736
1737 if (reg_ctx_sp->ReconfigureRegisterInfo()) {
1738 // Now we have changed the offsets of all the registers, so the values
1739 // will be corrupted.
1740 reg_ctx_sp->InvalidateAllRegisters();
1741 // Expedited registers values will never contain registers that would be
1742 // resized by a reconfigure. So we are safe to continue using these
1743 // values.
1744 ParseExpeditedRegisters(expedited_register_map, thread_sp);
1745 }
1746
1747 thread_sp->SetName(thread_name.empty() ? nullptr : thread_name.c_str());
1748
1749 gdb_thread->SetThreadDispatchQAddr(thread_dispatch_qaddr);
1750 // Check if the GDB server was able to provide the queue name, kind and serial
1751 // number
1752 if (queue_vars_valid)
1753 gdb_thread->SetQueueInfo(queue_name: std::move(queue_name), queue_kind, queue_serial,
1754 dispatch_queue_t, associated_with_libdispatch_queue: associated_with_dispatch_queue);
1755 else
1756 gdb_thread->ClearQueueInfo();
1757
1758 gdb_thread->SetAssociatedWithLibdispatchQueue(associated_with_dispatch_queue);
1759
1760 if (dispatch_queue_t != LLDB_INVALID_ADDRESS)
1761 gdb_thread->SetQueueLibdispatchQueueAddress(dispatch_queue_t);
1762
1763 // Make sure we update our thread stop reason just once, but don't overwrite
1764 // the stop info for threads that haven't moved:
1765 StopInfoSP current_stop_info_sp = thread_sp->GetPrivateStopInfo(calculate: false);
1766 if (thread_sp->GetTemporaryResumeState() == eStateSuspended &&
1767 current_stop_info_sp) {
1768 thread_sp->SetStopInfo(current_stop_info_sp);
1769 return thread_sp;
1770 }
1771
1772 if (!thread_sp->StopInfoIsUpToDate()) {
1773 thread_sp->SetStopInfo(StopInfoSP());
1774
1775 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1776 BreakpointSiteSP bp_site_sp =
1777 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(addr: pc);
1778 if (bp_site_sp && bp_site_sp->IsEnabled())
1779 thread_sp->SetThreadStoppedAtUnexecutedBP(pc);
1780
1781 if (exc_type != 0) {
1782 // For thread plan async interrupt, creating stop info on the
1783 // original async interrupt request thread instead. If interrupt thread
1784 // does not exist anymore we fallback to current signal receiving thread
1785 // instead.
1786 ThreadSP interrupt_thread;
1787 if (m_interrupt_tid != LLDB_INVALID_THREAD_ID)
1788 interrupt_thread = HandleThreadAsyncInterrupt(signo, description);
1789 if (interrupt_thread)
1790 thread_sp = interrupt_thread;
1791 else {
1792 const size_t exc_data_size = exc_data.size();
1793 thread_sp->SetStopInfo(
1794 StopInfoMachException::CreateStopReasonWithMachException(
1795 thread&: *thread_sp, exc_type, exc_data_count: exc_data_size,
1796 exc_code: exc_data_size >= 1 ? exc_data[0] : 0,
1797 exc_sub_code: exc_data_size >= 2 ? exc_data[1] : 0,
1798 exc_sub_sub_code: exc_data_size >= 3 ? exc_data[2] : 0));
1799 }
1800 } else {
1801 bool handled = false;
1802 bool did_exec = false;
1803 // debugserver can send reason = "none" which is equivalent
1804 // to no reason.
1805 if (!reason.empty() && reason != "none") {
1806 if (reason == "trace") {
1807 thread_sp->SetStopInfo(StopInfo::CreateStopReasonToTrace(thread&: *thread_sp));
1808 handled = true;
1809 } else if (reason == "breakpoint") {
1810 thread_sp->SetThreadHitBreakpointSite();
1811 if (bp_site_sp) {
1812 // If the breakpoint is for this thread, then we'll report the hit,
1813 // but if it is for another thread, we can just report no reason.
1814 // We don't need to worry about stepping over the breakpoint here,
1815 // that will be taken care of when the thread resumes and notices
1816 // that there's a breakpoint under the pc.
1817 handled = true;
1818 if (bp_site_sp->ValidForThisThread(thread&: *thread_sp)) {
1819 thread_sp->SetStopInfo(
1820 StopInfo::CreateStopReasonWithBreakpointSiteID(
1821 thread&: *thread_sp, break_id: bp_site_sp->GetID()));
1822 } else {
1823 StopInfoSP invalid_stop_info_sp;
1824 thread_sp->SetStopInfo(invalid_stop_info_sp);
1825 }
1826 }
1827 } else if (reason == "trap") {
1828 // Let the trap just use the standard signal stop reason below...
1829 } else if (reason == "watchpoint") {
1830 // We will have between 1 and 3 fields in the description.
1831 //
1832 // \a wp_addr which is the original start address that
1833 // lldb requested be watched, or an address that the
1834 // hardware reported. This address should be within the
1835 // range of a currently active watchpoint region - lldb
1836 // should be able to find a watchpoint with this address.
1837 //
1838 // \a wp_index is the hardware watchpoint register number.
1839 //
1840 // \a wp_hit_addr is the actual address reported by the hardware,
1841 // which may be outside the range of a region we are watching.
1842 //
1843 // On MIPS, we may get a false watchpoint exception where an
1844 // access to the same 8 byte granule as a watchpoint will trigger,
1845 // even if the access was not within the range of the watched
1846 // region. When we get a \a wp_hit_addr outside the range of any
1847 // set watchpoint, continue execution without making it visible to
1848 // the user.
1849 //
1850 // On ARM, a related issue where a large access that starts
1851 // before the watched region (and extends into the watched
1852 // region) may report a hit address before the watched region.
1853 // lldb will not find the "nearest" watchpoint to
1854 // disable/step/re-enable it, so one of the valid watchpoint
1855 // addresses should be provided as \a wp_addr.
1856 StringExtractor desc_extractor(description.c_str());
1857 // FIXME NativeThreadLinux::SetStoppedByWatchpoint sends this
1858 // up as
1859 // <address within wp range> <wp hw index> <actual accessed addr>
1860 // but this is not reading the <wp hw index>. Seems like it
1861 // wouldn't work on MIPS, where that third field is important.
1862 addr_t wp_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
1863 addr_t wp_hit_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
1864 watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
1865 bool silently_continue = false;
1866 WatchpointResourceSP wp_resource_sp;
1867 if (wp_hit_addr != LLDB_INVALID_ADDRESS) {
1868 wp_resource_sp =
1869 m_watchpoint_resource_list.FindByAddress(addr: wp_hit_addr);
1870 // On MIPS, \a wp_hit_addr outside the range of a watched
1871 // region means we should silently continue, it is a false hit.
1872 ArchSpec::Core core = GetTarget().GetArchitecture().GetCore();
1873 if (!wp_resource_sp && core >= ArchSpec::kCore_mips_first &&
1874 core <= ArchSpec::kCore_mips_last)
1875 silently_continue = true;
1876 }
1877 if (!wp_resource_sp && wp_addr != LLDB_INVALID_ADDRESS)
1878 wp_resource_sp = m_watchpoint_resource_list.FindByAddress(addr: wp_addr);
1879 if (!wp_resource_sp) {
1880 Log *log(GetLog(mask: GDBRLog::Watchpoints));
1881 LLDB_LOGF(log, "failed to find watchpoint");
1882 watch_id = LLDB_INVALID_SITE_ID;
1883 } else {
1884 // LWP_TODO: This is hardcoding a single Watchpoint in a
1885 // Resource, need to add
1886 // StopInfo::CreateStopReasonWithWatchpointResource which
1887 // represents all watchpoints that were tripped at this stop.
1888 watch_id = wp_resource_sp->GetConstituentAtIndex(idx: 0)->GetID();
1889 }
1890 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithWatchpointID(
1891 thread&: *thread_sp, watch_id, silently_continue));
1892 handled = true;
1893 } else if (reason == "exception") {
1894 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
1895 thread&: *thread_sp, description: description.c_str()));
1896 handled = true;
1897 } else if (reason == "history boundary") {
1898 thread_sp->SetStopInfo(StopInfo::CreateStopReasonHistoryBoundary(
1899 thread&: *thread_sp, description: description.c_str()));
1900 handled = true;
1901 } else if (reason == "exec") {
1902 did_exec = true;
1903 thread_sp->SetStopInfo(
1904 StopInfo::CreateStopReasonWithExec(thread&: *thread_sp));
1905 handled = true;
1906 } else if (reason == "processor trace") {
1907 thread_sp->SetStopInfo(StopInfo::CreateStopReasonProcessorTrace(
1908 thread&: *thread_sp, description: description.c_str()));
1909 } else if (reason == "fork") {
1910 StringExtractor desc_extractor(description.c_str());
1911 lldb::pid_t child_pid =
1912 desc_extractor.GetU64(LLDB_INVALID_PROCESS_ID);
1913 lldb::tid_t child_tid = desc_extractor.GetU64(LLDB_INVALID_THREAD_ID);
1914 thread_sp->SetStopInfo(
1915 StopInfo::CreateStopReasonFork(thread&: *thread_sp, child_pid, child_tid));
1916 handled = true;
1917 } else if (reason == "vfork") {
1918 StringExtractor desc_extractor(description.c_str());
1919 lldb::pid_t child_pid =
1920 desc_extractor.GetU64(LLDB_INVALID_PROCESS_ID);
1921 lldb::tid_t child_tid = desc_extractor.GetU64(LLDB_INVALID_THREAD_ID);
1922 thread_sp->SetStopInfo(StopInfo::CreateStopReasonVFork(
1923 thread&: *thread_sp, child_pid, child_tid));
1924 handled = true;
1925 } else if (reason == "vforkdone") {
1926 thread_sp->SetStopInfo(
1927 StopInfo::CreateStopReasonVForkDone(thread&: *thread_sp));
1928 handled = true;
1929 }
1930 }
1931
1932 if (!handled && signo && !did_exec) {
1933 if (signo == SIGTRAP) {
1934 // Currently we are going to assume SIGTRAP means we are either
1935 // hitting a breakpoint or hardware single stepping.
1936
1937 // We can't disambiguate between stepping-to-a-breakpointsite and
1938 // hitting-a-breakpointsite.
1939 //
1940 // A user can instruction-step, and be stopped at a BreakpointSite.
1941 // Or a user can be sitting at a BreakpointSite,
1942 // instruction-step which hits the breakpoint and the pc does not
1943 // advance.
1944 //
1945 // In both cases, we're at a BreakpointSite when stopped, and
1946 // the resume state was eStateStepping.
1947
1948 // Assume if we're at a BreakpointSite, we hit it.
1949 handled = true;
1950 addr_t pc =
1951 thread_sp->GetRegisterContext()->GetPC() + m_breakpoint_pc_offset;
1952 BreakpointSiteSP bp_site_sp =
1953 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
1954 addr: pc);
1955
1956 // We can't know if we hit it or not. So if we are stopped at
1957 // a BreakpointSite, assume we hit it, and should step past the
1958 // breakpoint when we resume. This is contrary to how we handle
1959 // BreakpointSites in any other location, but we can't know for
1960 // sure what happened so it's a reasonable default.
1961 if (bp_site_sp) {
1962 if (bp_site_sp->IsEnabled())
1963 thread_sp->SetThreadHitBreakpointSite();
1964
1965 if (bp_site_sp->ValidForThisThread(thread&: *thread_sp)) {
1966 if (m_breakpoint_pc_offset != 0)
1967 thread_sp->GetRegisterContext()->SetPC(pc);
1968 thread_sp->SetStopInfo(
1969 StopInfo::CreateStopReasonWithBreakpointSiteID(
1970 thread&: *thread_sp, break_id: bp_site_sp->GetID()));
1971 } else {
1972 StopInfoSP invalid_stop_info_sp;
1973 thread_sp->SetStopInfo(invalid_stop_info_sp);
1974 }
1975 } else {
1976 // If we were stepping then assume the stop was the result of the
1977 // trace. If we were not stepping then report the SIGTRAP.
1978 if (thread_sp->GetTemporaryResumeState() == eStateStepping)
1979 thread_sp->SetStopInfo(
1980 StopInfo::CreateStopReasonToTrace(thread&: *thread_sp));
1981 else
1982 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1983 thread&: *thread_sp, signo, description: description.c_str()));
1984 }
1985 }
1986 if (!handled) {
1987 // For thread plan async interrupt, creating stop info on the
1988 // original async interrupt request thread instead. If interrupt
1989 // thread does not exist anymore we fallback to current signal
1990 // receiving thread instead.
1991 ThreadSP interrupt_thread;
1992 if (m_interrupt_tid != LLDB_INVALID_THREAD_ID)
1993 interrupt_thread = HandleThreadAsyncInterrupt(signo, description);
1994 if (interrupt_thread)
1995 thread_sp = interrupt_thread;
1996 else
1997 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1998 thread&: *thread_sp, signo, description: description.c_str()));
1999 }
2000 }
2001
2002 if (!description.empty()) {
2003 lldb::StopInfoSP stop_info_sp(thread_sp->GetStopInfo());
2004 if (stop_info_sp) {
2005 const char *stop_info_desc = stop_info_sp->GetDescription();
2006 if (!stop_info_desc || !stop_info_desc[0])
2007 stop_info_sp->SetDescription(description.c_str());
2008 } else {
2009 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
2010 thread&: *thread_sp, description: description.c_str()));
2011 }
2012 }
2013 }
2014 }
2015 return thread_sp;
2016}
2017
2018ThreadSP
2019ProcessGDBRemote::HandleThreadAsyncInterrupt(uint8_t signo,
2020 const std::string &description) {
2021 ThreadSP thread_sp;
2022 {
2023 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
2024 thread_sp = m_thread_list_real.FindThreadByProtocolID(tid: m_interrupt_tid,
2025 /*can_update=*/false);
2026 }
2027 if (thread_sp)
2028 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithInterrupt(
2029 thread&: *thread_sp, signo, description: description.c_str()));
2030 // Clear m_interrupt_tid regardless we can find original interrupt thread or
2031 // not.
2032 m_interrupt_tid = LLDB_INVALID_THREAD_ID;
2033 return thread_sp;
2034}
2035
2036lldb::ThreadSP
2037ProcessGDBRemote::SetThreadStopInfo(StructuredData::Dictionary *thread_dict) {
2038 static constexpr llvm::StringLiteral g_key_tid("tid");
2039 static constexpr llvm::StringLiteral g_key_name("name");
2040 static constexpr llvm::StringLiteral g_key_reason("reason");
2041 static constexpr llvm::StringLiteral g_key_metype("metype");
2042 static constexpr llvm::StringLiteral g_key_medata("medata");
2043 static constexpr llvm::StringLiteral g_key_qaddr("qaddr");
2044 static constexpr llvm::StringLiteral g_key_dispatch_queue_t(
2045 "dispatch_queue_t");
2046 static constexpr llvm::StringLiteral g_key_associated_with_dispatch_queue(
2047 "associated_with_dispatch_queue");
2048 static constexpr llvm::StringLiteral g_key_queue_name("qname");
2049 static constexpr llvm::StringLiteral g_key_queue_kind("qkind");
2050 static constexpr llvm::StringLiteral g_key_queue_serial_number("qserialnum");
2051 static constexpr llvm::StringLiteral g_key_registers("registers");
2052 static constexpr llvm::StringLiteral g_key_memory("memory");
2053 static constexpr llvm::StringLiteral g_key_description("description");
2054 static constexpr llvm::StringLiteral g_key_signal("signal");
2055
2056 // Stop with signal and thread info
2057 lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
2058 uint8_t signo = 0;
2059 std::string thread_name;
2060 std::string reason;
2061 std::string description;
2062 uint32_t exc_type = 0;
2063 std::vector<addr_t> exc_data;
2064 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
2065 ExpeditedRegisterMap expedited_register_map;
2066 bool queue_vars_valid = false;
2067 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS;
2068 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2069 std::string queue_name;
2070 QueueKind queue_kind = eQueueKindUnknown;
2071 uint64_t queue_serial_number = 0;
2072 // Iterate through all of the thread dictionary key/value pairs from the
2073 // structured data dictionary
2074
2075 // FIXME: we're silently ignoring invalid data here
2076 thread_dict->ForEach(callback: [this, &tid, &expedited_register_map, &thread_name,
2077 &signo, &reason, &description, &exc_type, &exc_data,
2078 &thread_dispatch_qaddr, &queue_vars_valid,
2079 &associated_with_dispatch_queue, &dispatch_queue_t,
2080 &queue_name, &queue_kind, &queue_serial_number](
2081 llvm::StringRef key,
2082 StructuredData::Object *object) -> bool {
2083 if (key == g_key_tid) {
2084 // thread in big endian hex
2085 tid = object->GetUnsignedIntegerValue(LLDB_INVALID_THREAD_ID);
2086 } else if (key == g_key_metype) {
2087 // exception type in big endian hex
2088 exc_type = object->GetUnsignedIntegerValue(fail_value: 0);
2089 } else if (key == g_key_medata) {
2090 // exception data in big endian hex
2091 StructuredData::Array *array = object->GetAsArray();
2092 if (array) {
2093 array->ForEach(foreach_callback: [&exc_data](StructuredData::Object *object) -> bool {
2094 exc_data.push_back(x: object->GetUnsignedIntegerValue());
2095 return true; // Keep iterating through all array items
2096 });
2097 }
2098 } else if (key == g_key_name) {
2099 thread_name = std::string(object->GetStringValue());
2100 } else if (key == g_key_qaddr) {
2101 thread_dispatch_qaddr =
2102 object->GetUnsignedIntegerValue(LLDB_INVALID_ADDRESS);
2103 } else if (key == g_key_queue_name) {
2104 queue_vars_valid = true;
2105 queue_name = std::string(object->GetStringValue());
2106 } else if (key == g_key_queue_kind) {
2107 std::string queue_kind_str = std::string(object->GetStringValue());
2108 if (queue_kind_str == "serial") {
2109 queue_vars_valid = true;
2110 queue_kind = eQueueKindSerial;
2111 } else if (queue_kind_str == "concurrent") {
2112 queue_vars_valid = true;
2113 queue_kind = eQueueKindConcurrent;
2114 }
2115 } else if (key == g_key_queue_serial_number) {
2116 queue_serial_number = object->GetUnsignedIntegerValue(fail_value: 0);
2117 if (queue_serial_number != 0)
2118 queue_vars_valid = true;
2119 } else if (key == g_key_dispatch_queue_t) {
2120 dispatch_queue_t = object->GetUnsignedIntegerValue(fail_value: 0);
2121 if (dispatch_queue_t != 0 && dispatch_queue_t != LLDB_INVALID_ADDRESS)
2122 queue_vars_valid = true;
2123 } else if (key == g_key_associated_with_dispatch_queue) {
2124 queue_vars_valid = true;
2125 bool associated = object->GetBooleanValue();
2126 if (associated)
2127 associated_with_dispatch_queue = eLazyBoolYes;
2128 else
2129 associated_with_dispatch_queue = eLazyBoolNo;
2130 } else if (key == g_key_reason) {
2131 reason = std::string(object->GetStringValue());
2132 } else if (key == g_key_description) {
2133 description = std::string(object->GetStringValue());
2134 } else if (key == g_key_registers) {
2135 StructuredData::Dictionary *registers_dict = object->GetAsDictionary();
2136
2137 if (registers_dict) {
2138 registers_dict->ForEach(
2139 callback: [&expedited_register_map](llvm::StringRef key,
2140 StructuredData::Object *object) -> bool {
2141 uint32_t reg;
2142 if (llvm::to_integer(S: key, Num&: reg))
2143 expedited_register_map[reg] =
2144 std::string(object->GetStringValue());
2145 return true; // Keep iterating through all array items
2146 });
2147 }
2148 } else if (key == g_key_memory) {
2149 StructuredData::Array *array = object->GetAsArray();
2150 if (array) {
2151 array->ForEach(foreach_callback: [this](StructuredData::Object *object) -> bool {
2152 StructuredData::Dictionary *mem_cache_dict =
2153 object->GetAsDictionary();
2154 if (mem_cache_dict) {
2155 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
2156 if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>(
2157 key: "address", result&: mem_cache_addr)) {
2158 if (mem_cache_addr != LLDB_INVALID_ADDRESS) {
2159 llvm::StringRef str;
2160 if (mem_cache_dict->GetValueForKeyAsString(key: "bytes", result&: str)) {
2161 StringExtractor bytes(str);
2162 bytes.SetFilePos(0);
2163
2164 const size_t byte_size = bytes.GetStringRef().size() / 2;
2165 WritableDataBufferSP data_buffer_sp(
2166 new DataBufferHeap(byte_size, 0));
2167 const size_t bytes_copied =
2168 bytes.GetHexBytes(dest: data_buffer_sp->GetData(), fail_fill_value: 0);
2169 if (bytes_copied == byte_size)
2170 m_memory_cache.AddL1CacheData(addr: mem_cache_addr,
2171 data_buffer_sp);
2172 }
2173 }
2174 }
2175 }
2176 return true; // Keep iterating through all array items
2177 });
2178 }
2179
2180 } else if (key == g_key_signal)
2181 signo = object->GetUnsignedIntegerValue(LLDB_INVALID_SIGNAL_NUMBER);
2182 return true; // Keep iterating through all dictionary key/value pairs
2183 });
2184
2185 return SetThreadStopInfo(tid, expedited_register_map, signo, thread_name,
2186 reason, description, exc_type, exc_data,
2187 thread_dispatch_qaddr, queue_vars_valid,
2188 associated_with_dispatch_queue, dispatch_queue_t,
2189 queue_name, queue_kind, queue_serial: queue_serial_number);
2190}
2191
2192StateType ProcessGDBRemote::SetThreadStopInfo(StringExtractor &stop_packet) {
2193 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
2194 stop_packet.SetFilePos(0);
2195 const char stop_type = stop_packet.GetChar();
2196 switch (stop_type) {
2197 case 'T':
2198 case 'S': {
2199 // This is a bit of a hack, but it is required. If we did exec, we need to
2200 // clear our thread lists and also know to rebuild our dynamic register
2201 // info before we lookup and threads and populate the expedited register
2202 // values so we need to know this right away so we can cleanup and update
2203 // our registers.
2204 const uint32_t stop_id = GetStopID();
2205 if (stop_id == 0) {
2206 // Our first stop, make sure we have a process ID, and also make sure we
2207 // know about our registers
2208 if (GetID() == LLDB_INVALID_PROCESS_ID && pid != LLDB_INVALID_PROCESS_ID)
2209 SetID(pid);
2210 BuildDynamicRegisterInfo(force: true);
2211 }
2212 // Stop with signal and thread info
2213 lldb::pid_t stop_pid = LLDB_INVALID_PROCESS_ID;
2214 lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
2215 const uint8_t signo = stop_packet.GetHexU8();
2216 llvm::StringRef key;
2217 llvm::StringRef value;
2218 std::string thread_name;
2219 std::string reason;
2220 std::string description;
2221 uint32_t exc_type = 0;
2222 std::vector<addr_t> exc_data;
2223 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
2224 bool queue_vars_valid =
2225 false; // says if locals below that start with "queue_" are valid
2226 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS;
2227 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2228 std::string queue_name;
2229 QueueKind queue_kind = eQueueKindUnknown;
2230 uint64_t queue_serial_number = 0;
2231 ExpeditedRegisterMap expedited_register_map;
2232 AddressableBits addressable_bits;
2233 while (stop_packet.GetNameColonValue(name&: key, value)) {
2234 if (key.compare(RHS: "metype") == 0) {
2235 // exception type in big endian hex
2236 value.getAsInteger(Radix: 16, Result&: exc_type);
2237 } else if (key.compare(RHS: "medata") == 0) {
2238 // exception data in big endian hex
2239 uint64_t x;
2240 value.getAsInteger(Radix: 16, Result&: x);
2241 exc_data.push_back(x: x);
2242 } else if (key.compare(RHS: "thread") == 0) {
2243 // thread-id
2244 StringExtractorGDBRemote thread_id{value};
2245 auto pid_tid = thread_id.GetPidTid(default_pid: pid);
2246 if (pid_tid) {
2247 stop_pid = pid_tid->first;
2248 tid = pid_tid->second;
2249 } else
2250 tid = LLDB_INVALID_THREAD_ID;
2251 } else if (key.compare(RHS: "threads") == 0) {
2252 std::lock_guard<std::recursive_mutex> guard(
2253 m_thread_list_real.GetMutex());
2254 UpdateThreadIDsFromStopReplyThreadsValue(value);
2255 } else if (key.compare(RHS: "thread-pcs") == 0) {
2256 m_thread_pcs.clear();
2257 // A comma separated list of all threads in the current
2258 // process that includes the thread for this stop reply packet
2259 lldb::addr_t pc;
2260 while (!value.empty()) {
2261 llvm::StringRef pc_str;
2262 std::tie(args&: pc_str, args&: value) = value.split(Separator: ',');
2263 if (pc_str.getAsInteger(Radix: 16, Result&: pc))
2264 pc = LLDB_INVALID_ADDRESS;
2265 m_thread_pcs.push_back(x: pc);
2266 }
2267 } else if (key.compare(RHS: "jstopinfo") == 0) {
2268 StringExtractor json_extractor(value);
2269 std::string json;
2270 // Now convert the HEX bytes into a string value
2271 json_extractor.GetHexByteString(str&: json);
2272
2273 // This JSON contains thread IDs and thread stop info for all threads.
2274 // It doesn't contain expedited registers, memory or queue info.
2275 m_jstopinfo_sp = StructuredData::ParseJSON(json_text: json);
2276 } else if (key.compare(RHS: "hexname") == 0) {
2277 StringExtractor name_extractor(value);
2278 // Now convert the HEX bytes into a string value
2279 name_extractor.GetHexByteString(str&: thread_name);
2280 } else if (key.compare(RHS: "name") == 0) {
2281 thread_name = std::string(value);
2282 } else if (key.compare(RHS: "qaddr") == 0) {
2283 value.getAsInteger(Radix: 16, Result&: thread_dispatch_qaddr);
2284 } else if (key.compare(RHS: "dispatch_queue_t") == 0) {
2285 queue_vars_valid = true;
2286 value.getAsInteger(Radix: 16, Result&: dispatch_queue_t);
2287 } else if (key.compare(RHS: "qname") == 0) {
2288 queue_vars_valid = true;
2289 StringExtractor name_extractor(value);
2290 // Now convert the HEX bytes into a string value
2291 name_extractor.GetHexByteString(str&: queue_name);
2292 } else if (key.compare(RHS: "qkind") == 0) {
2293 queue_kind = llvm::StringSwitch<QueueKind>(value)
2294 .Case(S: "serial", Value: eQueueKindSerial)
2295 .Case(S: "concurrent", Value: eQueueKindConcurrent)
2296 .Default(Value: eQueueKindUnknown);
2297 queue_vars_valid = queue_kind != eQueueKindUnknown;
2298 } else if (key.compare(RHS: "qserialnum") == 0) {
2299 if (!value.getAsInteger(Radix: 0, Result&: queue_serial_number))
2300 queue_vars_valid = true;
2301 } else if (key.compare(RHS: "reason") == 0) {
2302 reason = std::string(value);
2303 } else if (key.compare(RHS: "description") == 0) {
2304 StringExtractor desc_extractor(value);
2305 // Now convert the HEX bytes into a string value
2306 desc_extractor.GetHexByteString(str&: description);
2307 } else if (key.compare(RHS: "memory") == 0) {
2308 // Expedited memory. GDB servers can choose to send back expedited
2309 // memory that can populate the L1 memory cache in the process so that
2310 // things like the frame pointer backchain can be expedited. This will
2311 // help stack backtracing be more efficient by not having to send as
2312 // many memory read requests down the remote GDB server.
2313
2314 // Key/value pair format: memory:<addr>=<bytes>;
2315 // <addr> is a number whose base will be interpreted by the prefix:
2316 // "0x[0-9a-fA-F]+" for hex
2317 // "0[0-7]+" for octal
2318 // "[1-9]+" for decimal
2319 // <bytes> is native endian ASCII hex bytes just like the register
2320 // values
2321 llvm::StringRef addr_str, bytes_str;
2322 std::tie(args&: addr_str, args&: bytes_str) = value.split(Separator: '=');
2323 if (!addr_str.empty() && !bytes_str.empty()) {
2324 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
2325 if (!addr_str.getAsInteger(Radix: 0, Result&: mem_cache_addr)) {
2326 StringExtractor bytes(bytes_str);
2327 const size_t byte_size = bytes.GetBytesLeft() / 2;
2328 WritableDataBufferSP data_buffer_sp(
2329 new DataBufferHeap(byte_size, 0));
2330 const size_t bytes_copied =
2331 bytes.GetHexBytes(dest: data_buffer_sp->GetData(), fail_fill_value: 0);
2332 if (bytes_copied == byte_size)
2333 m_memory_cache.AddL1CacheData(addr: mem_cache_addr, data_buffer_sp);
2334 }
2335 }
2336 } else if (key.compare(RHS: "watch") == 0 || key.compare(RHS: "rwatch") == 0 ||
2337 key.compare(RHS: "awatch") == 0) {
2338 // Support standard GDB remote stop reply packet 'TAAwatch:addr'
2339 lldb::addr_t wp_addr = LLDB_INVALID_ADDRESS;
2340 value.getAsInteger(Radix: 16, Result&: wp_addr);
2341
2342 WatchpointResourceSP wp_resource_sp =
2343 m_watchpoint_resource_list.FindByAddress(addr: wp_addr);
2344
2345 // Rewrite gdb standard watch/rwatch/awatch to
2346 // "reason:watchpoint" + "description:ADDR",
2347 // which is parsed in SetThreadStopInfo.
2348 reason = "watchpoint";
2349 StreamString ostr;
2350 ostr.Printf(format: "%" PRIu64, wp_addr);
2351 description = std::string(ostr.GetString());
2352 } else if (key.compare(RHS: "swbreak") == 0 || key.compare(RHS: "hwbreak") == 0) {
2353 reason = "breakpoint";
2354 } else if (key.compare(RHS: "replaylog") == 0) {
2355 reason = "history boundary";
2356 } else if (key.compare(RHS: "library") == 0) {
2357 auto error = LoadModules();
2358 if (error) {
2359 Log *log(GetLog(mask: GDBRLog::Process));
2360 LLDB_LOG_ERROR(log, std::move(error), "Failed to load modules: {0}");
2361 }
2362 } else if (key.compare(RHS: "fork") == 0 || key.compare(RHS: "vfork") == 0) {
2363 // fork includes child pid/tid in thread-id format
2364 StringExtractorGDBRemote thread_id{value};
2365 auto pid_tid = thread_id.GetPidTid(LLDB_INVALID_PROCESS_ID);
2366 if (!pid_tid) {
2367 Log *log(GetLog(mask: GDBRLog::Process));
2368 LLDB_LOG(log, "Invalid PID/TID to fork: {0}", value);
2369 pid_tid = {{LLDB_INVALID_PROCESS_ID, LLDB_INVALID_THREAD_ID}};
2370 }
2371
2372 reason = key.str();
2373 StreamString ostr;
2374 ostr.Printf(format: "%" PRIu64 " %" PRIu64, pid_tid->first, pid_tid->second);
2375 description = std::string(ostr.GetString());
2376 } else if (key.compare(RHS: "addressing_bits") == 0) {
2377 uint64_t addressing_bits;
2378 if (!value.getAsInteger(Radix: 0, Result&: addressing_bits)) {
2379 addressable_bits.SetAddressableBits(addressing_bits);
2380 }
2381 } else if (key.compare(RHS: "low_mem_addressing_bits") == 0) {
2382 uint64_t addressing_bits;
2383 if (!value.getAsInteger(Radix: 0, Result&: addressing_bits)) {
2384 addressable_bits.SetLowmemAddressableBits(addressing_bits);
2385 }
2386 } else if (key.compare(RHS: "high_mem_addressing_bits") == 0) {
2387 uint64_t addressing_bits;
2388 if (!value.getAsInteger(Radix: 0, Result&: addressing_bits)) {
2389 addressable_bits.SetHighmemAddressableBits(addressing_bits);
2390 }
2391 } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
2392 uint32_t reg = UINT32_MAX;
2393 if (!key.getAsInteger(Radix: 16, Result&: reg))
2394 expedited_register_map[reg] = std::string(std::move(value));
2395 }
2396 // swbreak and hwbreak are also expected keys, but we don't need to
2397 // change our behaviour for them because lldb always expects the remote
2398 // to adjust the program counter (if relevant, e.g., for x86 targets)
2399 }
2400
2401 if (stop_pid != LLDB_INVALID_PROCESS_ID && stop_pid != pid) {
2402 Log *log = GetLog(mask: GDBRLog::Process);
2403 LLDB_LOG(log,
2404 "Received stop for incorrect PID = {0} (inferior PID = {1})",
2405 stop_pid, pid);
2406 return eStateInvalid;
2407 }
2408
2409 if (tid == LLDB_INVALID_THREAD_ID) {
2410 // A thread id may be invalid if the response is old style 'S' packet
2411 // which does not provide the
2412 // thread information. So update the thread list and choose the first
2413 // one.
2414 UpdateThreadIDList();
2415
2416 if (!m_thread_ids.empty()) {
2417 tid = m_thread_ids.front();
2418 }
2419 }
2420
2421 SetAddressableBitMasks(addressable_bits);
2422
2423 ThreadSP thread_sp = SetThreadStopInfo(
2424 tid, expedited_register_map, signo, thread_name, reason, description,
2425 exc_type, exc_data, thread_dispatch_qaddr, queue_vars_valid,
2426 associated_with_dispatch_queue, dispatch_queue_t, queue_name,
2427 queue_kind, queue_serial: queue_serial_number);
2428
2429 return eStateStopped;
2430 } break;
2431
2432 case 'W':
2433 case 'X':
2434 // process exited
2435 return eStateExited;
2436
2437 default:
2438 break;
2439 }
2440 return eStateInvalid;
2441}
2442
2443void ProcessGDBRemote::RefreshStateAfterStop() {
2444 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
2445
2446 m_thread_ids.clear();
2447 m_thread_pcs.clear();
2448
2449 // Set the thread stop info. It might have a "threads" key whose value is a
2450 // list of all thread IDs in the current process, so m_thread_ids might get
2451 // set.
2452 // Check to see if SetThreadStopInfo() filled in m_thread_ids?
2453 if (m_thread_ids.empty()) {
2454 // No, we need to fetch the thread list manually
2455 UpdateThreadIDList();
2456 }
2457
2458 // We might set some stop info's so make sure the thread list is up to
2459 // date before we do that or we might overwrite what was computed here.
2460 UpdateThreadListIfNeeded();
2461
2462 if (m_last_stop_packet)
2463 SetThreadStopInfo(*m_last_stop_packet);
2464 m_last_stop_packet.reset();
2465
2466 // If we have queried for a default thread id
2467 if (m_initial_tid != LLDB_INVALID_THREAD_ID) {
2468 m_thread_list.SetSelectedThreadByID(tid: m_initial_tid);
2469 m_initial_tid = LLDB_INVALID_THREAD_ID;
2470 }
2471
2472 // Let all threads recover from stopping and do any clean up based on the
2473 // previous thread state (if any).
2474 m_thread_list_real.RefreshStateAfterStop();
2475}
2476
2477Status ProcessGDBRemote::DoHalt(bool &caused_stop) {
2478 Status error;
2479
2480 if (m_public_state.GetValue() == eStateAttaching) {
2481 // We are being asked to halt during an attach. We used to just close our
2482 // file handle and debugserver will go away, but with remote proxies, it
2483 // is better to send a positive signal, so let's send the interrupt first...
2484 caused_stop = m_gdb_comm.Interrupt(interrupt_timeout: GetInterruptTimeout());
2485 m_gdb_comm.Disconnect();
2486 } else
2487 caused_stop = m_gdb_comm.Interrupt(interrupt_timeout: GetInterruptTimeout());
2488 return error;
2489}
2490
2491Status ProcessGDBRemote::DoDetach(bool keep_stopped) {
2492 Status error;
2493 Log *log = GetLog(mask: GDBRLog::Process);
2494 LLDB_LOGF(log, "ProcessGDBRemote::DoDetach(keep_stopped: %i)", keep_stopped);
2495
2496 error = m_gdb_comm.Detach(keep_stopped);
2497 if (log) {
2498 if (error.Success())
2499 log->PutCString(
2500 cstr: "ProcessGDBRemote::DoDetach() detach packet sent successfully");
2501 else
2502 LLDB_LOGF(log,
2503 "ProcessGDBRemote::DoDetach() detach packet send failed: %s",
2504 error.AsCString() ? error.AsCString() : "<unknown error>");
2505 }
2506
2507 if (!error.Success())
2508 return error;
2509
2510 // Sleep for one second to let the process get all detached...
2511 StopAsyncThread();
2512
2513 SetPrivateState(eStateDetached);
2514 ResumePrivateStateThread();
2515
2516 // KillDebugserverProcess ();
2517 return error;
2518}
2519
2520Status ProcessGDBRemote::DoDestroy() {
2521 Log *log = GetLog(mask: GDBRLog::Process);
2522 LLDB_LOGF(log, "ProcessGDBRemote::DoDestroy()");
2523
2524 // Interrupt if our inferior is running...
2525 int exit_status = SIGABRT;
2526 std::string exit_string;
2527
2528 if (m_gdb_comm.IsConnected()) {
2529 if (m_public_state.GetValue() != eStateAttaching) {
2530 llvm::Expected<int> kill_res = m_gdb_comm.KillProcess(pid: GetID());
2531
2532 if (kill_res) {
2533 exit_status = kill_res.get();
2534#if defined(__APPLE__)
2535 // For Native processes on Mac OS X, we launch through the Host
2536 // Platform, then hand the process off to debugserver, which becomes
2537 // the parent process through "PT_ATTACH". Then when we go to kill
2538 // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then
2539 // we call waitpid which returns with no error and the correct
2540 // status. But amusingly enough that doesn't seem to actually reap
2541 // the process, but instead it is left around as a Zombie. Probably
2542 // the kernel is in the process of switching ownership back to lldb
2543 // which was the original parent, and gets confused in the handoff.
2544 // Anyway, so call waitpid here to finally reap it.
2545 PlatformSP platform_sp(GetTarget().GetPlatform());
2546 if (platform_sp && platform_sp->IsHost()) {
2547 int status;
2548 ::pid_t reap_pid;
2549 reap_pid = waitpid(GetID(), &status, WNOHANG);
2550 LLDB_LOGF(log, "Reaped pid: %d, status: %d.\n", reap_pid, status);
2551 }
2552#endif
2553 ClearThreadIDList();
2554 exit_string.assign(s: "killed");
2555 } else {
2556 exit_string.assign(str: llvm::toString(E: kill_res.takeError()));
2557 }
2558 } else {
2559 exit_string.assign(s: "killed or interrupted while attaching.");
2560 }
2561 } else {
2562 // If we missed setting the exit status on the way out, do it here.
2563 // NB set exit status can be called multiple times, the first one sets the
2564 // status.
2565 exit_string.assign(s: "destroying when not connected to debugserver");
2566 }
2567
2568 SetExitStatus(exit_status, exit_string: exit_string.c_str());
2569
2570 StopAsyncThread();
2571 KillDebugserverProcess();
2572 RemoveNewThreadBreakpoints();
2573 return Status();
2574}
2575
2576void ProcessGDBRemote::RemoveNewThreadBreakpoints() {
2577 if (m_thread_create_bp_sp) {
2578 if (TargetSP target_sp = m_target_wp.lock())
2579 target_sp->RemoveBreakpointByID(break_id: m_thread_create_bp_sp->GetID());
2580 m_thread_create_bp_sp.reset();
2581 }
2582}
2583
2584void ProcessGDBRemote::SetLastStopPacket(
2585 const StringExtractorGDBRemote &response) {
2586 const bool did_exec =
2587 response.GetStringRef().find(Str: ";reason:exec;") != std::string::npos;
2588 if (did_exec) {
2589 Log *log = GetLog(mask: GDBRLog::Process);
2590 LLDB_LOGF(log, "ProcessGDBRemote::SetLastStopPacket () - detected exec");
2591
2592 m_thread_list_real.Clear();
2593 m_thread_list.Clear();
2594 BuildDynamicRegisterInfo(force: true);
2595 m_gdb_comm.ResetDiscoverableSettings(did_exec);
2596 }
2597
2598 m_last_stop_packet = response;
2599}
2600
2601void ProcessGDBRemote::SetUnixSignals(const UnixSignalsSP &signals_sp) {
2602 Process::SetUnixSignals(std::make_shared<GDBRemoteSignals>(args: signals_sp));
2603}
2604
2605// Process Queries
2606
2607bool ProcessGDBRemote::IsAlive() {
2608 return m_gdb_comm.IsConnected() && Process::IsAlive();
2609}
2610
2611addr_t ProcessGDBRemote::GetImageInfoAddress() {
2612 // request the link map address via the $qShlibInfoAddr packet
2613 lldb::addr_t addr = m_gdb_comm.GetShlibInfoAddr();
2614
2615 // the loaded module list can also provides a link map address
2616 if (addr == LLDB_INVALID_ADDRESS) {
2617 llvm::Expected<LoadedModuleInfoList> list = GetLoadedModuleList();
2618 if (!list) {
2619 Log *log = GetLog(mask: GDBRLog::Process);
2620 LLDB_LOG_ERROR(log, list.takeError(), "Failed to read module list: {0}.");
2621 } else {
2622 addr = list->m_link_map;
2623 }
2624 }
2625
2626 return addr;
2627}
2628
2629void ProcessGDBRemote::WillPublicStop() {
2630 // See if the GDB remote client supports the JSON threads info. If so, we
2631 // gather stop info for all threads, expedited registers, expedited memory,
2632 // runtime queue information (iOS and MacOSX only), and more. Expediting
2633 // memory will help stack backtracing be much faster. Expediting registers
2634 // will make sure we don't have to read the thread registers for GPRs.
2635 m_jthreadsinfo_sp = m_gdb_comm.GetThreadsInfo();
2636
2637 if (m_jthreadsinfo_sp) {
2638 // Now set the stop info for each thread and also expedite any registers
2639 // and memory that was in the jThreadsInfo response.
2640 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
2641 if (thread_infos) {
2642 const size_t n = thread_infos->GetSize();
2643 for (size_t i = 0; i < n; ++i) {
2644 StructuredData::Dictionary *thread_dict =
2645 thread_infos->GetItemAtIndex(idx: i)->GetAsDictionary();
2646 if (thread_dict)
2647 SetThreadStopInfo(thread_dict);
2648 }
2649 }
2650 }
2651}
2652
2653// Process Memory
2654size_t ProcessGDBRemote::DoReadMemory(addr_t addr, void *buf, size_t size,
2655 Status &error) {
2656 using xPacketState = GDBRemoteCommunicationClient::xPacketState;
2657
2658 GetMaxMemorySize();
2659 xPacketState x_state = m_gdb_comm.GetxPacketState();
2660
2661 // M and m packets take 2 bytes for 1 byte of memory
2662 size_t max_memory_size = x_state != xPacketState::Unimplemented
2663 ? m_max_memory_size
2664 : m_max_memory_size / 2;
2665 if (size > max_memory_size) {
2666 // Keep memory read sizes down to a sane limit. This function will be
2667 // called multiple times in order to complete the task by
2668 // lldb_private::Process so it is ok to do this.
2669 size = max_memory_size;
2670 }
2671
2672 char packet[64];
2673 int packet_len;
2674 packet_len = ::snprintf(s: packet, maxlen: sizeof(packet), format: "%c%" PRIx64 ",%" PRIx64,
2675 x_state != xPacketState::Unimplemented ? 'x' : 'm',
2676 (uint64_t)addr, (uint64_t)size);
2677 assert(packet_len + 1 < (int)sizeof(packet));
2678 UNUSED_IF_ASSERT_DISABLED(packet_len);
2679 StringExtractorGDBRemote response;
2680 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet, response,
2681 interrupt_timeout: GetInterruptTimeout()) ==
2682 GDBRemoteCommunication::PacketResult::Success) {
2683 if (response.IsNormalResponse()) {
2684 error.Clear();
2685 if (x_state != xPacketState::Unimplemented) {
2686 // The lower level GDBRemoteCommunication packet receive layer has
2687 // already de-quoted any 0x7d character escaping that was present in
2688 // the packet
2689
2690 llvm::StringRef data_received = response.GetStringRef();
2691 if (x_state == xPacketState::Prefixed &&
2692 !data_received.consume_front(Prefix: "b")) {
2693 error = Status::FromErrorStringWithFormatv(
2694 format: "unexpected response to GDB server memory read packet '{0}': "
2695 "'{1}'",
2696 args&: packet, args&: data_received);
2697 return 0;
2698 }
2699 // Don't write past the end of BUF if the remote debug server gave us
2700 // too much data for some reason.
2701 size_t memcpy_size = std::min(a: size, b: data_received.size());
2702 memcpy(dest: buf, src: data_received.data(), n: memcpy_size);
2703 return memcpy_size;
2704 } else {
2705 return response.GetHexBytes(
2706 dest: llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, size), fail_fill_value: '\xdd');
2707 }
2708 } else if (response.IsErrorResponse())
2709 error = Status::FromErrorStringWithFormat(
2710 format: "memory read failed for 0x%" PRIx64, addr);
2711 else if (response.IsUnsupportedResponse())
2712 error = Status::FromErrorStringWithFormat(
2713 format: "GDB server does not support reading memory");
2714 else
2715 error = Status::FromErrorStringWithFormat(
2716 format: "unexpected response to GDB server memory read packet '%s': '%s'",
2717 packet, response.GetStringRef().data());
2718 } else {
2719 error = Status::FromErrorStringWithFormat(format: "failed to send packet: '%s'",
2720 packet);
2721 }
2722 return 0;
2723}
2724
2725bool ProcessGDBRemote::SupportsMemoryTagging() {
2726 return m_gdb_comm.GetMemoryTaggingSupported();
2727}
2728
2729llvm::Expected<std::vector<uint8_t>>
2730ProcessGDBRemote::DoReadMemoryTags(lldb::addr_t addr, size_t len,
2731 int32_t type) {
2732 // By this point ReadMemoryTags has validated that tagging is enabled
2733 // for this target/process/address.
2734 DataBufferSP buffer_sp = m_gdb_comm.ReadMemoryTags(addr, len, type);
2735 if (!buffer_sp) {
2736 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
2737 S: "Error reading memory tags from remote");
2738 }
2739
2740 // Return the raw tag data
2741 llvm::ArrayRef<uint8_t> tag_data = buffer_sp->GetData();
2742 std::vector<uint8_t> got;
2743 got.reserve(n: tag_data.size());
2744 std::copy(first: tag_data.begin(), last: tag_data.end(), result: std::back_inserter(x&: got));
2745 return got;
2746}
2747
2748Status ProcessGDBRemote::DoWriteMemoryTags(lldb::addr_t addr, size_t len,
2749 int32_t type,
2750 const std::vector<uint8_t> &tags) {
2751 // By now WriteMemoryTags should have validated that tagging is enabled
2752 // for this target/process.
2753 return m_gdb_comm.WriteMemoryTags(addr, len, type, tags);
2754}
2755
2756Status ProcessGDBRemote::WriteObjectFile(
2757 std::vector<ObjectFile::LoadableData> entries) {
2758 Status error;
2759 // Sort the entries by address because some writes, like those to flash
2760 // memory, must happen in order of increasing address.
2761 llvm::stable_sort(Range&: entries, C: [](const ObjectFile::LoadableData a,
2762 const ObjectFile::LoadableData b) {
2763 return a.Dest < b.Dest;
2764 });
2765 m_allow_flash_writes = true;
2766 error = Process::WriteObjectFile(entries);
2767 if (error.Success())
2768 error = FlashDone();
2769 else
2770 // Even though some of the writing failed, try to send a flash done if some
2771 // of the writing succeeded so the flash state is reset to normal, but
2772 // don't stomp on the error status that was set in the write failure since
2773 // that's the one we want to report back.
2774 FlashDone();
2775 m_allow_flash_writes = false;
2776 return error;
2777}
2778
2779bool ProcessGDBRemote::HasErased(FlashRange range) {
2780 auto size = m_erased_flash_ranges.GetSize();
2781 for (size_t i = 0; i < size; ++i)
2782 if (m_erased_flash_ranges.GetEntryAtIndex(i)->Contains(range))
2783 return true;
2784 return false;
2785}
2786
2787Status ProcessGDBRemote::FlashErase(lldb::addr_t addr, size_t size) {
2788 Status status;
2789
2790 MemoryRegionInfo region;
2791 status = GetMemoryRegionInfo(load_addr: addr, range_info&: region);
2792 if (!status.Success())
2793 return status;
2794
2795 // The gdb spec doesn't say if erasures are allowed across multiple regions,
2796 // but we'll disallow it to be safe and to keep the logic simple by worring
2797 // about only one region's block size. DoMemoryWrite is this function's
2798 // primary user, and it can easily keep writes within a single memory region
2799 if (addr + size > region.GetRange().GetRangeEnd()) {
2800 status =
2801 Status::FromErrorString(str: "Unable to erase flash in multiple regions");
2802 return status;
2803 }
2804
2805 uint64_t blocksize = region.GetBlocksize();
2806 if (blocksize == 0) {
2807 status =
2808 Status::FromErrorString(str: "Unable to erase flash because blocksize is 0");
2809 return status;
2810 }
2811
2812 // Erasures can only be done on block boundary adresses, so round down addr
2813 // and round up size
2814 lldb::addr_t block_start_addr = addr - (addr % blocksize);
2815 size += (addr - block_start_addr);
2816 if ((size % blocksize) != 0)
2817 size += (blocksize - size % blocksize);
2818
2819 FlashRange range(block_start_addr, size);
2820
2821 if (HasErased(range))
2822 return status;
2823
2824 // We haven't erased the entire range, but we may have erased part of it.
2825 // (e.g., block A is already erased and range starts in A and ends in B). So,
2826 // adjust range if necessary to exclude already erased blocks.
2827 if (!m_erased_flash_ranges.IsEmpty()) {
2828 // Assuming that writes and erasures are done in increasing addr order,
2829 // because that is a requirement of the vFlashWrite command. Therefore, we
2830 // only need to look at the last range in the list for overlap.
2831 const auto &last_range = *m_erased_flash_ranges.Back();
2832 if (range.GetRangeBase() < last_range.GetRangeEnd()) {
2833 auto overlap = last_range.GetRangeEnd() - range.GetRangeBase();
2834 // overlap will be less than range.GetByteSize() or else HasErased()
2835 // would have been true
2836 range.SetByteSize(range.GetByteSize() - overlap);
2837 range.SetRangeBase(range.GetRangeBase() + overlap);
2838 }
2839 }
2840
2841 StreamString packet;
2842 packet.Printf(format: "vFlashErase:%" PRIx64 ",%" PRIx64, range.GetRangeBase(),
2843 (uint64_t)range.GetByteSize());
2844
2845 StringExtractorGDBRemote response;
2846 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response,
2847 interrupt_timeout: GetInterruptTimeout()) ==
2848 GDBRemoteCommunication::PacketResult::Success) {
2849 if (response.IsOKResponse()) {
2850 m_erased_flash_ranges.Insert(entry: range, combine: true);
2851 } else {
2852 if (response.IsErrorResponse())
2853 status = Status::FromErrorStringWithFormat(
2854 format: "flash erase failed for 0x%" PRIx64, addr);
2855 else if (response.IsUnsupportedResponse())
2856 status = Status::FromErrorStringWithFormat(
2857 format: "GDB server does not support flashing");
2858 else
2859 status = Status::FromErrorStringWithFormat(
2860 format: "unexpected response to GDB server flash erase packet '%s': '%s'",
2861 packet.GetData(), response.GetStringRef().data());
2862 }
2863 } else {
2864 status = Status::FromErrorStringWithFormat(format: "failed to send packet: '%s'",
2865 packet.GetData());
2866 }
2867 return status;
2868}
2869
2870Status ProcessGDBRemote::FlashDone() {
2871 Status status;
2872 // If we haven't erased any blocks, then we must not have written anything
2873 // either, so there is no need to actually send a vFlashDone command
2874 if (m_erased_flash_ranges.IsEmpty())
2875 return status;
2876 StringExtractorGDBRemote response;
2877 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: "vFlashDone", response,
2878 interrupt_timeout: GetInterruptTimeout()) ==
2879 GDBRemoteCommunication::PacketResult::Success) {
2880 if (response.IsOKResponse()) {
2881 m_erased_flash_ranges.Clear();
2882 } else {
2883 if (response.IsErrorResponse())
2884 status = Status::FromErrorStringWithFormat(format: "flash done failed");
2885 else if (response.IsUnsupportedResponse())
2886 status = Status::FromErrorStringWithFormat(
2887 format: "GDB server does not support flashing");
2888 else
2889 status = Status::FromErrorStringWithFormat(
2890 format: "unexpected response to GDB server flash done packet: '%s'",
2891 response.GetStringRef().data());
2892 }
2893 } else {
2894 status =
2895 Status::FromErrorStringWithFormat(format: "failed to send flash done packet");
2896 }
2897 return status;
2898}
2899
2900size_t ProcessGDBRemote::DoWriteMemory(addr_t addr, const void *buf,
2901 size_t size, Status &error) {
2902 GetMaxMemorySize();
2903 // M and m packets take 2 bytes for 1 byte of memory
2904 size_t max_memory_size = m_max_memory_size / 2;
2905 if (size > max_memory_size) {
2906 // Keep memory read sizes down to a sane limit. This function will be
2907 // called multiple times in order to complete the task by
2908 // lldb_private::Process so it is ok to do this.
2909 size = max_memory_size;
2910 }
2911
2912 StreamGDBRemote packet;
2913
2914 MemoryRegionInfo region;
2915 Status region_status = GetMemoryRegionInfo(load_addr: addr, range_info&: region);
2916
2917 bool is_flash =
2918 region_status.Success() && region.GetFlash() == MemoryRegionInfo::eYes;
2919
2920 if (is_flash) {
2921 if (!m_allow_flash_writes) {
2922 error = Status::FromErrorString(str: "Writing to flash memory is not allowed");
2923 return 0;
2924 }
2925 // Keep the write within a flash memory region
2926 if (addr + size > region.GetRange().GetRangeEnd())
2927 size = region.GetRange().GetRangeEnd() - addr;
2928 // Flash memory must be erased before it can be written
2929 error = FlashErase(addr, size);
2930 if (!error.Success())
2931 return 0;
2932 packet.Printf(format: "vFlashWrite:%" PRIx64 ":", addr);
2933 packet.PutEscapedBytes(s: buf, src_len: size);
2934 } else {
2935 packet.Printf(format: "M%" PRIx64 ",%" PRIx64 ":", addr, (uint64_t)size);
2936 packet.PutBytesAsRawHex8(src: buf, src_len: size, src_byte_order: endian::InlHostByteOrder(),
2937 dst_byte_order: endian::InlHostByteOrder());
2938 }
2939 StringExtractorGDBRemote response;
2940 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response,
2941 interrupt_timeout: GetInterruptTimeout()) ==
2942 GDBRemoteCommunication::PacketResult::Success) {
2943 if (response.IsOKResponse()) {
2944 error.Clear();
2945 return size;
2946 } else if (response.IsErrorResponse())
2947 error = Status::FromErrorStringWithFormat(
2948 format: "memory write failed for 0x%" PRIx64, addr);
2949 else if (response.IsUnsupportedResponse())
2950 error = Status::FromErrorStringWithFormat(
2951 format: "GDB server does not support writing memory");
2952 else
2953 error = Status::FromErrorStringWithFormat(
2954 format: "unexpected response to GDB server memory write packet '%s': '%s'",
2955 packet.GetData(), response.GetStringRef().data());
2956 } else {
2957 error = Status::FromErrorStringWithFormat(format: "failed to send packet: '%s'",
2958 packet.GetData());
2959 }
2960 return 0;
2961}
2962
2963lldb::addr_t ProcessGDBRemote::DoAllocateMemory(size_t size,
2964 uint32_t permissions,
2965 Status &error) {
2966 Log *log = GetLog(mask: LLDBLog::Process | LLDBLog::Expressions);
2967 addr_t allocated_addr = LLDB_INVALID_ADDRESS;
2968
2969 if (m_gdb_comm.SupportsAllocDeallocMemory() != eLazyBoolNo) {
2970 allocated_addr = m_gdb_comm.AllocateMemory(size, permissions);
2971 if (allocated_addr != LLDB_INVALID_ADDRESS ||
2972 m_gdb_comm.SupportsAllocDeallocMemory() == eLazyBoolYes)
2973 return allocated_addr;
2974 }
2975
2976 if (m_gdb_comm.SupportsAllocDeallocMemory() == eLazyBoolNo) {
2977 // Call mmap() to create memory in the inferior..
2978 unsigned prot = 0;
2979 if (permissions & lldb::ePermissionsReadable)
2980 prot |= eMmapProtRead;
2981 if (permissions & lldb::ePermissionsWritable)
2982 prot |= eMmapProtWrite;
2983 if (permissions & lldb::ePermissionsExecutable)
2984 prot |= eMmapProtExec;
2985
2986 if (InferiorCallMmap(proc: this, allocated_addr, addr: 0, length: size, prot,
2987 flags: eMmapFlagsAnon | eMmapFlagsPrivate, fd: -1, offset: 0))
2988 m_addr_to_mmap_size[allocated_addr] = size;
2989 else {
2990 allocated_addr = LLDB_INVALID_ADDRESS;
2991 LLDB_LOGF(log,
2992 "ProcessGDBRemote::%s no direct stub support for memory "
2993 "allocation, and InferiorCallMmap also failed - is stub "
2994 "missing register context save/restore capability?",
2995 __FUNCTION__);
2996 }
2997 }
2998
2999 if (allocated_addr == LLDB_INVALID_ADDRESS)
3000 error = Status::FromErrorStringWithFormat(
3001 format: "unable to allocate %" PRIu64 " bytes of memory with permissions %s",
3002 (uint64_t)size, GetPermissionsAsCString(permissions));
3003 else
3004 error.Clear();
3005 return allocated_addr;
3006}
3007
3008Status ProcessGDBRemote::DoGetMemoryRegionInfo(addr_t load_addr,
3009 MemoryRegionInfo &region_info) {
3010
3011 Status error(m_gdb_comm.GetMemoryRegionInfo(addr: load_addr, range_info&: region_info));
3012 return error;
3013}
3014
3015std::optional<uint32_t> ProcessGDBRemote::GetWatchpointSlotCount() {
3016 return m_gdb_comm.GetWatchpointSlotCount();
3017}
3018
3019std::optional<bool> ProcessGDBRemote::DoGetWatchpointReportedAfter() {
3020 return m_gdb_comm.GetWatchpointReportedAfter();
3021}
3022
3023Status ProcessGDBRemote::DoDeallocateMemory(lldb::addr_t addr) {
3024 Status error;
3025 LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();
3026
3027 switch (supported) {
3028 case eLazyBoolCalculate:
3029 // We should never be deallocating memory without allocating memory first
3030 // so we should never get eLazyBoolCalculate
3031 error = Status::FromErrorString(
3032 str: "tried to deallocate memory without ever allocating memory");
3033 break;
3034
3035 case eLazyBoolYes:
3036 if (!m_gdb_comm.DeallocateMemory(addr))
3037 error = Status::FromErrorStringWithFormat(
3038 format: "unable to deallocate memory at 0x%" PRIx64, addr);
3039 break;
3040
3041 case eLazyBoolNo:
3042 // Call munmap() to deallocate memory in the inferior..
3043 {
3044 MMapMap::iterator pos = m_addr_to_mmap_size.find(x: addr);
3045 if (pos != m_addr_to_mmap_size.end() &&
3046 InferiorCallMunmap(proc: this, addr, length: pos->second))
3047 m_addr_to_mmap_size.erase(position: pos);
3048 else
3049 error = Status::FromErrorStringWithFormat(
3050 format: "unable to deallocate memory at 0x%" PRIx64, addr);
3051 }
3052 break;
3053 }
3054
3055 return error;
3056}
3057
3058// Process STDIO
3059size_t ProcessGDBRemote::PutSTDIN(const char *src, size_t src_len,
3060 Status &error) {
3061 if (m_stdio_communication.IsConnected()) {
3062 ConnectionStatus status;
3063 m_stdio_communication.WriteAll(src, src_len, status, error_ptr: nullptr);
3064 } else if (m_stdin_forward) {
3065 m_gdb_comm.SendStdinNotification(data: src, data_len: src_len);
3066 }
3067 return 0;
3068}
3069
3070Status ProcessGDBRemote::EnableBreakpointSite(BreakpointSite *bp_site) {
3071 Status error;
3072 assert(bp_site != nullptr);
3073
3074 // Get logging info
3075 Log *log = GetLog(mask: GDBRLog::Breakpoints);
3076 user_id_t site_id = bp_site->GetID();
3077
3078 // Get the breakpoint address
3079 const addr_t addr = bp_site->GetLoadAddress();
3080
3081 // Log that a breakpoint was requested
3082 LLDB_LOGF(log,
3083 "ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64
3084 ") address = 0x%" PRIx64,
3085 site_id, (uint64_t)addr);
3086
3087 // Breakpoint already exists and is enabled
3088 if (bp_site->IsEnabled()) {
3089 LLDB_LOGF(log,
3090 "ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64
3091 ") address = 0x%" PRIx64 " -- SUCCESS (already enabled)",
3092 site_id, (uint64_t)addr);
3093 return error;
3094 }
3095
3096 // Get the software breakpoint trap opcode size
3097 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
3098
3099 // SupportsGDBStoppointPacket() simply checks a boolean, indicating if this
3100 // breakpoint type is supported by the remote stub. These are set to true by
3101 // default, and later set to false only after we receive an unimplemented
3102 // response when sending a breakpoint packet. This means initially that
3103 // unless we were specifically instructed to use a hardware breakpoint, LLDB
3104 // will attempt to set a software breakpoint. HardwareRequired() also queries
3105 // a boolean variable which indicates if the user specifically asked for
3106 // hardware breakpoints. If true then we will skip over software
3107 // breakpoints.
3108 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointSoftware) &&
3109 (!bp_site->HardwareRequired())) {
3110 // Try to send off a software breakpoint packet ($Z0)
3111 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3112 type: eBreakpointSoftware, insert: true, addr, length: bp_op_size, interrupt_timeout: GetInterruptTimeout());
3113 if (error_no == 0) {
3114 // The breakpoint was placed successfully
3115 bp_site->SetEnabled(true);
3116 bp_site->SetType(BreakpointSite::eExternal);
3117 return error;
3118 }
3119
3120 // SendGDBStoppointTypePacket() will return an error if it was unable to
3121 // set this breakpoint. We need to differentiate between a error specific
3122 // to placing this breakpoint or if we have learned that this breakpoint
3123 // type is unsupported. To do this, we must test the support boolean for
3124 // this breakpoint type to see if it now indicates that this breakpoint
3125 // type is unsupported. If they are still supported then we should return
3126 // with the error code. If they are now unsupported, then we would like to
3127 // fall through and try another form of breakpoint.
3128 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointSoftware)) {
3129 if (error_no != UINT8_MAX)
3130 error = Status::FromErrorStringWithFormat(
3131 format: "error: %d sending the breakpoint request", error_no);
3132 else
3133 error = Status::FromErrorString(str: "error sending the breakpoint request");
3134 return error;
3135 }
3136
3137 // We reach here when software breakpoints have been found to be
3138 // unsupported. For future calls to set a breakpoint, we will not attempt
3139 // to set a breakpoint with a type that is known not to be supported.
3140 LLDB_LOGF(log, "Software breakpoints are unsupported");
3141
3142 // So we will fall through and try a hardware breakpoint
3143 }
3144
3145 // The process of setting a hardware breakpoint is much the same as above.
3146 // We check the supported boolean for this breakpoint type, and if it is
3147 // thought to be supported then we will try to set this breakpoint with a
3148 // hardware breakpoint.
3149 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointHardware)) {
3150 // Try to send off a hardware breakpoint packet ($Z1)
3151 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3152 type: eBreakpointHardware, insert: true, addr, length: bp_op_size, interrupt_timeout: GetInterruptTimeout());
3153 if (error_no == 0) {
3154 // The breakpoint was placed successfully
3155 bp_site->SetEnabled(true);
3156 bp_site->SetType(BreakpointSite::eHardware);
3157 return error;
3158 }
3159
3160 // Check if the error was something other then an unsupported breakpoint
3161 // type
3162 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointHardware)) {
3163 // Unable to set this hardware breakpoint
3164 if (error_no != UINT8_MAX)
3165 error = Status::FromErrorStringWithFormat(
3166 format: "error: %d sending the hardware breakpoint request "
3167 "(hardware breakpoint resources might be exhausted or unavailable)",
3168 error_no);
3169 else
3170 error = Status::FromErrorString(
3171 str: "error sending the hardware breakpoint request "
3172 "(hardware breakpoint resources "
3173 "might be exhausted or unavailable)");
3174 return error;
3175 }
3176
3177 // We will reach here when the stub gives an unsupported response to a
3178 // hardware breakpoint
3179 LLDB_LOGF(log, "Hardware breakpoints are unsupported");
3180
3181 // Finally we will falling through to a #trap style breakpoint
3182 }
3183
3184 // Don't fall through when hardware breakpoints were specifically requested
3185 if (bp_site->HardwareRequired()) {
3186 error = Status::FromErrorString(str: "hardware breakpoints are not supported");
3187 return error;
3188 }
3189
3190 // As a last resort we want to place a manual breakpoint. An instruction is
3191 // placed into the process memory using memory write packets.
3192 return EnableSoftwareBreakpoint(bp_site);
3193}
3194
3195Status ProcessGDBRemote::DisableBreakpointSite(BreakpointSite *bp_site) {
3196 Status error;
3197 assert(bp_site != nullptr);
3198 addr_t addr = bp_site->GetLoadAddress();
3199 user_id_t site_id = bp_site->GetID();
3200 Log *log = GetLog(mask: GDBRLog::Breakpoints);
3201 LLDB_LOGF(log,
3202 "ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64
3203 ") addr = 0x%8.8" PRIx64,
3204 site_id, (uint64_t)addr);
3205
3206 if (bp_site->IsEnabled()) {
3207 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
3208
3209 BreakpointSite::Type bp_type = bp_site->GetType();
3210 switch (bp_type) {
3211 case BreakpointSite::eSoftware:
3212 error = DisableSoftwareBreakpoint(bp_site);
3213 break;
3214
3215 case BreakpointSite::eHardware:
3216 if (m_gdb_comm.SendGDBStoppointTypePacket(type: eBreakpointHardware, insert: false,
3217 addr, length: bp_op_size,
3218 interrupt_timeout: GetInterruptTimeout()))
3219 error = Status::FromErrorString(str: "unknown error");
3220 break;
3221
3222 case BreakpointSite::eExternal: {
3223 if (m_gdb_comm.SendGDBStoppointTypePacket(type: eBreakpointSoftware, insert: false,
3224 addr, length: bp_op_size,
3225 interrupt_timeout: GetInterruptTimeout()))
3226 error = Status::FromErrorString(str: "unknown error");
3227 } break;
3228 }
3229 if (error.Success())
3230 bp_site->SetEnabled(false);
3231 } else {
3232 LLDB_LOGF(log,
3233 "ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64
3234 ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
3235 site_id, (uint64_t)addr);
3236 return error;
3237 }
3238
3239 if (error.Success())
3240 error = Status::FromErrorString(str: "unknown error");
3241 return error;
3242}
3243
3244// Pre-requisite: wp != NULL.
3245static GDBStoppointType
3246GetGDBStoppointType(const WatchpointResourceSP &wp_res_sp) {
3247 assert(wp_res_sp);
3248 bool read = wp_res_sp->WatchpointResourceRead();
3249 bool write = wp_res_sp->WatchpointResourceWrite();
3250
3251 assert((read || write) &&
3252 "WatchpointResource type is neither read nor write");
3253 if (read && write)
3254 return eWatchpointReadWrite;
3255 else if (read)
3256 return eWatchpointRead;
3257 else
3258 return eWatchpointWrite;
3259}
3260
3261Status ProcessGDBRemote::EnableWatchpoint(WatchpointSP wp_sp, bool notify) {
3262 Status error;
3263 if (!wp_sp) {
3264 error = Status::FromErrorString(str: "No watchpoint specified");
3265 return error;
3266 }
3267 user_id_t watchID = wp_sp->GetID();
3268 addr_t addr = wp_sp->GetLoadAddress();
3269 Log *log(GetLog(mask: GDBRLog::Watchpoints));
3270 LLDB_LOGF(log, "ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64 ")",
3271 watchID);
3272 if (wp_sp->IsEnabled()) {
3273 LLDB_LOGF(log,
3274 "ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64
3275 ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
3276 watchID, (uint64_t)addr);
3277 return error;
3278 }
3279
3280 bool read = wp_sp->WatchpointRead();
3281 bool write = wp_sp->WatchpointWrite() || wp_sp->WatchpointModify();
3282 size_t size = wp_sp->GetByteSize();
3283
3284 ArchSpec target_arch = GetTarget().GetArchitecture();
3285 WatchpointHardwareFeature supported_features =
3286 m_gdb_comm.GetSupportedWatchpointTypes();
3287
3288 std::vector<WatchpointResourceSP> resources =
3289 WatchpointAlgorithms::AtomizeWatchpointRequest(
3290 addr, size, read, write, supported_features, arch&: target_arch);
3291
3292 // LWP_TODO: Now that we know the WP Resources needed to implement this
3293 // Watchpoint, we need to look at currently allocated Resources in the
3294 // Process and if they match, or are within the same memory granule, or
3295 // overlapping memory ranges, then we need to combine them. e.g. one
3296 // Watchpoint watching 1 byte at 0x1002 and a second watchpoint watching 1
3297 // byte at 0x1003, they must use the same hardware watchpoint register
3298 // (Resource) to watch them.
3299
3300 // This may mean that an existing resource changes its type (read to
3301 // read+write) or address range it is watching, in which case the old
3302 // watchpoint needs to be disabled and the new Resource addr/size/type
3303 // watchpoint enabled.
3304
3305 // If we modify a shared Resource to accomodate this newly added Watchpoint,
3306 // and we are unable to set all of the Resources for it in the inferior, we
3307 // will return an error for this Watchpoint and the shared Resource should
3308 // be restored. e.g. this Watchpoint requires three Resources, one which
3309 // is shared with another Watchpoint. We extend the shared Resouce to
3310 // handle both Watchpoints and we try to set two new ones. But if we don't
3311 // have sufficient watchpoint register for all 3, we need to show an error
3312 // for creating this Watchpoint and we should reset the shared Resource to
3313 // its original configuration because it is no longer shared.
3314
3315 bool set_all_resources = true;
3316 std::vector<WatchpointResourceSP> succesfully_set_resources;
3317 for (const auto &wp_res_sp : resources) {
3318 addr_t addr = wp_res_sp->GetLoadAddress();
3319 size_t size = wp_res_sp->GetByteSize();
3320 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
3321 if (!m_gdb_comm.SupportsGDBStoppointPacket(type) ||
3322 m_gdb_comm.SendGDBStoppointTypePacket(type, insert: true, addr, length: size,
3323 interrupt_timeout: GetInterruptTimeout())) {
3324 set_all_resources = false;
3325 break;
3326 } else {
3327 succesfully_set_resources.push_back(x: wp_res_sp);
3328 }
3329 }
3330 if (set_all_resources) {
3331 wp_sp->SetEnabled(enabled: true, notify);
3332 for (const auto &wp_res_sp : resources) {
3333 // LWP_TODO: If we expanded/reused an existing Resource,
3334 // it's already in the WatchpointResourceList.
3335 wp_res_sp->AddConstituent(constituent: wp_sp);
3336 m_watchpoint_resource_list.Add(site_sp: wp_res_sp);
3337 }
3338 return error;
3339 } else {
3340 // We failed to allocate one of the resources. Unset all
3341 // of the new resources we did successfully set in the
3342 // process.
3343 for (const auto &wp_res_sp : succesfully_set_resources) {
3344 addr_t addr = wp_res_sp->GetLoadAddress();
3345 size_t size = wp_res_sp->GetByteSize();
3346 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
3347 m_gdb_comm.SendGDBStoppointTypePacket(type, insert: false, addr, length: size,
3348 interrupt_timeout: GetInterruptTimeout());
3349 }
3350 error = Status::FromErrorString(
3351 str: "Setting one of the watchpoint resources failed");
3352 }
3353 return error;
3354}
3355
3356Status ProcessGDBRemote::DisableWatchpoint(WatchpointSP wp_sp, bool notify) {
3357 Status error;
3358 if (!wp_sp) {
3359 error = Status::FromErrorString(str: "Watchpoint argument was NULL.");
3360 return error;
3361 }
3362
3363 user_id_t watchID = wp_sp->GetID();
3364
3365 Log *log(GetLog(mask: GDBRLog::Watchpoints));
3366
3367 addr_t addr = wp_sp->GetLoadAddress();
3368
3369 LLDB_LOGF(log,
3370 "ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
3371 ") addr = 0x%8.8" PRIx64,
3372 watchID, (uint64_t)addr);
3373
3374 if (!wp_sp->IsEnabled()) {
3375 LLDB_LOGF(log,
3376 "ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
3377 ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
3378 watchID, (uint64_t)addr);
3379 // See also 'class WatchpointSentry' within StopInfo.cpp. This disabling
3380 // attempt might come from the user-supplied actions, we'll route it in
3381 // order for the watchpoint object to intelligently process this action.
3382 wp_sp->SetEnabled(enabled: false, notify);
3383 return error;
3384 }
3385
3386 if (wp_sp->IsHardware()) {
3387 bool disabled_all = true;
3388
3389 std::vector<WatchpointResourceSP> unused_resources;
3390 for (const auto &wp_res_sp : m_watchpoint_resource_list.Sites()) {
3391 if (wp_res_sp->ConstituentsContains(wp_sp)) {
3392 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
3393 addr_t addr = wp_res_sp->GetLoadAddress();
3394 size_t size = wp_res_sp->GetByteSize();
3395 if (m_gdb_comm.SendGDBStoppointTypePacket(type, insert: false, addr, length: size,
3396 interrupt_timeout: GetInterruptTimeout())) {
3397 disabled_all = false;
3398 } else {
3399 wp_res_sp->RemoveConstituent(constituent&: wp_sp);
3400 if (wp_res_sp->GetNumberOfConstituents() == 0)
3401 unused_resources.push_back(x: wp_res_sp);
3402 }
3403 }
3404 }
3405 for (auto &wp_res_sp : unused_resources)
3406 m_watchpoint_resource_list.Remove(site_id: wp_res_sp->GetID());
3407
3408 wp_sp->SetEnabled(enabled: false, notify);
3409 if (!disabled_all)
3410 error = Status::FromErrorString(
3411 str: "Failure disabling one of the watchpoint locations");
3412 }
3413 return error;
3414}
3415
3416void ProcessGDBRemote::Clear() {
3417 m_thread_list_real.Clear();
3418 m_thread_list.Clear();
3419}
3420
3421Status ProcessGDBRemote::DoSignal(int signo) {
3422 Status error;
3423 Log *log = GetLog(mask: GDBRLog::Process);
3424 LLDB_LOGF(log, "ProcessGDBRemote::DoSignal (signal = %d)", signo);
3425
3426 if (!m_gdb_comm.SendAsyncSignal(signo, interrupt_timeout: GetInterruptTimeout()))
3427 error =
3428 Status::FromErrorStringWithFormat(format: "failed to send signal %i", signo);
3429 return error;
3430}
3431
3432Status
3433ProcessGDBRemote::EstablishConnectionIfNeeded(const ProcessInfo &process_info) {
3434 // Make sure we aren't already connected?
3435 if (m_gdb_comm.IsConnected())
3436 return Status();
3437
3438 PlatformSP platform_sp(GetTarget().GetPlatform());
3439 if (platform_sp && !platform_sp->IsHost())
3440 return Status::FromErrorString(str: "Lost debug server connection");
3441
3442 auto error = LaunchAndConnectToDebugserver(process_info);
3443 if (error.Fail()) {
3444 const char *error_string = error.AsCString();
3445 if (error_string == nullptr)
3446 error_string = "unable to launch " DEBUGSERVER_BASENAME;
3447 }
3448 return error;
3449}
3450#if !defined(_WIN32)
3451#define USE_SOCKETPAIR_FOR_LOCAL_CONNECTION 1
3452#endif
3453
3454#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3455static bool SetCloexecFlag(int fd) {
3456#if defined(FD_CLOEXEC)
3457 int flags = ::fcntl(fd: fd, F_GETFD);
3458 if (flags == -1)
3459 return false;
3460 return (::fcntl(fd: fd, F_SETFD, flags | FD_CLOEXEC) == 0);
3461#else
3462 return false;
3463#endif
3464}
3465#endif
3466
3467Status ProcessGDBRemote::LaunchAndConnectToDebugserver(
3468 const ProcessInfo &process_info) {
3469 using namespace std::placeholders; // For _1, _2, etc.
3470
3471 Status error;
3472 if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID) {
3473 // If we locate debugserver, keep that located version around
3474 static FileSpec g_debugserver_file_spec;
3475
3476 ProcessLaunchInfo debugserver_launch_info;
3477 // Make debugserver run in its own session so signals generated by special
3478 // terminal key sequences (^C) don't affect debugserver.
3479 debugserver_launch_info.SetLaunchInSeparateProcessGroup(true);
3480
3481 const std::weak_ptr<ProcessGDBRemote> this_wp =
3482 std::static_pointer_cast<ProcessGDBRemote>(r: shared_from_this());
3483 debugserver_launch_info.SetMonitorProcessCallback(
3484 std::bind(f&: MonitorDebugserverProcess, args: this_wp, args: _1, args: _2, args: _3));
3485 debugserver_launch_info.SetUserID(process_info.GetUserID());
3486
3487#if defined(__APPLE__)
3488 // On macOS 11, we need to support x86_64 applications translated to
3489 // arm64. We check whether a binary is translated and spawn the correct
3490 // debugserver accordingly.
3491 int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
3492 static_cast<int>(process_info.GetProcessID()) };
3493 struct kinfo_proc processInfo;
3494 size_t bufsize = sizeof(processInfo);
3495 if (sysctl(mib, (unsigned)(sizeof(mib)/sizeof(int)), &processInfo,
3496 &bufsize, NULL, 0) == 0 && bufsize > 0) {
3497 if (processInfo.kp_proc.p_flag & P_TRANSLATED) {
3498 FileSpec rosetta_debugserver("/Library/Apple/usr/libexec/oah/debugserver");
3499 debugserver_launch_info.SetExecutableFile(rosetta_debugserver, false);
3500 }
3501 }
3502#endif
3503
3504 shared_fd_t communication_fd = SharedSocket::kInvalidFD;
3505#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3506 // Use a socketpair on non-Windows systems for security and performance
3507 // reasons.
3508 int sockets[2]; /* the pair of socket descriptors */
3509 if (socketpair(AF_UNIX, SOCK_STREAM, protocol: 0, fds: sockets) == -1) {
3510 error = Status::FromErrno();
3511 return error;
3512 }
3513
3514 int our_socket = sockets[0];
3515 int gdb_socket = sockets[1];
3516 auto cleanup_our = llvm::make_scope_exit(F: [&]() { close(fd: our_socket); });
3517 auto cleanup_gdb = llvm::make_scope_exit(F: [&]() { close(fd: gdb_socket); });
3518
3519 // Don't let any child processes inherit our communication socket
3520 SetCloexecFlag(our_socket);
3521 communication_fd = gdb_socket;
3522#endif
3523
3524 error = m_gdb_comm.StartDebugserverProcess(
3525 url: nullptr, platform: GetTarget().GetPlatform().get(), launch_info&: debugserver_launch_info,
3526 port: nullptr, inferior_args: nullptr, pass_comm_fd: communication_fd);
3527
3528 if (error.Success())
3529 m_debugserver_pid = debugserver_launch_info.GetProcessID();
3530 else
3531 m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
3532
3533 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) {
3534#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3535 // Our process spawned correctly, we can now set our connection to use
3536 // our end of the socket pair
3537 cleanup_our.release();
3538 m_gdb_comm.SetConnection(
3539 std::make_unique<ConnectionFileDescriptor>(args&: our_socket, args: true));
3540#endif
3541 StartAsyncThread();
3542 }
3543
3544 if (error.Fail()) {
3545 Log *log = GetLog(mask: GDBRLog::Process);
3546
3547 LLDB_LOGF(log, "failed to start debugserver process: %s",
3548 error.AsCString());
3549 return error;
3550 }
3551
3552 if (m_gdb_comm.IsConnected()) {
3553 // Finish the connection process by doing the handshake without
3554 // connecting (send NULL URL)
3555 error = ConnectToDebugserver(connect_url: "");
3556 } else {
3557 error = Status::FromErrorString(str: "connection failed");
3558 }
3559 }
3560 return error;
3561}
3562
3563void ProcessGDBRemote::MonitorDebugserverProcess(
3564 std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid,
3565 int signo, // Zero for no signal
3566 int exit_status // Exit value of process if signal is zero
3567) {
3568 // "debugserver_pid" argument passed in is the process ID for debugserver
3569 // that we are tracking...
3570 Log *log = GetLog(mask: GDBRLog::Process);
3571
3572 LLDB_LOGF(log,
3573 "ProcessGDBRemote::%s(process_wp, pid=%" PRIu64
3574 ", signo=%i (0x%x), exit_status=%i)",
3575 __FUNCTION__, debugserver_pid, signo, signo, exit_status);
3576
3577 std::shared_ptr<ProcessGDBRemote> process_sp = process_wp.lock();
3578 LLDB_LOGF(log, "ProcessGDBRemote::%s(process = %p)", __FUNCTION__,
3579 static_cast<void *>(process_sp.get()));
3580 if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
3581 return;
3582
3583 // Sleep for a half a second to make sure our inferior process has time to
3584 // set its exit status before we set it incorrectly when both the debugserver
3585 // and the inferior process shut down.
3586 std::this_thread::sleep_for(rtime: std::chrono::milliseconds(500));
3587
3588 // If our process hasn't yet exited, debugserver might have died. If the
3589 // process did exit, then we are reaping it.
3590 const StateType state = process_sp->GetState();
3591
3592 if (state != eStateInvalid && state != eStateUnloaded &&
3593 state != eStateExited && state != eStateDetached) {
3594 StreamString stream;
3595 if (signo == 0)
3596 stream.Format(DEBUGSERVER_BASENAME " died with an exit status of {0:x8}",
3597 args&: exit_status);
3598 else {
3599 llvm::StringRef signal_name =
3600 process_sp->GetUnixSignals()->GetSignalAsStringRef(signo);
3601 const char *format_str = DEBUGSERVER_BASENAME " died with signal {0}";
3602 if (!signal_name.empty())
3603 stream.Format(format: format_str, args&: signal_name);
3604 else
3605 stream.Format(format: format_str, args&: signo);
3606 }
3607 process_sp->SetExitStatus(exit_status: -1, exit_string: stream.GetString());
3608 }
3609 // Debugserver has exited we need to let our ProcessGDBRemote know that it no
3610 // longer has a debugserver instance
3611 process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
3612}
3613
3614void ProcessGDBRemote::KillDebugserverProcess() {
3615 m_gdb_comm.Disconnect();
3616 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) {
3617 Host::Kill(pid: m_debugserver_pid, SIGINT);
3618 m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
3619 }
3620}
3621
3622void ProcessGDBRemote::Initialize() {
3623 static llvm::once_flag g_once_flag;
3624
3625 llvm::call_once(flag&: g_once_flag, F: []() {
3626 PluginManager::RegisterPlugin(name: GetPluginNameStatic(),
3627 description: GetPluginDescriptionStatic(), create_callback: CreateInstance,
3628 debugger_init_callback: DebuggerInitialize);
3629 });
3630}
3631
3632void ProcessGDBRemote::DebuggerInitialize(Debugger &debugger) {
3633 if (!PluginManager::GetSettingForProcessPlugin(
3634 debugger, setting_name: PluginProperties::GetSettingName())) {
3635 const bool is_global_setting = true;
3636 PluginManager::CreateSettingForProcessPlugin(
3637 debugger, properties_sp: GetGlobalPluginProperties().GetValueProperties(),
3638 description: "Properties for the gdb-remote process plug-in.", is_global_property: is_global_setting);
3639 }
3640}
3641
3642bool ProcessGDBRemote::StartAsyncThread() {
3643 Log *log = GetLog(mask: GDBRLog::Process);
3644
3645 LLDB_LOGF(log, "ProcessGDBRemote::%s ()", __FUNCTION__);
3646
3647 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3648 if (!m_async_thread.IsJoinable()) {
3649 // Create a thread that watches our internal state and controls which
3650 // events make it to clients (into the DCProcess event queue).
3651
3652 llvm::Expected<HostThread> async_thread =
3653 ThreadLauncher::LaunchThread(name: "<lldb.process.gdb-remote.async>", thread_function: [this] {
3654 return ProcessGDBRemote::AsyncThread();
3655 });
3656 if (!async_thread) {
3657 LLDB_LOG_ERROR(GetLog(LLDBLog::Host), async_thread.takeError(),
3658 "failed to launch host thread: {0}");
3659 return false;
3660 }
3661 m_async_thread = *async_thread;
3662 } else
3663 LLDB_LOGF(log,
3664 "ProcessGDBRemote::%s () - Called when Async thread was "
3665 "already running.",
3666 __FUNCTION__);
3667
3668 return m_async_thread.IsJoinable();
3669}
3670
3671void ProcessGDBRemote::StopAsyncThread() {
3672 Log *log = GetLog(mask: GDBRLog::Process);
3673
3674 LLDB_LOGF(log, "ProcessGDBRemote::%s ()", __FUNCTION__);
3675
3676 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3677 if (m_async_thread.IsJoinable()) {
3678 m_async_broadcaster.BroadcastEvent(event_type: eBroadcastBitAsyncThreadShouldExit);
3679
3680 // This will shut down the async thread.
3681 m_gdb_comm.Disconnect(); // Disconnect from the debug server.
3682
3683 // Stop the stdio thread
3684 m_async_thread.Join(result: nullptr);
3685 m_async_thread.Reset();
3686 } else
3687 LLDB_LOGF(
3688 log,
3689 "ProcessGDBRemote::%s () - Called when Async thread was not running.",
3690 __FUNCTION__);
3691}
3692
3693thread_result_t ProcessGDBRemote::AsyncThread() {
3694 Log *log = GetLog(mask: GDBRLog::Process);
3695 LLDB_LOGF(log, "ProcessGDBRemote::%s(pid = %" PRIu64 ") thread starting...",
3696 __FUNCTION__, GetID());
3697
3698 EventSP event_sp;
3699
3700 // We need to ignore any packets that come in after we have
3701 // have decided the process has exited. There are some
3702 // situations, for instance when we try to interrupt a running
3703 // process and the interrupt fails, where another packet might
3704 // get delivered after we've decided to give up on the process.
3705 // But once we've decided we are done with the process we will
3706 // not be in a state to do anything useful with new packets.
3707 // So it is safer to simply ignore any remaining packets by
3708 // explicitly checking for eStateExited before reentering the
3709 // fetch loop.
3710
3711 bool done = false;
3712 while (!done && GetPrivateState() != eStateExited) {
3713 LLDB_LOGF(log,
3714 "ProcessGDBRemote::%s(pid = %" PRIu64
3715 ") listener.WaitForEvent (NULL, event_sp)...",
3716 __FUNCTION__, GetID());
3717
3718 if (m_async_listener_sp->GetEvent(event_sp, timeout: std::nullopt)) {
3719 const uint32_t event_type = event_sp->GetType();
3720 if (event_sp->BroadcasterIs(broadcaster: &m_async_broadcaster)) {
3721 LLDB_LOGF(log,
3722 "ProcessGDBRemote::%s(pid = %" PRIu64
3723 ") Got an event of type: %d...",
3724 __FUNCTION__, GetID(), event_type);
3725
3726 switch (event_type) {
3727 case eBroadcastBitAsyncContinue: {
3728 const EventDataBytes *continue_packet =
3729 EventDataBytes::GetEventDataFromEvent(event_ptr: event_sp.get());
3730
3731 if (continue_packet) {
3732 const char *continue_cstr =
3733 (const char *)continue_packet->GetBytes();
3734 const size_t continue_cstr_len = continue_packet->GetByteSize();
3735 LLDB_LOGF(log,
3736 "ProcessGDBRemote::%s(pid = %" PRIu64
3737 ") got eBroadcastBitAsyncContinue: %s",
3738 __FUNCTION__, GetID(), continue_cstr);
3739
3740 if (::strstr(haystack: continue_cstr, needle: "vAttach") == nullptr)
3741 SetPrivateState(eStateRunning);
3742 StringExtractorGDBRemote response;
3743
3744 StateType stop_state =
3745 GetGDBRemote().SendContinuePacketAndWaitForResponse(
3746 delegate&: *this, signals: *GetUnixSignals(),
3747 payload: llvm::StringRef(continue_cstr, continue_cstr_len),
3748 interrupt_timeout: GetInterruptTimeout(), response);
3749
3750 // We need to immediately clear the thread ID list so we are sure
3751 // to get a valid list of threads. The thread ID list might be
3752 // contained within the "response", or the stop reply packet that
3753 // caused the stop. So clear it now before we give the stop reply
3754 // packet to the process using the
3755 // SetLastStopPacket()...
3756 ClearThreadIDList();
3757
3758 switch (stop_state) {
3759 case eStateStopped:
3760 case eStateCrashed:
3761 case eStateSuspended:
3762 SetLastStopPacket(response);
3763 SetPrivateState(stop_state);
3764 break;
3765
3766 case eStateExited: {
3767 SetLastStopPacket(response);
3768 ClearThreadIDList();
3769 response.SetFilePos(1);
3770
3771 int exit_status = response.GetHexU8();
3772 std::string desc_string;
3773 if (response.GetBytesLeft() > 0 && response.GetChar(fail_value: '-') == ';') {
3774 llvm::StringRef desc_str;
3775 llvm::StringRef desc_token;
3776 while (response.GetNameColonValue(name&: desc_token, value&: desc_str)) {
3777 if (desc_token != "description")
3778 continue;
3779 StringExtractor extractor(desc_str);
3780 extractor.GetHexByteString(str&: desc_string);
3781 }
3782 }
3783 SetExitStatus(exit_status, exit_string: desc_string.c_str());
3784 done = true;
3785 break;
3786 }
3787 case eStateInvalid: {
3788 // Check to see if we were trying to attach and if we got back
3789 // the "E87" error code from debugserver -- this indicates that
3790 // the process is not debuggable. Return a slightly more
3791 // helpful error message about why the attach failed.
3792 if (::strstr(haystack: continue_cstr, needle: "vAttach") != nullptr &&
3793 response.GetError() == 0x87) {
3794 SetExitStatus(exit_status: -1, exit_string: "cannot attach to process due to "
3795 "System Integrity Protection");
3796 } else if (::strstr(haystack: continue_cstr, needle: "vAttach") != nullptr &&
3797 response.GetStatus().Fail()) {
3798 SetExitStatus(exit_status: -1, exit_string: response.GetStatus().AsCString());
3799 } else {
3800 SetExitStatus(exit_status: -1, exit_string: "lost connection");
3801 }
3802 done = true;
3803 break;
3804 }
3805
3806 default:
3807 SetPrivateState(stop_state);
3808 break;
3809 } // switch(stop_state)
3810 } // if (continue_packet)
3811 } // case eBroadcastBitAsyncContinue
3812 break;
3813
3814 case eBroadcastBitAsyncThreadShouldExit:
3815 LLDB_LOGF(log,
3816 "ProcessGDBRemote::%s(pid = %" PRIu64
3817 ") got eBroadcastBitAsyncThreadShouldExit...",
3818 __FUNCTION__, GetID());
3819 done = true;
3820 break;
3821
3822 default:
3823 LLDB_LOGF(log,
3824 "ProcessGDBRemote::%s(pid = %" PRIu64
3825 ") got unknown event 0x%8.8x",
3826 __FUNCTION__, GetID(), event_type);
3827 done = true;
3828 break;
3829 }
3830 }
3831 } else {
3832 LLDB_LOGF(log,
3833 "ProcessGDBRemote::%s(pid = %" PRIu64
3834 ") listener.WaitForEvent (NULL, event_sp) => false",
3835 __FUNCTION__, GetID());
3836 done = true;
3837 }
3838 }
3839
3840 LLDB_LOGF(log, "ProcessGDBRemote::%s(pid = %" PRIu64 ") thread exiting...",
3841 __FUNCTION__, GetID());
3842
3843 return {};
3844}
3845
3846// uint32_t
3847// ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList
3848// &matches, std::vector<lldb::pid_t> &pids)
3849//{
3850// // If we are planning to launch the debugserver remotely, then we need to
3851// fire up a debugserver
3852// // process and ask it for the list of processes. But if we are local, we
3853// can let the Host do it.
3854// if (m_local_debugserver)
3855// {
3856// return Host::ListProcessesMatchingName (name, matches, pids);
3857// }
3858// else
3859// {
3860// // FIXME: Implement talking to the remote debugserver.
3861// return 0;
3862// }
3863//
3864//}
3865//
3866bool ProcessGDBRemote::NewThreadNotifyBreakpointHit(
3867 void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
3868 lldb::user_id_t break_loc_id) {
3869 // I don't think I have to do anything here, just make sure I notice the new
3870 // thread when it starts to
3871 // run so I can stop it if that's what I want to do.
3872 Log *log = GetLog(mask: LLDBLog::Step);
3873 LLDB_LOGF(log, "Hit New Thread Notification breakpoint.");
3874 return false;
3875}
3876
3877Status ProcessGDBRemote::UpdateAutomaticSignalFiltering() {
3878 Log *log = GetLog(mask: GDBRLog::Process);
3879 LLDB_LOG(log, "Check if need to update ignored signals");
3880
3881 // QPassSignals package is not supported by the server, there is no way we
3882 // can ignore any signals on server side.
3883 if (!m_gdb_comm.GetQPassSignalsSupported())
3884 return Status();
3885
3886 // No signals, nothing to send.
3887 if (m_unix_signals_sp == nullptr)
3888 return Status();
3889
3890 // Signals' version hasn't changed, no need to send anything.
3891 uint64_t new_signals_version = m_unix_signals_sp->GetVersion();
3892 if (new_signals_version == m_last_signals_version) {
3893 LLDB_LOG(log, "Signals' version hasn't changed. version={0}",
3894 m_last_signals_version);
3895 return Status();
3896 }
3897
3898 auto signals_to_ignore =
3899 m_unix_signals_sp->GetFilteredSignals(should_suppress: false, should_stop: false, should_notify: false);
3900 Status error = m_gdb_comm.SendSignalsToIgnore(signals: signals_to_ignore);
3901
3902 LLDB_LOG(log,
3903 "Signals' version changed. old version={0}, new version={1}, "
3904 "signals ignored={2}, update result={3}",
3905 m_last_signals_version, new_signals_version,
3906 signals_to_ignore.size(), error);
3907
3908 if (error.Success())
3909 m_last_signals_version = new_signals_version;
3910
3911 return error;
3912}
3913
3914bool ProcessGDBRemote::StartNoticingNewThreads() {
3915 Log *log = GetLog(mask: LLDBLog::Step);
3916 if (m_thread_create_bp_sp) {
3917 if (log && log->GetVerbose())
3918 LLDB_LOGF(log, "Enabled noticing new thread breakpoint.");
3919 m_thread_create_bp_sp->SetEnabled(true);
3920 } else {
3921 PlatformSP platform_sp(GetTarget().GetPlatform());
3922 if (platform_sp) {
3923 m_thread_create_bp_sp =
3924 platform_sp->SetThreadCreationBreakpoint(GetTarget());
3925 if (m_thread_create_bp_sp) {
3926 if (log && log->GetVerbose())
3927 LLDB_LOGF(
3928 log, "Successfully created new thread notification breakpoint %i",
3929 m_thread_create_bp_sp->GetID());
3930 m_thread_create_bp_sp->SetCallback(
3931 callback: ProcessGDBRemote::NewThreadNotifyBreakpointHit, baton: this, is_synchronous: true);
3932 } else {
3933 LLDB_LOGF(log, "Failed to create new thread notification breakpoint.");
3934 }
3935 }
3936 }
3937 return m_thread_create_bp_sp.get() != nullptr;
3938}
3939
3940bool ProcessGDBRemote::StopNoticingNewThreads() {
3941 Log *log = GetLog(mask: LLDBLog::Step);
3942 if (log && log->GetVerbose())
3943 LLDB_LOGF(log, "Disabling new thread notification breakpoint.");
3944
3945 if (m_thread_create_bp_sp)
3946 m_thread_create_bp_sp->SetEnabled(false);
3947
3948 return true;
3949}
3950
3951DynamicLoader *ProcessGDBRemote::GetDynamicLoader() {
3952 if (m_dyld_up.get() == nullptr)
3953 m_dyld_up.reset(p: DynamicLoader::FindPlugin(process: this, plugin_name: ""));
3954 return m_dyld_up.get();
3955}
3956
3957Status ProcessGDBRemote::SendEventData(const char *data) {
3958 int return_value;
3959 bool was_supported;
3960
3961 Status error;
3962
3963 return_value = m_gdb_comm.SendLaunchEventDataPacket(data, was_supported: &was_supported);
3964 if (return_value != 0) {
3965 if (!was_supported)
3966 error = Status::FromErrorString(
3967 str: "Sending events is not supported for this process.");
3968 else
3969 error = Status::FromErrorStringWithFormat(format: "Error sending event data: %d.",
3970 return_value);
3971 }
3972 return error;
3973}
3974
3975DataExtractor ProcessGDBRemote::GetAuxvData() {
3976 DataBufferSP buf;
3977 if (m_gdb_comm.GetQXferAuxvReadSupported()) {
3978 llvm::Expected<std::string> response = m_gdb_comm.ReadExtFeature(object: "auxv", annex: "");
3979 if (response)
3980 buf = std::make_shared<DataBufferHeap>(args: response->c_str(),
3981 args: response->length());
3982 else
3983 LLDB_LOG_ERROR(GetLog(GDBRLog::Process), response.takeError(), "{0}");
3984 }
3985 return DataExtractor(buf, GetByteOrder(), GetAddressByteSize());
3986}
3987
3988StructuredData::ObjectSP
3989ProcessGDBRemote::GetExtendedInfoForThread(lldb::tid_t tid) {
3990 StructuredData::ObjectSP object_sp;
3991
3992 if (m_gdb_comm.GetThreadExtendedInfoSupported()) {
3993 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
3994 SystemRuntime *runtime = GetSystemRuntime();
3995 if (runtime) {
3996 runtime->AddThreadExtendedInfoPacketHints(dict: args_dict);
3997 }
3998 args_dict->GetAsDictionary()->AddIntegerItem(key: "thread", value: tid);
3999
4000 StreamString packet;
4001 packet << "jThreadExtendedInfo:";
4002 args_dict->Dump(s&: packet, pretty_print: false);
4003
4004 // FIXME the final character of a JSON dictionary, '}', is the escape
4005 // character in gdb-remote binary mode. lldb currently doesn't escape
4006 // these characters in its packet output -- so we add the quoted version of
4007 // the } character here manually in case we talk to a debugserver which un-
4008 // escapes the characters at packet read time.
4009 packet << (char)(0x7d ^ 0x20);
4010
4011 StringExtractorGDBRemote response;
4012 response.SetResponseValidatorToJSON();
4013 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response) ==
4014 GDBRemoteCommunication::PacketResult::Success) {
4015 StringExtractorGDBRemote::ResponseType response_type =
4016 response.GetResponseType();
4017 if (response_type == StringExtractorGDBRemote::eResponse) {
4018 if (!response.Empty()) {
4019 object_sp = StructuredData::ParseJSON(json_text: response.GetStringRef());
4020 }
4021 }
4022 }
4023 }
4024 return object_sp;
4025}
4026
4027StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos(
4028 lldb::addr_t image_list_address, lldb::addr_t image_count) {
4029
4030 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
4031 args_dict->GetAsDictionary()->AddIntegerItem(key: "image_list_address",
4032 value: image_list_address);
4033 args_dict->GetAsDictionary()->AddIntegerItem(key: "image_count", value: image_count);
4034
4035 return GetLoadedDynamicLibrariesInfos_sender(args: args_dict);
4036}
4037
4038StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos() {
4039 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
4040
4041 args_dict->GetAsDictionary()->AddBooleanItem(key: "fetch_all_solibs", value: true);
4042
4043 return GetLoadedDynamicLibrariesInfos_sender(args: args_dict);
4044}
4045
4046StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos(
4047 const std::vector<lldb::addr_t> &load_addresses) {
4048 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
4049 StructuredData::ArraySP addresses(new StructuredData::Array);
4050
4051 for (auto addr : load_addresses)
4052 addresses->AddIntegerItem(value: addr);
4053
4054 args_dict->GetAsDictionary()->AddItem(key: "solib_addresses", value_sp: addresses);
4055
4056 return GetLoadedDynamicLibrariesInfos_sender(args: args_dict);
4057}
4058
4059StructuredData::ObjectSP
4060ProcessGDBRemote::GetLoadedDynamicLibrariesInfos_sender(
4061 StructuredData::ObjectSP args_dict) {
4062 StructuredData::ObjectSP object_sp;
4063
4064 if (m_gdb_comm.GetLoadedDynamicLibrariesInfosSupported()) {
4065 // Scope for the scoped timeout object
4066 GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
4067 std::chrono::seconds(10));
4068
4069 StreamString packet;
4070 packet << "jGetLoadedDynamicLibrariesInfos:";
4071 args_dict->Dump(s&: packet, pretty_print: false);
4072
4073 // FIXME the final character of a JSON dictionary, '}', is the escape
4074 // character in gdb-remote binary mode. lldb currently doesn't escape
4075 // these characters in its packet output -- so we add the quoted version of
4076 // the } character here manually in case we talk to a debugserver which un-
4077 // escapes the characters at packet read time.
4078 packet << (char)(0x7d ^ 0x20);
4079
4080 StringExtractorGDBRemote response;
4081 response.SetResponseValidatorToJSON();
4082 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response) ==
4083 GDBRemoteCommunication::PacketResult::Success) {
4084 StringExtractorGDBRemote::ResponseType response_type =
4085 response.GetResponseType();
4086 if (response_type == StringExtractorGDBRemote::eResponse) {
4087 if (!response.Empty()) {
4088 object_sp = StructuredData::ParseJSON(json_text: response.GetStringRef());
4089 }
4090 }
4091 }
4092 }
4093 return object_sp;
4094}
4095
4096StructuredData::ObjectSP ProcessGDBRemote::GetDynamicLoaderProcessState() {
4097 StructuredData::ObjectSP object_sp;
4098 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
4099
4100 if (m_gdb_comm.GetDynamicLoaderProcessStateSupported()) {
4101 StringExtractorGDBRemote response;
4102 response.SetResponseValidatorToJSON();
4103 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: "jGetDyldProcessState",
4104 response) ==
4105 GDBRemoteCommunication::PacketResult::Success) {
4106 StringExtractorGDBRemote::ResponseType response_type =
4107 response.GetResponseType();
4108 if (response_type == StringExtractorGDBRemote::eResponse) {
4109 if (!response.Empty()) {
4110 object_sp = StructuredData::ParseJSON(json_text: response.GetStringRef());
4111 }
4112 }
4113 }
4114 }
4115 return object_sp;
4116}
4117
4118StructuredData::ObjectSP ProcessGDBRemote::GetSharedCacheInfo() {
4119 StructuredData::ObjectSP object_sp;
4120 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
4121
4122 if (m_gdb_comm.GetSharedCacheInfoSupported()) {
4123 StreamString packet;
4124 packet << "jGetSharedCacheInfo:";
4125 args_dict->Dump(s&: packet, pretty_print: false);
4126
4127 // FIXME the final character of a JSON dictionary, '}', is the escape
4128 // character in gdb-remote binary mode. lldb currently doesn't escape
4129 // these characters in its packet output -- so we add the quoted version of
4130 // the } character here manually in case we talk to a debugserver which un-
4131 // escapes the characters at packet read time.
4132 packet << (char)(0x7d ^ 0x20);
4133
4134 StringExtractorGDBRemote response;
4135 response.SetResponseValidatorToJSON();
4136 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response) ==
4137 GDBRemoteCommunication::PacketResult::Success) {
4138 StringExtractorGDBRemote::ResponseType response_type =
4139 response.GetResponseType();
4140 if (response_type == StringExtractorGDBRemote::eResponse) {
4141 if (!response.Empty()) {
4142 object_sp = StructuredData::ParseJSON(json_text: response.GetStringRef());
4143 }
4144 }
4145 }
4146 }
4147 return object_sp;
4148}
4149
4150Status ProcessGDBRemote::ConfigureStructuredData(
4151 llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp) {
4152 return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
4153}
4154
4155// Establish the largest memory read/write payloads we should use. If the
4156// remote stub has a max packet size, stay under that size.
4157//
4158// If the remote stub's max packet size is crazy large, use a reasonable
4159// largeish default.
4160//
4161// If the remote stub doesn't advertise a max packet size, use a conservative
4162// default.
4163
4164void ProcessGDBRemote::GetMaxMemorySize() {
4165 const uint64_t reasonable_largeish_default = 128 * 1024;
4166 const uint64_t conservative_default = 512;
4167
4168 if (m_max_memory_size == 0) {
4169 uint64_t stub_max_size = m_gdb_comm.GetRemoteMaxPacketSize();
4170 if (stub_max_size != UINT64_MAX && stub_max_size != 0) {
4171 // Save the stub's claimed maximum packet size
4172 m_remote_stub_max_memory_size = stub_max_size;
4173
4174 // Even if the stub says it can support ginormous packets, don't exceed
4175 // our reasonable largeish default packet size.
4176 if (stub_max_size > reasonable_largeish_default) {
4177 stub_max_size = reasonable_largeish_default;
4178 }
4179
4180 // Memory packet have other overheads too like Maddr,size:#NN Instead of
4181 // calculating the bytes taken by size and addr every time, we take a
4182 // maximum guess here.
4183 if (stub_max_size > 70)
4184 stub_max_size -= 32 + 32 + 6;
4185 else {
4186 // In unlikely scenario that max packet size is less then 70, we will
4187 // hope that data being written is small enough to fit.
4188 Log *log(GetLog(mask: GDBRLog::Comm | GDBRLog::Memory));
4189 if (log)
4190 log->Warning(fmt: "Packet size is too small. "
4191 "LLDB may face problems while writing memory");
4192 }
4193
4194 m_max_memory_size = stub_max_size;
4195 } else {
4196 m_max_memory_size = conservative_default;
4197 }
4198 }
4199}
4200
4201void ProcessGDBRemote::SetUserSpecifiedMaxMemoryTransferSize(
4202 uint64_t user_specified_max) {
4203 if (user_specified_max != 0) {
4204 GetMaxMemorySize();
4205
4206 if (m_remote_stub_max_memory_size != 0) {
4207 if (m_remote_stub_max_memory_size < user_specified_max) {
4208 m_max_memory_size = m_remote_stub_max_memory_size; // user specified a
4209 // packet size too
4210 // big, go as big
4211 // as the remote stub says we can go.
4212 } else {
4213 m_max_memory_size = user_specified_max; // user's packet size is good
4214 }
4215 } else {
4216 m_max_memory_size =
4217 user_specified_max; // user's packet size is probably fine
4218 }
4219 }
4220}
4221
4222bool ProcessGDBRemote::GetModuleSpec(const FileSpec &module_file_spec,
4223 const ArchSpec &arch,
4224 ModuleSpec &module_spec) {
4225 Log *log = GetLog(mask: LLDBLog::Platform);
4226
4227 const ModuleCacheKey key(module_file_spec.GetPath(),
4228 arch.GetTriple().getTriple());
4229 auto cached = m_cached_module_specs.find(Val: key);
4230 if (cached != m_cached_module_specs.end()) {
4231 module_spec = cached->second;
4232 return bool(module_spec);
4233 }
4234
4235 if (!m_gdb_comm.GetModuleInfo(module_file_spec, arch_spec: arch, module_spec)) {
4236 LLDB_LOGF(log, "ProcessGDBRemote::%s - failed to get module info for %s:%s",
4237 __FUNCTION__, module_file_spec.GetPath().c_str(),
4238 arch.GetTriple().getTriple().c_str());
4239 return false;
4240 }
4241
4242 if (log) {
4243 StreamString stream;
4244 module_spec.Dump(strm&: stream);
4245 LLDB_LOGF(log, "ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
4246 __FUNCTION__, module_file_spec.GetPath().c_str(),
4247 arch.GetTriple().getTriple().c_str(), stream.GetData());
4248 }
4249
4250 m_cached_module_specs[key] = module_spec;
4251 return true;
4252}
4253
4254void ProcessGDBRemote::PrefetchModuleSpecs(
4255 llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
4256 auto module_specs = m_gdb_comm.GetModulesInfo(module_file_specs, triple);
4257 if (module_specs) {
4258 for (const FileSpec &spec : module_file_specs)
4259 m_cached_module_specs[ModuleCacheKey(spec.GetPath(),
4260 triple.getTriple())] = ModuleSpec();
4261 for (const ModuleSpec &spec : *module_specs)
4262 m_cached_module_specs[ModuleCacheKey(spec.GetFileSpec().GetPath(),
4263 triple.getTriple())] = spec;
4264 }
4265}
4266
4267llvm::VersionTuple ProcessGDBRemote::GetHostOSVersion() {
4268 return m_gdb_comm.GetOSVersion();
4269}
4270
4271llvm::VersionTuple ProcessGDBRemote::GetHostMacCatalystVersion() {
4272 return m_gdb_comm.GetMacCatalystVersion();
4273}
4274
4275namespace {
4276
4277typedef std::vector<std::string> stringVec;
4278
4279typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
4280struct RegisterSetInfo {
4281 ConstString name;
4282};
4283
4284typedef std::map<uint32_t, RegisterSetInfo> RegisterSetMap;
4285
4286struct GdbServerTargetInfo {
4287 std::string arch;
4288 std::string osabi;
4289 stringVec includes;
4290 RegisterSetMap reg_set_map;
4291};
4292
4293static FieldEnum::Enumerators ParseEnumEvalues(const XMLNode &enum_node) {
4294 Log *log(GetLog(mask: GDBRLog::Process));
4295 // We will use the last instance of each value. Also we preserve the order
4296 // of declaration in the XML, as it may not be numerical.
4297 // For example, hardware may intially release with two states that softwware
4298 // can read from a register field:
4299 // 0 = startup, 1 = running
4300 // If in a future hardware release, the designers added a pre-startup state:
4301 // 0 = startup, 1 = running, 2 = pre-startup
4302 // Now it makes more sense to list them in this logical order as opposed to
4303 // numerical order:
4304 // 2 = pre-startup, 1 = startup, 0 = startup
4305 // This only matters for "register info" but let's trust what the server
4306 // chose regardless.
4307 std::map<uint64_t, FieldEnum::Enumerator> enumerators;
4308
4309 enum_node.ForEachChildElementWithName(
4310 name: "evalue", callback: [&enumerators, &log](const XMLNode &enumerator_node) {
4311 std::optional<llvm::StringRef> name;
4312 std::optional<uint64_t> value;
4313
4314 enumerator_node.ForEachAttribute(
4315 callback: [&name, &value, &log](const llvm::StringRef &attr_name,
4316 const llvm::StringRef &attr_value) {
4317 if (attr_name == "name") {
4318 if (attr_value.size())
4319 name = attr_value;
4320 else
4321 LLDB_LOG(log, "ProcessGDBRemote::ParseEnumEvalues "
4322 "Ignoring empty name in evalue");
4323 } else if (attr_name == "value") {
4324 uint64_t parsed_value = 0;
4325 if (llvm::to_integer(S: attr_value, Num&: parsed_value))
4326 value = parsed_value;
4327 else
4328 LLDB_LOG(log,
4329 "ProcessGDBRemote::ParseEnumEvalues "
4330 "Invalid value \"{0}\" in "
4331 "evalue",
4332 attr_value.data());
4333 } else
4334 LLDB_LOG(log,
4335 "ProcessGDBRemote::ParseEnumEvalues Ignoring "
4336 "unknown attribute "
4337 "\"{0}\" in evalue",
4338 attr_name.data());
4339
4340 // Keep walking attributes.
4341 return true;
4342 });
4343
4344 if (value && name)
4345 enumerators.insert_or_assign(
4346 k: *value, obj: FieldEnum::Enumerator(*value, name->str()));
4347
4348 // Find all evalue elements.
4349 return true;
4350 });
4351
4352 FieldEnum::Enumerators final_enumerators;
4353 for (auto [_, enumerator] : enumerators)
4354 final_enumerators.push_back(x: enumerator);
4355
4356 return final_enumerators;
4357}
4358
4359static void
4360ParseEnums(XMLNode feature_node,
4361 llvm::StringMap<std::unique_ptr<FieldEnum>> &registers_enum_types) {
4362 Log *log(GetLog(mask: GDBRLog::Process));
4363
4364 // The top level element is "<enum...".
4365 feature_node.ForEachChildElementWithName(
4366 name: "enum", callback: [log, &registers_enum_types](const XMLNode &enum_node) {
4367 std::string id;
4368
4369 enum_node.ForEachAttribute(callback: [&id](const llvm::StringRef &attr_name,
4370 const llvm::StringRef &attr_value) {
4371 if (attr_name == "id")
4372 id = attr_value;
4373
4374 // There is also a "size" attribute that is supposed to be the size in
4375 // bytes of the register this applies to. However:
4376 // * LLDB doesn't need this information.
4377 // * It is difficult to verify because you have to wait until the
4378 // enum is applied to a field.
4379 //
4380 // So we will emit this attribute in XML for GDB's sake, but will not
4381 // bother ingesting it.
4382
4383 // Walk all attributes.
4384 return true;
4385 });
4386
4387 if (!id.empty()) {
4388 FieldEnum::Enumerators enumerators = ParseEnumEvalues(enum_node);
4389 if (!enumerators.empty()) {
4390 LLDB_LOG(log,
4391 "ProcessGDBRemote::ParseEnums Found enum type \"{0}\"",
4392 id);
4393 registers_enum_types.insert_or_assign(
4394 Key: id, Val: std::make_unique<FieldEnum>(args&: id, args&: enumerators));
4395 }
4396 }
4397
4398 // Find all <enum> elements.
4399 return true;
4400 });
4401}
4402
4403static std::vector<RegisterFlags::Field> ParseFlagsFields(
4404 XMLNode flags_node, unsigned size,
4405 const llvm::StringMap<std::unique_ptr<FieldEnum>> &registers_enum_types) {
4406 Log *log(GetLog(mask: GDBRLog::Process));
4407 const unsigned max_start_bit = size * 8 - 1;
4408
4409 // Process the fields of this set of flags.
4410 std::vector<RegisterFlags::Field> fields;
4411 flags_node.ForEachChildElementWithName(name: "field", callback: [&fields, max_start_bit, &log,
4412 &registers_enum_types](
4413 const XMLNode
4414 &field_node) {
4415 std::optional<llvm::StringRef> name;
4416 std::optional<unsigned> start;
4417 std::optional<unsigned> end;
4418 std::optional<llvm::StringRef> type;
4419
4420 field_node.ForEachAttribute(callback: [&name, &start, &end, &type, max_start_bit,
4421 &log](const llvm::StringRef &attr_name,
4422 const llvm::StringRef &attr_value) {
4423 // Note that XML in general requires that each of these attributes only
4424 // appears once, so we don't have to handle that here.
4425 if (attr_name == "name") {
4426 LLDB_LOG(
4427 log,
4428 "ProcessGDBRemote::ParseFlagsFields Found field node name \"{0}\"",
4429 attr_value.data());
4430 name = attr_value;
4431 } else if (attr_name == "start") {
4432 unsigned parsed_start = 0;
4433 if (llvm::to_integer(S: attr_value, Num&: parsed_start)) {
4434 if (parsed_start > max_start_bit) {
4435 LLDB_LOG(log,
4436 "ProcessGDBRemote::ParseFlagsFields Invalid start {0} in "
4437 "field node, "
4438 "cannot be > {1}",
4439 parsed_start, max_start_bit);
4440 } else
4441 start = parsed_start;
4442 } else {
4443 LLDB_LOG(
4444 log,
4445 "ProcessGDBRemote::ParseFlagsFields Invalid start \"{0}\" in "
4446 "field node",
4447 attr_value.data());
4448 }
4449 } else if (attr_name == "end") {
4450 unsigned parsed_end = 0;
4451 if (llvm::to_integer(S: attr_value, Num&: parsed_end))
4452 if (parsed_end > max_start_bit) {
4453 LLDB_LOG(log,
4454 "ProcessGDBRemote::ParseFlagsFields Invalid end {0} in "
4455 "field node, "
4456 "cannot be > {1}",
4457 parsed_end, max_start_bit);
4458 } else
4459 end = parsed_end;
4460 else {
4461 LLDB_LOG(log,
4462 "ProcessGDBRemote::ParseFlagsFields Invalid end \"{0}\" in "
4463 "field node",
4464 attr_value.data());
4465 }
4466 } else if (attr_name == "type") {
4467 type = attr_value;
4468 } else {
4469 LLDB_LOG(
4470 log,
4471 "ProcessGDBRemote::ParseFlagsFields Ignoring unknown attribute "
4472 "\"{0}\" in field node",
4473 attr_name.data());
4474 }
4475
4476 return true; // Walk all attributes of the field.
4477 });
4478
4479 if (name && start && end) {
4480 if (*start > *end)
4481 LLDB_LOG(
4482 log,
4483 "ProcessGDBRemote::ParseFlagsFields Start {0} > end {1} in field "
4484 "\"{2}\", ignoring",
4485 *start, *end, name->data());
4486 else {
4487 if (RegisterFlags::Field::GetSizeInBits(start: *start, end: *end) > 64)
4488 LLDB_LOG(log,
4489 "ProcessGDBRemote::ParseFlagsFields Ignoring field \"{2}\" "
4490 "that has "
4491 "size > 64 bits, this is not supported",
4492 name->data());
4493 else {
4494 // A field's type may be set to the name of an enum type.
4495 const FieldEnum *enum_type = nullptr;
4496 if (type && !type->empty()) {
4497 auto found = registers_enum_types.find(Key: *type);
4498 if (found != registers_enum_types.end()) {
4499 enum_type = found->second.get();
4500
4501 // No enumerator can exceed the range of the field itself.
4502 uint64_t max_value =
4503 RegisterFlags::Field::GetMaxValue(start: *start, end: *end);
4504 for (const auto &enumerator : enum_type->GetEnumerators()) {
4505 if (enumerator.m_value > max_value) {
4506 enum_type = nullptr;
4507 LLDB_LOG(
4508 log,
4509 "ProcessGDBRemote::ParseFlagsFields In enum \"{0}\" "
4510 "evalue \"{1}\" with value {2} exceeds the maximum value "
4511 "of field \"{3}\" ({4}), ignoring enum",
4512 type->data(), enumerator.m_name, enumerator.m_value,
4513 name->data(), max_value);
4514 break;
4515 }
4516 }
4517 } else {
4518 LLDB_LOG(log,
4519 "ProcessGDBRemote::ParseFlagsFields Could not find type "
4520 "\"{0}\" "
4521 "for field \"{1}\", ignoring",
4522 type->data(), name->data());
4523 }
4524 }
4525
4526 fields.push_back(
4527 x: RegisterFlags::Field(name->str(), *start, *end, enum_type));
4528 }
4529 }
4530 }
4531
4532 return true; // Iterate all "field" nodes.
4533 });
4534 return fields;
4535}
4536
4537void ParseFlags(
4538 XMLNode feature_node,
4539 llvm::StringMap<std::unique_ptr<RegisterFlags>> &registers_flags_types,
4540 const llvm::StringMap<std::unique_ptr<FieldEnum>> &registers_enum_types) {
4541 Log *log(GetLog(mask: GDBRLog::Process));
4542
4543 feature_node.ForEachChildElementWithName(
4544 name: "flags",
4545 callback: [&log, &registers_flags_types,
4546 &registers_enum_types](const XMLNode &flags_node) -> bool {
4547 LLDB_LOG(log, "ProcessGDBRemote::ParseFlags Found flags node \"{0}\"",
4548 flags_node.GetAttributeValue("id").c_str());
4549
4550 std::optional<llvm::StringRef> id;
4551 std::optional<unsigned> size;
4552 flags_node.ForEachAttribute(
4553 callback: [&id, &size, &log](const llvm::StringRef &name,
4554 const llvm::StringRef &value) {
4555 if (name == "id") {
4556 id = value;
4557 } else if (name == "size") {
4558 unsigned parsed_size = 0;
4559 if (llvm::to_integer(S: value, Num&: parsed_size))
4560 size = parsed_size;
4561 else {
4562 LLDB_LOG(log,
4563 "ProcessGDBRemote::ParseFlags Invalid size \"{0}\" "
4564 "in flags node",
4565 value.data());
4566 }
4567 } else {
4568 LLDB_LOG(log,
4569 "ProcessGDBRemote::ParseFlags Ignoring unknown "
4570 "attribute \"{0}\" in flags node",
4571 name.data());
4572 }
4573 return true; // Walk all attributes.
4574 });
4575
4576 if (id && size) {
4577 // Process the fields of this set of flags.
4578 std::vector<RegisterFlags::Field> fields =
4579 ParseFlagsFields(flags_node, size: *size, registers_enum_types);
4580 if (fields.size()) {
4581 // Sort so that the fields with the MSBs are first.
4582 std::sort(first: fields.rbegin(), last: fields.rend());
4583 std::vector<RegisterFlags::Field>::const_iterator overlap =
4584 std::adjacent_find(first: fields.begin(), last: fields.end(),
4585 binary_pred: [](const RegisterFlags::Field &lhs,
4586 const RegisterFlags::Field &rhs) {
4587 return lhs.Overlaps(other: rhs);
4588 });
4589
4590 // If no fields overlap, use them.
4591 if (overlap == fields.end()) {
4592 if (registers_flags_types.contains(Key: *id)) {
4593 // In theory you could define some flag set, use it with a
4594 // register then redefine it. We do not know if anyone does
4595 // that, or what they would expect to happen in that case.
4596 //
4597 // LLDB chooses to take the first definition and ignore the rest
4598 // as waiting until everything has been processed is more
4599 // expensive and difficult. This means that pointers to flag
4600 // sets in the register info remain valid if later the flag set
4601 // is redefined. If we allowed redefinitions, LLDB would crash
4602 // when you tried to print a register that used the original
4603 // definition.
4604 LLDB_LOG(
4605 log,
4606 "ProcessGDBRemote::ParseFlags Definition of flags "
4607 "\"{0}\" shadows "
4608 "previous definition, using original definition instead.",
4609 id->data());
4610 } else {
4611 registers_flags_types.insert_or_assign(
4612 Key: *id, Val: std::make_unique<RegisterFlags>(args: id->str(), args&: *size,
4613 args: std::move(fields)));
4614 }
4615 } else {
4616 // If any fields overlap, ignore the whole set of flags.
4617 std::vector<RegisterFlags::Field>::const_iterator next =
4618 std::next(x: overlap);
4619 LLDB_LOG(
4620 log,
4621 "ProcessGDBRemote::ParseFlags Ignoring flags because fields "
4622 "{0} (start: {1} end: {2}) and {3} (start: {4} end: {5}) "
4623 "overlap.",
4624 overlap->GetName().c_str(), overlap->GetStart(),
4625 overlap->GetEnd(), next->GetName().c_str(), next->GetStart(),
4626 next->GetEnd());
4627 }
4628 } else {
4629 LLDB_LOG(
4630 log,
4631 "ProcessGDBRemote::ParseFlags Ignoring definition of flags "
4632 "\"{0}\" because it contains no fields.",
4633 id->data());
4634 }
4635 }
4636
4637 return true; // Keep iterating through all "flags" elements.
4638 });
4639}
4640
4641bool ParseRegisters(
4642 XMLNode feature_node, GdbServerTargetInfo &target_info,
4643 std::vector<DynamicRegisterInfo::Register> &registers,
4644 llvm::StringMap<std::unique_ptr<RegisterFlags>> &registers_flags_types,
4645 llvm::StringMap<std::unique_ptr<FieldEnum>> &registers_enum_types) {
4646 if (!feature_node)
4647 return false;
4648
4649 Log *log(GetLog(mask: GDBRLog::Process));
4650
4651 // Enums first because they are referenced by fields in the flags.
4652 ParseEnums(feature_node, registers_enum_types);
4653 for (const auto &enum_type : registers_enum_types)
4654 enum_type.second->DumpToLog(log);
4655
4656 ParseFlags(feature_node, registers_flags_types, registers_enum_types);
4657 for (const auto &flags : registers_flags_types)
4658 flags.second->DumpToLog(log);
4659
4660 feature_node.ForEachChildElementWithName(
4661 name: "reg",
4662 callback: [&target_info, &registers, &registers_flags_types,
4663 log](const XMLNode &reg_node) -> bool {
4664 std::string gdb_group;
4665 std::string gdb_type;
4666 DynamicRegisterInfo::Register reg_info;
4667 bool encoding_set = false;
4668 bool format_set = false;
4669
4670 // FIXME: we're silently ignoring invalid data here
4671 reg_node.ForEachAttribute(callback: [&target_info, &gdb_group, &gdb_type,
4672 &encoding_set, &format_set, &reg_info,
4673 log](const llvm::StringRef &name,
4674 const llvm::StringRef &value) -> bool {
4675 if (name == "name") {
4676 reg_info.name.SetString(value);
4677 } else if (name == "bitsize") {
4678 if (llvm::to_integer(S: value, Num&: reg_info.byte_size))
4679 reg_info.byte_size =
4680 llvm::divideCeil(Numerator: reg_info.byte_size, CHAR_BIT);
4681 } else if (name == "type") {
4682 gdb_type = value.str();
4683 } else if (name == "group") {
4684 gdb_group = value.str();
4685 } else if (name == "regnum") {
4686 llvm::to_integer(S: value, Num&: reg_info.regnum_remote);
4687 } else if (name == "offset") {
4688 llvm::to_integer(S: value, Num&: reg_info.byte_offset);
4689 } else if (name == "altname") {
4690 reg_info.alt_name.SetString(value);
4691 } else if (name == "encoding") {
4692 encoding_set = true;
4693 reg_info.encoding = Args::StringToEncoding(s: value, fail_value: eEncodingUint);
4694 } else if (name == "format") {
4695 format_set = true;
4696 if (!OptionArgParser::ToFormat(s: value.data(), format&: reg_info.format,
4697 byte_size_ptr: nullptr)
4698 .Success())
4699 reg_info.format =
4700 llvm::StringSwitch<lldb::Format>(value)
4701 .Case(S: "vector-sint8", Value: eFormatVectorOfSInt8)
4702 .Case(S: "vector-uint8", Value: eFormatVectorOfUInt8)
4703 .Case(S: "vector-sint16", Value: eFormatVectorOfSInt16)
4704 .Case(S: "vector-uint16", Value: eFormatVectorOfUInt16)
4705 .Case(S: "vector-sint32", Value: eFormatVectorOfSInt32)
4706 .Case(S: "vector-uint32", Value: eFormatVectorOfUInt32)
4707 .Case(S: "vector-float32", Value: eFormatVectorOfFloat32)
4708 .Case(S: "vector-uint64", Value: eFormatVectorOfUInt64)
4709 .Case(S: "vector-uint128", Value: eFormatVectorOfUInt128)
4710 .Default(Value: eFormatInvalid);
4711 } else if (name == "group_id") {
4712 uint32_t set_id = UINT32_MAX;
4713 llvm::to_integer(S: value, Num&: set_id);
4714 RegisterSetMap::const_iterator pos =
4715 target_info.reg_set_map.find(x: set_id);
4716 if (pos != target_info.reg_set_map.end())
4717 reg_info.set_name = pos->second.name;
4718 } else if (name == "gcc_regnum" || name == "ehframe_regnum") {
4719 llvm::to_integer(S: value, Num&: reg_info.regnum_ehframe);
4720 } else if (name == "dwarf_regnum") {
4721 llvm::to_integer(S: value, Num&: reg_info.regnum_dwarf);
4722 } else if (name == "generic") {
4723 reg_info.regnum_generic = Args::StringToGenericRegister(s: value);
4724 } else if (name == "value_regnums") {
4725 SplitCommaSeparatedRegisterNumberString(comma_separated_register_numbers: value, regnums&: reg_info.value_regs,
4726 base: 0);
4727 } else if (name == "invalidate_regnums") {
4728 SplitCommaSeparatedRegisterNumberString(
4729 comma_separated_register_numbers: value, regnums&: reg_info.invalidate_regs, base: 0);
4730 } else {
4731 LLDB_LOGF(log,
4732 "ProcessGDBRemote::ParseRegisters unhandled reg "
4733 "attribute %s = %s",
4734 name.data(), value.data());
4735 }
4736 return true; // Keep iterating through all attributes
4737 });
4738
4739 if (!gdb_type.empty()) {
4740 // gdb_type could reference some flags type defined in XML.
4741 llvm::StringMap<std::unique_ptr<RegisterFlags>>::iterator it =
4742 registers_flags_types.find(Key: gdb_type);
4743 if (it != registers_flags_types.end()) {
4744 auto flags_type = it->second.get();
4745 if (reg_info.byte_size == flags_type->GetSize())
4746 reg_info.flags_type = flags_type;
4747 else
4748 LLDB_LOGF(log,
4749 "ProcessGDBRemote::ParseRegisters Size of register "
4750 "flags %s (%d bytes) for "
4751 "register %s does not match the register size (%d "
4752 "bytes). Ignoring this set of flags.",
4753 flags_type->GetID().c_str(), flags_type->GetSize(),
4754 reg_info.name.AsCString(), reg_info.byte_size);
4755 }
4756
4757 // There's a slim chance that the gdb_type name is both a flags type
4758 // and a simple type. Just in case, look for that too (setting both
4759 // does no harm).
4760 if (!gdb_type.empty() && !(encoding_set || format_set)) {
4761 if (llvm::StringRef(gdb_type).starts_with(Prefix: "int")) {
4762 reg_info.format = eFormatHex;
4763 reg_info.encoding = eEncodingUint;
4764 } else if (gdb_type == "data_ptr" || gdb_type == "code_ptr") {
4765 reg_info.format = eFormatAddressInfo;
4766 reg_info.encoding = eEncodingUint;
4767 } else if (gdb_type == "float") {
4768 reg_info.format = eFormatFloat;
4769 reg_info.encoding = eEncodingIEEE754;
4770 } else if (gdb_type == "aarch64v" ||
4771 llvm::StringRef(gdb_type).starts_with(Prefix: "vec") ||
4772 gdb_type == "i387_ext" || gdb_type == "uint128" ||
4773 reg_info.byte_size > 16) {
4774 // lldb doesn't handle 128-bit uints correctly (for ymm*h), so
4775 // treat them as vector (similarly to xmm/ymm).
4776 // We can fall back to handling anything else <= 128 bit as an
4777 // unsigned integer, more than that, call it a vector of bytes.
4778 // This can happen if we don't recognise the type for AArc64 SVE
4779 // registers.
4780 reg_info.format = eFormatVectorOfUInt8;
4781 reg_info.encoding = eEncodingVector;
4782 } else {
4783 LLDB_LOGF(
4784 log,
4785 "ProcessGDBRemote::ParseRegisters Could not determine lldb"
4786 "format and encoding for gdb type %s",
4787 gdb_type.c_str());
4788 }
4789 }
4790 }
4791
4792 // Only update the register set name if we didn't get a "reg_set"
4793 // attribute. "set_name" will be empty if we didn't have a "reg_set"
4794 // attribute.
4795 if (!reg_info.set_name) {
4796 if (!gdb_group.empty()) {
4797 reg_info.set_name.SetCString(gdb_group.c_str());
4798 } else {
4799 // If no register group name provided anywhere,
4800 // we'll create a 'general' register set
4801 reg_info.set_name.SetCString("general");
4802 }
4803 }
4804
4805 if (reg_info.byte_size == 0) {
4806 LLDB_LOGF(log,
4807 "ProcessGDBRemote::%s Skipping zero bitsize register %s",
4808 __FUNCTION__, reg_info.name.AsCString());
4809 } else
4810 registers.push_back(x: reg_info);
4811
4812 return true; // Keep iterating through all "reg" elements
4813 });
4814 return true;
4815}
4816
4817} // namespace
4818
4819// This method fetches a register description feature xml file from
4820// the remote stub and adds registers/register groupsets/architecture
4821// information to the current process. It will call itself recursively
4822// for nested register definition files. It returns true if it was able
4823// to fetch and parse an xml file.
4824bool ProcessGDBRemote::GetGDBServerRegisterInfoXMLAndProcess(
4825 ArchSpec &arch_to_use, std::string xml_filename,
4826 std::vector<DynamicRegisterInfo::Register> &registers) {
4827 // request the target xml file
4828 llvm::Expected<std::string> raw = m_gdb_comm.ReadExtFeature(object: "features", annex: xml_filename);
4829 if (errorToBool(Err: raw.takeError()))
4830 return false;
4831
4832 XMLDocument xml_document;
4833
4834 if (xml_document.ParseMemory(xml: raw->c_str(), xml_length: raw->size(),
4835 url: xml_filename.c_str())) {
4836 GdbServerTargetInfo target_info;
4837 std::vector<XMLNode> feature_nodes;
4838
4839 // The top level feature XML file will start with a <target> tag.
4840 XMLNode target_node = xml_document.GetRootElement(required_name: "target");
4841 if (target_node) {
4842 target_node.ForEachChildElement(callback: [&target_info, &feature_nodes](
4843 const XMLNode &node) -> bool {
4844 llvm::StringRef name = node.GetName();
4845 if (name == "architecture") {
4846 node.GetElementText(text&: target_info.arch);
4847 } else if (name == "osabi") {
4848 node.GetElementText(text&: target_info.osabi);
4849 } else if (name == "xi:include" || name == "include") {
4850 std::string href = node.GetAttributeValue(name: "href");
4851 if (!href.empty())
4852 target_info.includes.push_back(x: href);
4853 } else if (name == "feature") {
4854 feature_nodes.push_back(x: node);
4855 } else if (name == "groups") {
4856 node.ForEachChildElementWithName(
4857 name: "group", callback: [&target_info](const XMLNode &node) -> bool {
4858 uint32_t set_id = UINT32_MAX;
4859 RegisterSetInfo set_info;
4860
4861 node.ForEachAttribute(
4862 callback: [&set_id, &set_info](const llvm::StringRef &name,
4863 const llvm::StringRef &value) -> bool {
4864 // FIXME: we're silently ignoring invalid data here
4865 if (name == "id")
4866 llvm::to_integer(S: value, Num&: set_id);
4867 if (name == "name")
4868 set_info.name = ConstString(value);
4869 return true; // Keep iterating through all attributes
4870 });
4871
4872 if (set_id != UINT32_MAX)
4873 target_info.reg_set_map[set_id] = set_info;
4874 return true; // Keep iterating through all "group" elements
4875 });
4876 }
4877 return true; // Keep iterating through all children of the target_node
4878 });
4879 } else {
4880 // In an included XML feature file, we're already "inside" the <target>
4881 // tag of the initial XML file; this included file will likely only have
4882 // a <feature> tag. Need to check for any more included files in this
4883 // <feature> element.
4884 XMLNode feature_node = xml_document.GetRootElement(required_name: "feature");
4885 if (feature_node) {
4886 feature_nodes.push_back(x: feature_node);
4887 feature_node.ForEachChildElement(callback: [&target_info](
4888 const XMLNode &node) -> bool {
4889 llvm::StringRef name = node.GetName();
4890 if (name == "xi:include" || name == "include") {
4891 std::string href = node.GetAttributeValue(name: "href");
4892 if (!href.empty())
4893 target_info.includes.push_back(x: href);
4894 }
4895 return true;
4896 });
4897 }
4898 }
4899
4900 // gdbserver does not implement the LLDB packets used to determine host
4901 // or process architecture. If that is the case, attempt to use
4902 // the <architecture/> field from target.xml, e.g.:
4903 //
4904 // <architecture>i386:x86-64</architecture> (seen from VMWare ESXi)
4905 // <architecture>arm</architecture> (seen from Segger JLink on unspecified
4906 // arm board)
4907 if (!arch_to_use.IsValid() && !target_info.arch.empty()) {
4908 // We don't have any information about vendor or OS.
4909 arch_to_use.SetTriple(llvm::StringSwitch<std::string>(target_info.arch)
4910 .Case(S: "i386:x86-64", Value: "x86_64")
4911 .Case(S: "riscv:rv64", Value: "riscv64")
4912 .Case(S: "riscv:rv32", Value: "riscv32")
4913 .Default(Value: target_info.arch) +
4914 "--");
4915
4916 if (arch_to_use.IsValid())
4917 GetTarget().MergeArchitecture(arch_spec: arch_to_use);
4918 }
4919
4920 if (arch_to_use.IsValid()) {
4921 for (auto &feature_node : feature_nodes) {
4922 ParseRegisters(feature_node, target_info, registers,
4923 registers_flags_types&: m_registers_flags_types, registers_enum_types&: m_registers_enum_types);
4924 }
4925
4926 for (const auto &include : target_info.includes) {
4927 GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, xml_filename: include,
4928 registers);
4929 }
4930 }
4931 } else {
4932 return false;
4933 }
4934 return true;
4935}
4936
4937void ProcessGDBRemote::AddRemoteRegisters(
4938 std::vector<DynamicRegisterInfo::Register> &registers,
4939 const ArchSpec &arch_to_use) {
4940 std::map<uint32_t, uint32_t> remote_to_local_map;
4941 uint32_t remote_regnum = 0;
4942 for (auto it : llvm::enumerate(First&: registers)) {
4943 DynamicRegisterInfo::Register &remote_reg_info = it.value();
4944
4945 // Assign successive remote regnums if missing.
4946 if (remote_reg_info.regnum_remote == LLDB_INVALID_REGNUM)
4947 remote_reg_info.regnum_remote = remote_regnum;
4948
4949 // Create a mapping from remote to local regnos.
4950 remote_to_local_map[remote_reg_info.regnum_remote] = it.index();
4951
4952 remote_regnum = remote_reg_info.regnum_remote + 1;
4953 }
4954
4955 for (DynamicRegisterInfo::Register &remote_reg_info : registers) {
4956 auto proc_to_lldb = [&remote_to_local_map](uint32_t process_regnum) {
4957 auto lldb_regit = remote_to_local_map.find(x: process_regnum);
4958 return lldb_regit != remote_to_local_map.end() ? lldb_regit->second
4959 : LLDB_INVALID_REGNUM;
4960 };
4961
4962 llvm::transform(Range&: remote_reg_info.value_regs,
4963 d_first: remote_reg_info.value_regs.begin(), F: proc_to_lldb);
4964 llvm::transform(Range&: remote_reg_info.invalidate_regs,
4965 d_first: remote_reg_info.invalidate_regs.begin(), F: proc_to_lldb);
4966 }
4967
4968 // Don't use Process::GetABI, this code gets called from DidAttach, and
4969 // in that context we haven't set the Target's architecture yet, so the
4970 // ABI is also potentially incorrect.
4971 if (ABISP abi_sp = ABI::FindPlugin(process_sp: shared_from_this(), arch: arch_to_use))
4972 abi_sp->AugmentRegisterInfo(regs&: registers);
4973
4974 m_register_info_sp->SetRegisterInfo(regs: std::move(registers), arch: arch_to_use);
4975}
4976
4977// query the target of gdb-remote for extended target information returns
4978// true on success (got register definitions), false on failure (did not).
4979bool ProcessGDBRemote::GetGDBServerRegisterInfo(ArchSpec &arch_to_use) {
4980 // Make sure LLDB has an XML parser it can use first
4981 if (!XMLDocument::XMLEnabled())
4982 return false;
4983
4984 // check that we have extended feature read support
4985 if (!m_gdb_comm.GetQXferFeaturesReadSupported())
4986 return false;
4987
4988 // These hold register type information for the whole of target.xml.
4989 // target.xml may include further documents that
4990 // GetGDBServerRegisterInfoXMLAndProcess will recurse to fetch and process.
4991 // That's why we clear the cache here, and not in
4992 // GetGDBServerRegisterInfoXMLAndProcess. To prevent it being cleared on every
4993 // include read.
4994 m_registers_flags_types.clear();
4995 m_registers_enum_types.clear();
4996 std::vector<DynamicRegisterInfo::Register> registers;
4997 if (GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, xml_filename: "target.xml",
4998 registers) &&
4999 // Target XML is not required to include register information.
5000 !registers.empty())
5001 AddRemoteRegisters(registers, arch_to_use);
5002
5003 return m_register_info_sp->GetNumRegisters() > 0;
5004}
5005
5006llvm::Expected<LoadedModuleInfoList> ProcessGDBRemote::GetLoadedModuleList() {
5007 // Make sure LLDB has an XML parser it can use first
5008 if (!XMLDocument::XMLEnabled())
5009 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5010 S: "XML parsing not available");
5011
5012 Log *log = GetLog(mask: LLDBLog::Process);
5013 LLDB_LOGF(log, "ProcessGDBRemote::%s", __FUNCTION__);
5014
5015 LoadedModuleInfoList list;
5016 GDBRemoteCommunicationClient &comm = m_gdb_comm;
5017 bool can_use_svr4 = GetGlobalPluginProperties().GetUseSVR4();
5018
5019 // check that we have extended feature read support
5020 if (can_use_svr4 && comm.GetQXferLibrariesSVR4ReadSupported()) {
5021 // request the loaded library list
5022 llvm::Expected<std::string> raw = comm.ReadExtFeature(object: "libraries-svr4", annex: "");
5023 if (!raw)
5024 return raw.takeError();
5025
5026 // parse the xml file in memory
5027 LLDB_LOGF(log, "parsing: %s", raw->c_str());
5028 XMLDocument doc;
5029
5030 if (!doc.ParseMemory(xml: raw->c_str(), xml_length: raw->size(), url: "noname.xml"))
5031 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5032 S: "Error reading noname.xml");
5033
5034 XMLNode root_element = doc.GetRootElement(required_name: "library-list-svr4");
5035 if (!root_element)
5036 return llvm::createStringError(
5037 EC: llvm::inconvertibleErrorCode(),
5038 S: "Error finding library-list-svr4 xml element");
5039
5040 // main link map structure
5041 std::string main_lm = root_element.GetAttributeValue(name: "main-lm");
5042 // FIXME: we're silently ignoring invalid data here
5043 if (!main_lm.empty())
5044 llvm::to_integer(S: main_lm, Num&: list.m_link_map);
5045
5046 root_element.ForEachChildElementWithName(
5047 name: "library", callback: [log, &list](const XMLNode &library) -> bool {
5048 LoadedModuleInfoList::LoadedModuleInfo module;
5049
5050 // FIXME: we're silently ignoring invalid data here
5051 library.ForEachAttribute(
5052 callback: [&module](const llvm::StringRef &name,
5053 const llvm::StringRef &value) -> bool {
5054 uint64_t uint_value = LLDB_INVALID_ADDRESS;
5055 if (name == "name")
5056 module.set_name(value.str());
5057 else if (name == "lm") {
5058 // the address of the link_map struct.
5059 llvm::to_integer(S: value, Num&: uint_value);
5060 module.set_link_map(uint_value);
5061 } else if (name == "l_addr") {
5062 // the displacement as read from the field 'l_addr' of the
5063 // link_map struct.
5064 llvm::to_integer(S: value, Num&: uint_value);
5065 module.set_base(uint_value);
5066 // base address is always a displacement, not an absolute
5067 // value.
5068 module.set_base_is_offset(true);
5069 } else if (name == "l_ld") {
5070 // the memory address of the libraries PT_DYNAMIC section.
5071 llvm::to_integer(S: value, Num&: uint_value);
5072 module.set_dynamic(uint_value);
5073 }
5074
5075 return true; // Keep iterating over all properties of "library"
5076 });
5077
5078 if (log) {
5079 std::string name;
5080 lldb::addr_t lm = 0, base = 0, ld = 0;
5081 bool base_is_offset;
5082
5083 module.get_name(out&: name);
5084 module.get_link_map(out&: lm);
5085 module.get_base(out&: base);
5086 module.get_base_is_offset(out&: base_is_offset);
5087 module.get_dynamic(out&: ld);
5088
5089 LLDB_LOGF(log,
5090 "found (link_map:0x%08" PRIx64 ", base:0x%08" PRIx64
5091 "[%s], ld:0x%08" PRIx64 ", name:'%s')",
5092 lm, base, (base_is_offset ? "offset" : "absolute"), ld,
5093 name.c_str());
5094 }
5095
5096 list.add(mod: module);
5097 return true; // Keep iterating over all "library" elements in the root
5098 // node
5099 });
5100
5101 if (log)
5102 LLDB_LOGF(log, "found %" PRId32 " modules in total",
5103 (int)list.m_list.size());
5104 return list;
5105 } else if (comm.GetQXferLibrariesReadSupported()) {
5106 // request the loaded library list
5107 llvm::Expected<std::string> raw = comm.ReadExtFeature(object: "libraries", annex: "");
5108
5109 if (!raw)
5110 return raw.takeError();
5111
5112 LLDB_LOGF(log, "parsing: %s", raw->c_str());
5113 XMLDocument doc;
5114
5115 if (!doc.ParseMemory(xml: raw->c_str(), xml_length: raw->size(), url: "noname.xml"))
5116 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5117 S: "Error reading noname.xml");
5118
5119 XMLNode root_element = doc.GetRootElement(required_name: "library-list");
5120 if (!root_element)
5121 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5122 S: "Error finding library-list xml element");
5123
5124 // FIXME: we're silently ignoring invalid data here
5125 root_element.ForEachChildElementWithName(
5126 name: "library", callback: [log, &list](const XMLNode &library) -> bool {
5127 LoadedModuleInfoList::LoadedModuleInfo module;
5128
5129 std::string name = library.GetAttributeValue(name: "name");
5130 module.set_name(name);
5131
5132 // The base address of a given library will be the address of its
5133 // first section. Most remotes send only one section for Windows
5134 // targets for example.
5135 const XMLNode &section =
5136 library.FindFirstChildElementWithName(name: "section");
5137 std::string address = section.GetAttributeValue(name: "address");
5138 uint64_t address_value = LLDB_INVALID_ADDRESS;
5139 llvm::to_integer(S: address, Num&: address_value);
5140 module.set_base(address_value);
5141 // These addresses are absolute values.
5142 module.set_base_is_offset(false);
5143
5144 if (log) {
5145 std::string name;
5146 lldb::addr_t base = 0;
5147 bool base_is_offset;
5148 module.get_name(out&: name);
5149 module.get_base(out&: base);
5150 module.get_base_is_offset(out&: base_is_offset);
5151
5152 LLDB_LOGF(log, "found (base:0x%08" PRIx64 "[%s], name:'%s')", base,
5153 (base_is_offset ? "offset" : "absolute"), name.c_str());
5154 }
5155
5156 list.add(mod: module);
5157 return true; // Keep iterating over all "library" elements in the root
5158 // node
5159 });
5160
5161 if (log)
5162 LLDB_LOGF(log, "found %" PRId32 " modules in total",
5163 (int)list.m_list.size());
5164 return list;
5165 } else {
5166 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5167 S: "Remote libraries not supported");
5168 }
5169}
5170
5171lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
5172 lldb::addr_t link_map,
5173 lldb::addr_t base_addr,
5174 bool value_is_offset) {
5175 DynamicLoader *loader = GetDynamicLoader();
5176 if (!loader)
5177 return nullptr;
5178
5179 return loader->LoadModuleAtAddress(file, link_map_addr: link_map, base_addr,
5180 base_addr_is_offset: value_is_offset);
5181}
5182
5183llvm::Error ProcessGDBRemote::LoadModules() {
5184 using lldb_private::process_gdb_remote::ProcessGDBRemote;
5185
5186 // request a list of loaded libraries from GDBServer
5187 llvm::Expected<LoadedModuleInfoList> module_list = GetLoadedModuleList();
5188 if (!module_list)
5189 return module_list.takeError();
5190
5191 // get a list of all the modules
5192 ModuleList new_modules;
5193
5194 for (LoadedModuleInfoList::LoadedModuleInfo &modInfo : module_list->m_list) {
5195 std::string mod_name;
5196 lldb::addr_t mod_base;
5197 lldb::addr_t link_map;
5198 bool mod_base_is_offset;
5199
5200 bool valid = true;
5201 valid &= modInfo.get_name(out&: mod_name);
5202 valid &= modInfo.get_base(out&: mod_base);
5203 valid &= modInfo.get_base_is_offset(out&: mod_base_is_offset);
5204 if (!valid)
5205 continue;
5206
5207 if (!modInfo.get_link_map(out&: link_map))
5208 link_map = LLDB_INVALID_ADDRESS;
5209
5210 FileSpec file(mod_name);
5211 FileSystem::Instance().Resolve(file_spec&: file);
5212 lldb::ModuleSP module_sp =
5213 LoadModuleAtAddress(file, link_map, base_addr: mod_base, value_is_offset: mod_base_is_offset);
5214
5215 if (module_sp.get())
5216 new_modules.Append(module_sp);
5217 }
5218
5219 if (new_modules.GetSize() > 0) {
5220 ModuleList removed_modules;
5221 Target &target = GetTarget();
5222 ModuleList &loaded_modules = m_process->GetTarget().GetImages();
5223
5224 for (size_t i = 0; i < loaded_modules.GetSize(); ++i) {
5225 const lldb::ModuleSP loaded_module = loaded_modules.GetModuleAtIndex(idx: i);
5226
5227 bool found = false;
5228 for (size_t j = 0; j < new_modules.GetSize(); ++j) {
5229 if (new_modules.GetModuleAtIndex(idx: j).get() == loaded_module.get())
5230 found = true;
5231 }
5232
5233 // The main executable will never be included in libraries-svr4, don't
5234 // remove it
5235 if (!found &&
5236 loaded_module.get() != target.GetExecutableModulePointer()) {
5237 removed_modules.Append(module_sp: loaded_module);
5238 }
5239 }
5240
5241 loaded_modules.Remove(module_list&: removed_modules);
5242 m_process->GetTarget().ModulesDidUnload(module_list&: removed_modules, delete_locations: false);
5243
5244 new_modules.ForEach(callback: [&target](const lldb::ModuleSP module_sp) -> bool {
5245 lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
5246 if (!obj)
5247 return true;
5248
5249 if (obj->GetType() != ObjectFile::Type::eTypeExecutable)
5250 return true;
5251
5252 lldb::ModuleSP module_copy_sp = module_sp;
5253 target.SetExecutableModule(module_sp&: module_copy_sp, load_dependent_files: eLoadDependentsNo);
5254 return false;
5255 });
5256
5257 loaded_modules.AppendIfNeeded(module_list: new_modules);
5258 m_process->GetTarget().ModulesDidLoad(module_list&: new_modules);
5259 }
5260
5261 return llvm::ErrorSuccess();
5262}
5263
5264Status ProcessGDBRemote::GetFileLoadAddress(const FileSpec &file,
5265 bool &is_loaded,
5266 lldb::addr_t &load_addr) {
5267 is_loaded = false;
5268 load_addr = LLDB_INVALID_ADDRESS;
5269
5270 std::string file_path = file.GetPath(denormalize: false);
5271 if (file_path.empty())
5272 return Status::FromErrorString(str: "Empty file name specified");
5273
5274 StreamString packet;
5275 packet.PutCString(cstr: "qFileLoadAddress:");
5276 packet.PutStringAsRawHex8(s: file_path);
5277
5278 StringExtractorGDBRemote response;
5279 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response) !=
5280 GDBRemoteCommunication::PacketResult::Success)
5281 return Status::FromErrorString(str: "Sending qFileLoadAddress packet failed");
5282
5283 if (response.IsErrorResponse()) {
5284 if (response.GetError() == 1) {
5285 // The file is not loaded into the inferior
5286 is_loaded = false;
5287 load_addr = LLDB_INVALID_ADDRESS;
5288 return Status();
5289 }
5290
5291 return Status::FromErrorString(
5292 str: "Fetching file load address from remote server returned an error");
5293 }
5294
5295 if (response.IsNormalResponse()) {
5296 is_loaded = true;
5297 load_addr = response.GetHexMaxU64(little_endian: false, LLDB_INVALID_ADDRESS);
5298 return Status();
5299 }
5300
5301 return Status::FromErrorString(
5302 str: "Unknown error happened during sending the load address packet");
5303}
5304
5305void ProcessGDBRemote::ModulesDidLoad(ModuleList &module_list) {
5306 // We must call the lldb_private::Process::ModulesDidLoad () first before we
5307 // do anything
5308 Process::ModulesDidLoad(module_list);
5309
5310 // After loading shared libraries, we can ask our remote GDB server if it
5311 // needs any symbols.
5312 m_gdb_comm.ServeSymbolLookups(process: this);
5313}
5314
5315void ProcessGDBRemote::HandleAsyncStdout(llvm::StringRef out) {
5316 AppendSTDOUT(s: out.data(), len: out.size());
5317}
5318
5319static const char *end_delimiter = "--end--;";
5320static const int end_delimiter_len = 8;
5321
5322void ProcessGDBRemote::HandleAsyncMisc(llvm::StringRef data) {
5323 std::string input = data.str(); // '1' to move beyond 'A'
5324 if (m_partial_profile_data.length() > 0) {
5325 m_partial_profile_data.append(str: input);
5326 input = m_partial_profile_data;
5327 m_partial_profile_data.clear();
5328 }
5329
5330 size_t found, pos = 0, len = input.length();
5331 while ((found = input.find(s: end_delimiter, pos: pos)) != std::string::npos) {
5332 StringExtractorGDBRemote profileDataExtractor(
5333 input.substr(pos: pos, n: found).c_str());
5334 std::string profile_data =
5335 HarmonizeThreadIdsForProfileData(inputStringExtractor&: profileDataExtractor);
5336 BroadcastAsyncProfileData(one_profile_data: profile_data);
5337
5338 pos = found + end_delimiter_len;
5339 }
5340
5341 if (pos < len) {
5342 // Last incomplete chunk.
5343 m_partial_profile_data = input.substr(pos: pos);
5344 }
5345}
5346
5347std::string ProcessGDBRemote::HarmonizeThreadIdsForProfileData(
5348 StringExtractorGDBRemote &profileDataExtractor) {
5349 std::map<uint64_t, uint32_t> new_thread_id_to_used_usec_map;
5350 std::string output;
5351 llvm::raw_string_ostream output_stream(output);
5352 llvm::StringRef name, value;
5353
5354 // Going to assuming thread_used_usec comes first, else bail out.
5355 while (profileDataExtractor.GetNameColonValue(name, value)) {
5356 if (name.compare(RHS: "thread_used_id") == 0) {
5357 StringExtractor threadIDHexExtractor(value);
5358 uint64_t thread_id = threadIDHexExtractor.GetHexMaxU64(little_endian: false, fail_value: 0);
5359
5360 bool has_used_usec = false;
5361 uint32_t curr_used_usec = 0;
5362 llvm::StringRef usec_name, usec_value;
5363 uint32_t input_file_pos = profileDataExtractor.GetFilePos();
5364 if (profileDataExtractor.GetNameColonValue(name&: usec_name, value&: usec_value)) {
5365 if (usec_name == "thread_used_usec") {
5366 has_used_usec = true;
5367 usec_value.getAsInteger(Radix: 0, Result&: curr_used_usec);
5368 } else {
5369 // We didn't find what we want, it is probably an older version. Bail
5370 // out.
5371 profileDataExtractor.SetFilePos(input_file_pos);
5372 }
5373 }
5374
5375 if (has_used_usec) {
5376 uint32_t prev_used_usec = 0;
5377 std::map<uint64_t, uint32_t>::iterator iterator =
5378 m_thread_id_to_used_usec_map.find(x: thread_id);
5379 if (iterator != m_thread_id_to_used_usec_map.end())
5380 prev_used_usec = iterator->second;
5381
5382 uint32_t real_used_usec = curr_used_usec - prev_used_usec;
5383 // A good first time record is one that runs for at least 0.25 sec
5384 bool good_first_time =
5385 (prev_used_usec == 0) && (real_used_usec > 250000);
5386 bool good_subsequent_time =
5387 (prev_used_usec > 0) &&
5388 ((real_used_usec > 0) || (HasAssignedIndexIDToThread(sb_thread_id: thread_id)));
5389
5390 if (good_first_time || good_subsequent_time) {
5391 // We try to avoid doing too many index id reservation, resulting in
5392 // fast increase of index ids.
5393
5394 output_stream << name << ":";
5395 int32_t index_id = AssignIndexIDToThread(thread_id);
5396 output_stream << index_id << ";";
5397
5398 output_stream << usec_name << ":" << usec_value << ";";
5399 } else {
5400 // Skip past 'thread_used_name'.
5401 llvm::StringRef local_name, local_value;
5402 profileDataExtractor.GetNameColonValue(name&: local_name, value&: local_value);
5403 }
5404
5405 // Store current time as previous time so that they can be compared
5406 // later.
5407 new_thread_id_to_used_usec_map[thread_id] = curr_used_usec;
5408 } else {
5409 // Bail out and use old string.
5410 output_stream << name << ":" << value << ";";
5411 }
5412 } else {
5413 output_stream << name << ":" << value << ";";
5414 }
5415 }
5416 output_stream << end_delimiter;
5417 m_thread_id_to_used_usec_map = new_thread_id_to_used_usec_map;
5418
5419 return output;
5420}
5421
5422void ProcessGDBRemote::HandleStopReply() {
5423 if (GetStopID() != 0)
5424 return;
5425
5426 if (GetID() == LLDB_INVALID_PROCESS_ID) {
5427 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
5428 if (pid != LLDB_INVALID_PROCESS_ID)
5429 SetID(pid);
5430 }
5431 BuildDynamicRegisterInfo(force: true);
5432}
5433
5434llvm::Expected<bool> ProcessGDBRemote::SaveCore(llvm::StringRef outfile) {
5435 if (!m_gdb_comm.GetSaveCoreSupported())
5436 return false;
5437
5438 StreamString packet;
5439 packet.PutCString(cstr: "qSaveCore;path-hint:");
5440 packet.PutStringAsRawHex8(s: outfile);
5441
5442 StringExtractorGDBRemote response;
5443 if (m_gdb_comm.SendPacketAndWaitForResponse(payload: packet.GetString(), response) ==
5444 GDBRemoteCommunication::PacketResult::Success) {
5445 // TODO: grab error message from the packet? StringExtractor seems to
5446 // be missing a method for that
5447 if (response.IsErrorResponse())
5448 return llvm::createStringError(
5449 EC: llvm::inconvertibleErrorCode(),
5450 S: llvm::formatv(Fmt: "qSaveCore returned an error"));
5451
5452 std::string path;
5453
5454 // process the response
5455 for (auto x : llvm::split(Str: response.GetStringRef(), Separator: ';')) {
5456 if (x.consume_front(Prefix: "core-path:"))
5457 StringExtractor(x).GetHexByteString(str&: path);
5458 }
5459
5460 // verify that we've gotten what we need
5461 if (path.empty())
5462 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5463 S: "qSaveCore returned no core path");
5464
5465 // now transfer the core file
5466 FileSpec remote_core{llvm::StringRef(path)};
5467 Platform &platform = *GetTarget().GetPlatform();
5468 Status error = platform.GetFile(source: remote_core, destination: FileSpec(outfile));
5469
5470 if (platform.IsRemote()) {
5471 // NB: we unlink the file on error too
5472 platform.Unlink(file_spec: remote_core);
5473 if (error.Fail())
5474 return error.ToError();
5475 }
5476
5477 return true;
5478 }
5479
5480 return llvm::createStringError(EC: llvm::inconvertibleErrorCode(),
5481 S: "Unable to send qSaveCore");
5482}
5483
5484static const char *const s_async_json_packet_prefix = "JSON-async:";
5485
5486static StructuredData::ObjectSP
5487ParseStructuredDataPacket(llvm::StringRef packet) {
5488 Log *log = GetLog(mask: GDBRLog::Process);
5489
5490 if (!packet.consume_front(Prefix: s_async_json_packet_prefix)) {
5491 if (log) {
5492 LLDB_LOGF(
5493 log,
5494 "GDBRemoteCommunicationClientBase::%s() received $J packet "
5495 "but was not a StructuredData packet: packet starts with "
5496 "%s",
5497 __FUNCTION__,
5498 packet.slice(0, strlen(s_async_json_packet_prefix)).str().c_str());
5499 }
5500 return StructuredData::ObjectSP();
5501 }
5502
5503 // This is an asynchronous JSON packet, destined for a StructuredDataPlugin.
5504 StructuredData::ObjectSP json_sp = StructuredData::ParseJSON(json_text: packet);
5505 if (log) {
5506 if (json_sp) {
5507 StreamString json_str;
5508 json_sp->Dump(s&: json_str, pretty_print: true);
5509 json_str.Flush();
5510 LLDB_LOGF(log,
5511 "ProcessGDBRemote::%s() "
5512 "received Async StructuredData packet: %s",
5513 __FUNCTION__, json_str.GetData());
5514 } else {
5515 LLDB_LOGF(log,
5516 "ProcessGDBRemote::%s"
5517 "() received StructuredData packet:"
5518 " parse failure",
5519 __FUNCTION__);
5520 }
5521 }
5522 return json_sp;
5523}
5524
5525void ProcessGDBRemote::HandleAsyncStructuredDataPacket(llvm::StringRef data) {
5526 auto structured_data_sp = ParseStructuredDataPacket(packet: data);
5527 if (structured_data_sp)
5528 RouteAsyncStructuredData(object_sp: structured_data_sp);
5529}
5530
5531class CommandObjectProcessGDBRemoteSpeedTest : public CommandObjectParsed {
5532public:
5533 CommandObjectProcessGDBRemoteSpeedTest(CommandInterpreter &interpreter)
5534 : CommandObjectParsed(interpreter, "process plugin packet speed-test",
5535 "Tests packet speeds of various sizes to determine "
5536 "the performance characteristics of the GDB remote "
5537 "connection. ",
5538 nullptr),
5539 m_option_group(),
5540 m_num_packets(LLDB_OPT_SET_1, false, "count", 'c', 0, eArgTypeCount,
5541 "The number of packets to send of each varying size "
5542 "(default is 1000).",
5543 1000),
5544 m_max_send(LLDB_OPT_SET_1, false, "max-send", 's', 0, eArgTypeCount,
5545 "The maximum number of bytes to send in a packet. Sizes "
5546 "increase in powers of 2 while the size is less than or "
5547 "equal to this option value. (default 1024).",
5548 1024),
5549 m_max_recv(LLDB_OPT_SET_1, false, "max-receive", 'r', 0, eArgTypeCount,
5550 "The maximum number of bytes to receive in a packet. Sizes "
5551 "increase in powers of 2 while the size is less than or "
5552 "equal to this option value. (default 1024).",
5553 1024),
5554 m_json(LLDB_OPT_SET_1, false, "json", 'j',
5555 "Print the output as JSON data for easy parsing.", false, true) {
5556 m_option_group.Append(group: &m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5557 m_option_group.Append(group: &m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5558 m_option_group.Append(group: &m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5559 m_option_group.Append(group: &m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5560 m_option_group.Finalize();
5561 }
5562
5563 ~CommandObjectProcessGDBRemoteSpeedTest() override = default;
5564
5565 Options *GetOptions() override { return &m_option_group; }
5566
5567 void DoExecute(Args &command, CommandReturnObject &result) override {
5568 const size_t argc = command.GetArgumentCount();
5569 if (argc == 0) {
5570 ProcessGDBRemote *process =
5571 (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
5572 .GetProcessPtr();
5573 if (process) {
5574 StreamSP output_stream_sp = result.GetImmediateOutputStream();
5575 if (!output_stream_sp)
5576 output_stream_sp = m_interpreter.GetDebugger().GetAsyncOutputStream();
5577 result.SetImmediateOutputStream(output_stream_sp);
5578
5579 const uint32_t num_packets =
5580 (uint32_t)m_num_packets.GetOptionValue().GetCurrentValue();
5581 const uint64_t max_send = m_max_send.GetOptionValue().GetCurrentValue();
5582 const uint64_t max_recv = m_max_recv.GetOptionValue().GetCurrentValue();
5583 const bool json = m_json.GetOptionValue().GetCurrentValue();
5584 const uint64_t k_recv_amount =
5585 4 * 1024 * 1024; // Receive amount in bytes
5586 process->GetGDBRemote().TestPacketSpeed(
5587 num_packets, max_send, max_recv, recv_amount: k_recv_amount, json,
5588 strm&: output_stream_sp ? *output_stream_sp : result.GetOutputStream());
5589 result.SetStatus(eReturnStatusSuccessFinishResult);
5590 return;
5591 }
5592 } else {
5593 result.AppendErrorWithFormat(format: "'%s' takes no arguments",
5594 m_cmd_name.c_str());
5595 }
5596 result.SetStatus(eReturnStatusFailed);
5597 }
5598
5599protected:
5600 OptionGroupOptions m_option_group;
5601 OptionGroupUInt64 m_num_packets;
5602 OptionGroupUInt64 m_max_send;
5603 OptionGroupUInt64 m_max_recv;
5604 OptionGroupBoolean m_json;
5605};
5606
5607class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed {
5608private:
5609public:
5610 CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter)
5611 : CommandObjectParsed(interpreter, "process plugin packet history",
5612 "Dumps the packet history buffer. ", nullptr) {}
5613
5614 ~CommandObjectProcessGDBRemotePacketHistory() override = default;
5615
5616 void DoExecute(Args &command, CommandReturnObject &result) override {
5617 ProcessGDBRemote *process =
5618 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5619 if (process) {
5620 process->DumpPluginHistory(s&: result.GetOutputStream());
5621 result.SetStatus(eReturnStatusSuccessFinishResult);
5622 return;
5623 }
5624 result.SetStatus(eReturnStatusFailed);
5625 }
5626};
5627
5628class CommandObjectProcessGDBRemotePacketXferSize : public CommandObjectParsed {
5629private:
5630public:
5631 CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter)
5632 : CommandObjectParsed(
5633 interpreter, "process plugin packet xfer-size",
5634 "Maximum size that lldb will try to read/write one one chunk.",
5635 nullptr) {
5636 AddSimpleArgumentList(arg_type: eArgTypeUnsignedInteger);
5637 }
5638
5639 ~CommandObjectProcessGDBRemotePacketXferSize() override = default;
5640
5641 void DoExecute(Args &command, CommandReturnObject &result) override {
5642 const size_t argc = command.GetArgumentCount();
5643 if (argc == 0) {
5644 result.AppendErrorWithFormat(format: "'%s' takes an argument to specify the max "
5645 "amount to be transferred when "
5646 "reading/writing",
5647 m_cmd_name.c_str());
5648 return;
5649 }
5650
5651 ProcessGDBRemote *process =
5652 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5653 if (process) {
5654 const char *packet_size = command.GetArgumentAtIndex(idx: 0);
5655 errno = 0;
5656 uint64_t user_specified_max = strtoul(nptr: packet_size, endptr: nullptr, base: 10);
5657 if (errno == 0 && user_specified_max != 0) {
5658 process->SetUserSpecifiedMaxMemoryTransferSize(user_specified_max);
5659 result.SetStatus(eReturnStatusSuccessFinishResult);
5660 return;
5661 }
5662 }
5663 result.SetStatus(eReturnStatusFailed);
5664 }
5665};
5666
5667class CommandObjectProcessGDBRemotePacketSend : public CommandObjectParsed {
5668private:
5669public:
5670 CommandObjectProcessGDBRemotePacketSend(CommandInterpreter &interpreter)
5671 : CommandObjectParsed(interpreter, "process plugin packet send",
5672 "Send a custom packet through the GDB remote "
5673 "protocol and print the answer. "
5674 "The packet header and footer will automatically "
5675 "be added to the packet prior to sending and "
5676 "stripped from the result.",
5677 nullptr) {
5678 AddSimpleArgumentList(arg_type: eArgTypeNone, repetition_type: eArgRepeatStar);
5679 }
5680
5681 ~CommandObjectProcessGDBRemotePacketSend() override = default;
5682
5683 void DoExecute(Args &command, CommandReturnObject &result) override {
5684 const size_t argc = command.GetArgumentCount();
5685 if (argc == 0) {
5686 result.AppendErrorWithFormat(
5687 format: "'%s' takes a one or more packet content arguments",
5688 m_cmd_name.c_str());
5689 return;
5690 }
5691
5692 ProcessGDBRemote *process =
5693 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5694 if (process) {
5695 for (size_t i = 0; i < argc; ++i) {
5696 const char *packet_cstr = command.GetArgumentAtIndex(idx: 0);
5697 StringExtractorGDBRemote response;
5698 process->GetGDBRemote().SendPacketAndWaitForResponse(
5699 payload: packet_cstr, response, interrupt_timeout: process->GetInterruptTimeout());
5700 result.SetStatus(eReturnStatusSuccessFinishResult);
5701 Stream &output_strm = result.GetOutputStream();
5702 output_strm.Printf(format: " packet: %s\n", packet_cstr);
5703 std::string response_str = std::string(response.GetStringRef());
5704
5705 if (strstr(haystack: packet_cstr, needle: "qGetProfileData") != nullptr) {
5706 response_str = process->HarmonizeThreadIdsForProfileData(profileDataExtractor&: response);
5707 }
5708
5709 if (response_str.empty())
5710 output_strm.PutCString(cstr: "response: \nerror: UNIMPLEMENTED\n");
5711 else
5712 output_strm.Printf(format: "response: %s\n", response.GetStringRef().data());
5713 }
5714 }
5715 }
5716};
5717
5718class CommandObjectProcessGDBRemotePacketMonitor : public CommandObjectRaw {
5719private:
5720public:
5721 CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter)
5722 : CommandObjectRaw(interpreter, "process plugin packet monitor",
5723 "Send a qRcmd packet through the GDB remote protocol "
5724 "and print the response."
5725 "The argument passed to this command will be hex "
5726 "encoded into a valid 'qRcmd' packet, sent and the "
5727 "response will be printed.") {}
5728
5729 ~CommandObjectProcessGDBRemotePacketMonitor() override = default;
5730
5731 void DoExecute(llvm::StringRef command,
5732 CommandReturnObject &result) override {
5733 if (command.empty()) {
5734 result.AppendErrorWithFormat(format: "'%s' takes a command string argument",
5735 m_cmd_name.c_str());
5736 return;
5737 }
5738
5739 ProcessGDBRemote *process =
5740 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5741 if (process) {
5742 StreamString packet;
5743 packet.PutCString(cstr: "qRcmd,");
5744 packet.PutBytesAsRawHex8(src: command.data(), src_len: command.size());
5745
5746 StringExtractorGDBRemote response;
5747 Stream &output_strm = result.GetOutputStream();
5748 process->GetGDBRemote().SendPacketAndReceiveResponseWithOutputSupport(
5749 payload: packet.GetString(), response, interrupt_timeout: process->GetInterruptTimeout(),
5750 output_callback: [&output_strm](llvm::StringRef output) { output_strm << output; });
5751 result.SetStatus(eReturnStatusSuccessFinishResult);
5752 output_strm.Printf(format: " packet: %s\n", packet.GetData());
5753 const std::string &response_str = std::string(response.GetStringRef());
5754
5755 if (response_str.empty())
5756 output_strm.PutCString(cstr: "response: \nerror: UNIMPLEMENTED\n");
5757 else
5758 output_strm.Printf(format: "response: %s\n", response.GetStringRef().data());
5759 }
5760 }
5761};
5762
5763class CommandObjectProcessGDBRemotePacket : public CommandObjectMultiword {
5764private:
5765public:
5766 CommandObjectProcessGDBRemotePacket(CommandInterpreter &interpreter)
5767 : CommandObjectMultiword(interpreter, "process plugin packet",
5768 "Commands that deal with GDB remote packets.",
5769 nullptr) {
5770 LoadSubCommand(
5771 cmd_name: "history",
5772 command_obj: CommandObjectSP(
5773 new CommandObjectProcessGDBRemotePacketHistory(interpreter)));
5774 LoadSubCommand(
5775 cmd_name: "send", command_obj: CommandObjectSP(
5776 new CommandObjectProcessGDBRemotePacketSend(interpreter)));
5777 LoadSubCommand(
5778 cmd_name: "monitor",
5779 command_obj: CommandObjectSP(
5780 new CommandObjectProcessGDBRemotePacketMonitor(interpreter)));
5781 LoadSubCommand(
5782 cmd_name: "xfer-size",
5783 command_obj: CommandObjectSP(
5784 new CommandObjectProcessGDBRemotePacketXferSize(interpreter)));
5785 LoadSubCommand(cmd_name: "speed-test",
5786 command_obj: CommandObjectSP(new CommandObjectProcessGDBRemoteSpeedTest(
5787 interpreter)));
5788 }
5789
5790 ~CommandObjectProcessGDBRemotePacket() override = default;
5791};
5792
5793class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword {
5794public:
5795 CommandObjectMultiwordProcessGDBRemote(CommandInterpreter &interpreter)
5796 : CommandObjectMultiword(
5797 interpreter, "process plugin",
5798 "Commands for operating on a ProcessGDBRemote process.",
5799 "process plugin <subcommand> [<subcommand-options>]") {
5800 LoadSubCommand(
5801 cmd_name: "packet",
5802 command_obj: CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter)));
5803 }
5804
5805 ~CommandObjectMultiwordProcessGDBRemote() override = default;
5806};
5807
5808CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
5809 if (!m_command_sp)
5810 m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>(
5811 args&: GetTarget().GetDebugger().GetCommandInterpreter());
5812 return m_command_sp.get();
5813}
5814
5815void ProcessGDBRemote::DidForkSwitchSoftwareBreakpoints(bool enable) {
5816 GetBreakpointSiteList().ForEach(callback: [this, enable](BreakpointSite *bp_site) {
5817 if (bp_site->IsEnabled() &&
5818 (bp_site->GetType() == BreakpointSite::eSoftware ||
5819 bp_site->GetType() == BreakpointSite::eExternal)) {
5820 m_gdb_comm.SendGDBStoppointTypePacket(
5821 type: eBreakpointSoftware, insert: enable, addr: bp_site->GetLoadAddress(),
5822 length: GetSoftwareBreakpointTrapOpcode(bp_site), interrupt_timeout: GetInterruptTimeout());
5823 }
5824 });
5825}
5826
5827void ProcessGDBRemote::DidForkSwitchHardwareTraps(bool enable) {
5828 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointHardware)) {
5829 GetBreakpointSiteList().ForEach(callback: [this, enable](BreakpointSite *bp_site) {
5830 if (bp_site->IsEnabled() &&
5831 bp_site->GetType() == BreakpointSite::eHardware) {
5832 m_gdb_comm.SendGDBStoppointTypePacket(
5833 type: eBreakpointHardware, insert: enable, addr: bp_site->GetLoadAddress(),
5834 length: GetSoftwareBreakpointTrapOpcode(bp_site), interrupt_timeout: GetInterruptTimeout());
5835 }
5836 });
5837 }
5838
5839 for (const auto &wp_res_sp : m_watchpoint_resource_list.Sites()) {
5840 addr_t addr = wp_res_sp->GetLoadAddress();
5841 size_t size = wp_res_sp->GetByteSize();
5842 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
5843 m_gdb_comm.SendGDBStoppointTypePacket(type, insert: enable, addr, length: size,
5844 interrupt_timeout: GetInterruptTimeout());
5845 }
5846}
5847
5848void ProcessGDBRemote::DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) {
5849 Log *log = GetLog(mask: GDBRLog::Process);
5850
5851 lldb::pid_t parent_pid = m_gdb_comm.GetCurrentProcessID();
5852 // Any valid TID will suffice, thread-relevant actions will set a proper TID
5853 // anyway.
5854 lldb::tid_t parent_tid = m_thread_ids.front();
5855
5856 lldb::pid_t follow_pid, detach_pid;
5857 lldb::tid_t follow_tid, detach_tid;
5858
5859 switch (GetFollowForkMode()) {
5860 case eFollowParent:
5861 follow_pid = parent_pid;
5862 follow_tid = parent_tid;
5863 detach_pid = child_pid;
5864 detach_tid = child_tid;
5865 break;
5866 case eFollowChild:
5867 follow_pid = child_pid;
5868 follow_tid = child_tid;
5869 detach_pid = parent_pid;
5870 detach_tid = parent_tid;
5871 break;
5872 }
5873
5874 // Switch to the process that is going to be detached.
5875 if (!m_gdb_comm.SetCurrentThread(tid: detach_tid, pid: detach_pid)) {
5876 LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to set pid/tid");
5877 return;
5878 }
5879
5880 // Disable all software breakpoints in the forked process.
5881 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointSoftware))
5882 DidForkSwitchSoftwareBreakpoints(enable: false);
5883
5884 // Remove hardware breakpoints / watchpoints from parent process if we're
5885 // following child.
5886 if (GetFollowForkMode() == eFollowChild)
5887 DidForkSwitchHardwareTraps(enable: false);
5888
5889 // Switch to the process that is going to be followed
5890 if (!m_gdb_comm.SetCurrentThread(tid: follow_tid, pid: follow_pid) ||
5891 !m_gdb_comm.SetCurrentThreadForRun(tid: follow_tid, pid: follow_pid)) {
5892 LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to reset pid/tid");
5893 return;
5894 }
5895
5896 LLDB_LOG(log, "Detaching process {0}", detach_pid);
5897 Status error = m_gdb_comm.Detach(keep_stopped: false, pid: detach_pid);
5898 if (error.Fail()) {
5899 LLDB_LOG(log, "ProcessGDBRemote::DidFork() detach packet send failed: {0}",
5900 error.AsCString() ? error.AsCString() : "<unknown error>");
5901 return;
5902 }
5903
5904 // Hardware breakpoints/watchpoints are not inherited implicitly,
5905 // so we need to readd them if we're following child.
5906 if (GetFollowForkMode() == eFollowChild) {
5907 DidForkSwitchHardwareTraps(enable: true);
5908 // Update our PID
5909 SetID(child_pid);
5910 }
5911}
5912
5913void ProcessGDBRemote::DidVFork(lldb::pid_t child_pid, lldb::tid_t child_tid) {
5914 Log *log = GetLog(mask: GDBRLog::Process);
5915
5916 LLDB_LOG(
5917 log,
5918 "ProcessGDBRemote::DidFork() called for child_pid: {0}, child_tid {1}",
5919 child_pid, child_tid);
5920 ++m_vfork_in_progress_count;
5921
5922 // Disable all software breakpoints for the duration of vfork.
5923 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointSoftware))
5924 DidForkSwitchSoftwareBreakpoints(enable: false);
5925
5926 lldb::pid_t detach_pid;
5927 lldb::tid_t detach_tid;
5928
5929 switch (GetFollowForkMode()) {
5930 case eFollowParent:
5931 detach_pid = child_pid;
5932 detach_tid = child_tid;
5933 break;
5934 case eFollowChild:
5935 detach_pid = m_gdb_comm.GetCurrentProcessID();
5936 // Any valid TID will suffice, thread-relevant actions will set a proper TID
5937 // anyway.
5938 detach_tid = m_thread_ids.front();
5939
5940 // Switch to the parent process before detaching it.
5941 if (!m_gdb_comm.SetCurrentThread(tid: detach_tid, pid: detach_pid)) {
5942 LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to set pid/tid");
5943 return;
5944 }
5945
5946 // Remove hardware breakpoints / watchpoints from the parent process.
5947 DidForkSwitchHardwareTraps(enable: false);
5948
5949 // Switch to the child process.
5950 if (!m_gdb_comm.SetCurrentThread(tid: child_tid, pid: child_pid) ||
5951 !m_gdb_comm.SetCurrentThreadForRun(tid: child_tid, pid: child_pid)) {
5952 LLDB_LOG(log, "ProcessGDBRemote::DidFork() unable to reset pid/tid");
5953 return;
5954 }
5955 break;
5956 }
5957
5958 LLDB_LOG(log, "Detaching process {0}", detach_pid);
5959 Status error = m_gdb_comm.Detach(keep_stopped: false, pid: detach_pid);
5960 if (error.Fail()) {
5961 LLDB_LOG(log,
5962 "ProcessGDBRemote::DidFork() detach packet send failed: {0}",
5963 error.AsCString() ? error.AsCString() : "<unknown error>");
5964 return;
5965 }
5966
5967 if (GetFollowForkMode() == eFollowChild) {
5968 // Update our PID
5969 SetID(child_pid);
5970 }
5971}
5972
5973void ProcessGDBRemote::DidVForkDone() {
5974 assert(m_vfork_in_progress_count > 0);
5975 --m_vfork_in_progress_count;
5976
5977 // Reenable all software breakpoints that were enabled before vfork.
5978 if (m_gdb_comm.SupportsGDBStoppointPacket(type: eBreakpointSoftware))
5979 DidForkSwitchSoftwareBreakpoints(enable: true);
5980}
5981
5982void ProcessGDBRemote::DidExec() {
5983 // If we are following children, vfork is finished by exec (rather than
5984 // vforkdone that is submitted for parent).
5985 if (GetFollowForkMode() == eFollowChild) {
5986 if (m_vfork_in_progress_count > 0)
5987 --m_vfork_in_progress_count;
5988 }
5989 Process::DidExec();
5990}
5991

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp