LLDB mainline
ProcessGDBRemote.cpp
Go to the documentation of this file.
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
29#include "lldb/Core/Debugger.h"
30#include "lldb/Core/Module.h"
33#include "lldb/Core/Value.h"
38#include "lldb/Host/PosixApi.h"
42#include "lldb/Host/XML.h"
54#include "lldb/Target/ABI.h"
59#include "lldb/Target/Target.h"
62#include "lldb/Utility/Args.h"
65#include "lldb/Utility/State.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
82#include "ProcessGDBRemote.h"
83#include "ProcessGDBRemoteLog.h"
84#include "ThreadGDBRemote.h"
85#include "lldb/Host/Host.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;
99
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(
112 if (!file) {
113 llvm::consumeError(file.takeError());
114 return;
115 }
116 StreamFile stream(std::move(file.get()));
117 ((Process *)p)->DumpPluginHistory(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() {
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
172} // namespace
173
174static PluginProperties &GetGlobalPluginProperties() {
175 static PluginProperties g_settings;
176 return g_settings;
177}
178
179// TODO Randomly assigning a port is unsafe. We should get an unused
180// ephemeral port from the kernel and make sure we reserve it before passing it
181// to debugserver.
182
183#if defined(__APPLE__)
184#define LOW_PORT (IPPORT_RESERVED)
185#define HIGH_PORT (IPPORT_HIFIRSTAUTO)
186#else
187#define LOW_PORT (1024u)
188#define HIGH_PORT (49151u)
189#endif
190
192 return "GDB Remote protocol based debugging plug-in.";
193}
194
197}
198
200 lldb::TargetSP target_sp, ListenerSP listener_sp,
201 const FileSpec *crash_file_path, bool can_connect) {
202 lldb::ProcessSP process_sp;
203 if (crash_file_path == nullptr)
204 process_sp = std::shared_ptr<ProcessGDBRemote>(
205 new ProcessGDBRemote(target_sp, listener_sp));
206 return process_sp;
207}
208
211 gdb_comm.DumpHistory(s);
212}
213
215 return std::chrono::seconds(GetGlobalPluginProperties().GetPacketTimeout());
216}
217
220}
221
223 bool plugin_specified_by_name) {
224 if (plugin_specified_by_name)
225 return true;
226
227 // For now we are just making sure the file exists for a given module
228 Module *exe_module = target_sp->GetExecutableModulePointer();
229 if (exe_module) {
230 ObjectFile *exe_objfile = exe_module->GetObjectFile();
231 // We can't debug core files...
232 switch (exe_objfile->GetType()) {
240 return false;
244 break;
245 }
246 return FileSystem::Instance().Exists(exe_module->GetFileSpec());
247 }
248 // However, if there is no executable module, we return true since we might
249 // be preparing to attach.
250 return true;
251}
252
253// ProcessGDBRemote constructor
255 ListenerSP listener_sp)
256 : Process(target_sp, listener_sp),
257 m_debugserver_pid(LLDB_INVALID_PROCESS_ID), m_register_info_sp(nullptr),
258 m_async_broadcaster(nullptr, "lldb.process.gdb-remote.async-broadcaster"),
259 m_async_listener_sp(
260 Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
261 m_async_thread_state_mutex(), m_thread_ids(), m_thread_pcs(),
262 m_jstopinfo_sp(), m_jthreadsinfo_sp(), m_continue_c_tids(),
263 m_continue_C_tids(), m_continue_s_tids(), m_continue_S_tids(),
264 m_max_memory_size(0), m_remote_stub_max_memory_size(0),
265 m_addr_to_mmap_size(), m_thread_create_bp_sp(),
266 m_waiting_for_attach(false), m_command_sp(), m_breakpoint_pc_offset(0),
267 m_initial_tid(LLDB_INVALID_THREAD_ID), m_allow_flash_writes(false),
268 m_erased_flash_ranges(), m_vfork_in_progress_count(0) {
270 "async thread should exit");
272 "async thread continue");
274 "async thread did exit");
275
276 Log *log = GetLog(GDBRLog::Async);
277
278 const uint32_t async_event_mask =
280
281 if (m_async_listener_sp->StartListeningForEvents(
282 &m_async_broadcaster, async_event_mask) != async_event_mask) {
283 LLDB_LOGF(log,
284 "ProcessGDBRemote::%s failed to listen for "
285 "m_async_broadcaster events",
286 __FUNCTION__);
287 }
288
289 const uint64_t timeout_seconds =
290 GetGlobalPluginProperties().GetPacketTimeout();
291 if (timeout_seconds > 0)
292 m_gdb_comm.SetPacketTimeout(std::chrono::seconds(timeout_seconds));
293
295 GetGlobalPluginProperties().GetUseGPacketForReading();
296}
297
298// Destructor
300 // m_mach_process.UnregisterNotificationCallbacks (this);
301 Clear();
302 // We need to call finalize on the process before destroying ourselves to
303 // make sure all of the broadcaster cleanup goes as planned. If we destruct
304 // this class, then Process::~Process() might have problems trying to fully
305 // destroy the broadcaster.
306 Finalize(true /* destructing */);
307
308 // The general Finalize is going to try to destroy the process and that
309 // SHOULD shut down the async thread. However, if we don't kill it it will
310 // get stranded and its connection will go away so when it wakes up it will
311 // crash. So kill it for sure here.
314}
315
317 const FileSpec &target_definition_fspec) {
318 ScriptInterpreter *interpreter =
321 StructuredData::ObjectSP module_object_sp(
322 interpreter->LoadPluginModule(target_definition_fspec, error));
323 if (module_object_sp) {
324 StructuredData::DictionarySP target_definition_sp(
325 interpreter->GetDynamicSettings(module_object_sp, &GetTarget(),
326 "gdb-server-target-definition", error));
327
328 if (target_definition_sp) {
329 StructuredData::ObjectSP target_object(
330 target_definition_sp->GetValueForKey("host-info"));
331 if (target_object) {
332 if (auto host_info_dict = target_object->GetAsDictionary()) {
333 StructuredData::ObjectSP triple_value =
334 host_info_dict->GetValueForKey("triple");
335 if (auto triple_string_value = triple_value->GetAsString()) {
336 std::string triple_string =
337 std::string(triple_string_value->GetValue());
338 ArchSpec host_arch(triple_string.c_str());
339 if (!host_arch.IsCompatibleMatch(GetTarget().GetArchitecture())) {
340 GetTarget().SetArchitecture(host_arch);
341 }
342 }
343 }
344 }
346 StructuredData::ObjectSP breakpoint_pc_offset_value =
347 target_definition_sp->GetValueForKey("breakpoint-pc-offset");
348 if (breakpoint_pc_offset_value) {
349 if (auto breakpoint_pc_int_value =
350 breakpoint_pc_offset_value->GetAsSignedInteger())
351 m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue();
352 }
353
354 if (m_register_info_sp->SetRegisterInfo(
355 *target_definition_sp, GetTarget().GetArchitecture()) > 0) {
356 return true;
357 }
358 }
359 }
360 return false;
361}
362
364 const llvm::StringRef &comma_separated_register_numbers,
365 std::vector<uint32_t> &regnums, int base) {
366 regnums.clear();
367 for (llvm::StringRef x : llvm::split(comma_separated_register_numbers, ',')) {
368 uint32_t reg;
369 if (llvm::to_integer(x, reg, base))
370 regnums.push_back(reg);
371 }
372 return regnums.size();
373}
374
376 if (!force && m_register_info_sp)
377 return;
378
379 m_register_info_sp = std::make_shared<GDBRemoteDynamicRegisterInfo>();
380
381 // Check if qHostInfo specified a specific packet timeout for this
382 // connection. If so then lets update our setting so the user knows what the
383 // timeout is and can see it.
384 const auto host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
385 if (host_packet_timeout > std::chrono::seconds(0)) {
386 GetGlobalPluginProperties().SetPacketTimeout(host_packet_timeout.count());
387 }
388
389 // Register info search order:
390 // 1 - Use the target definition python file if one is specified.
391 // 2 - If the target definition doesn't have any of the info from the
392 // target.xml (registers) then proceed to read the target.xml.
393 // 3 - Fall back on the qRegisterInfo packets.
394 // 4 - Use hardcoded defaults if available.
395
396 FileSpec target_definition_fspec =
397 GetGlobalPluginProperties().GetTargetDefinitionFile();
398 if (!FileSystem::Instance().Exists(target_definition_fspec)) {
399 // If the filename doesn't exist, it may be a ~ not having been expanded -
400 // try to resolve it.
401 FileSystem::Instance().Resolve(target_definition_fspec);
402 }
403 if (target_definition_fspec) {
404 // See if we can get register definitions from a python file
405 if (ParsePythonTargetDefinition(target_definition_fspec))
406 return;
407
408 Debugger::ReportError("target description file " +
409 target_definition_fspec.GetPath() +
410 " failed to parse",
411 GetTarget().GetDebugger().GetID());
412 }
413
414 const ArchSpec &target_arch = GetTarget().GetArchitecture();
415 const ArchSpec &remote_host_arch = m_gdb_comm.GetHostArchitecture();
416 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
417
418 // Use the process' architecture instead of the host arch, if available
419 ArchSpec arch_to_use;
420 if (remote_process_arch.IsValid())
421 arch_to_use = remote_process_arch;
422 else
423 arch_to_use = remote_host_arch;
424
425 if (!arch_to_use.IsValid())
426 arch_to_use = target_arch;
427
428 if (GetGDBServerRegisterInfo(arch_to_use))
429 return;
430
431 char packet[128];
432 std::vector<DynamicRegisterInfo::Register> registers;
433 uint32_t reg_num = 0;
434 for (StringExtractorGDBRemote::ResponseType response_type =
436 response_type == StringExtractorGDBRemote::eResponse; ++reg_num) {
437 const int packet_len =
438 ::snprintf(packet, sizeof(packet), "qRegisterInfo%x", reg_num);
439 assert(packet_len < (int)sizeof(packet));
440 UNUSED_IF_ASSERT_DISABLED(packet_len);
442 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response) ==
444 response_type = response.GetResponseType();
445 if (response_type == StringExtractorGDBRemote::eResponse) {
446 llvm::StringRef name;
447 llvm::StringRef value;
449
450 while (response.GetNameColonValue(name, value)) {
451 if (name == "name") {
452 reg_info.name.SetString(value);
453 } else if (name == "alt-name") {
454 reg_info.alt_name.SetString(value);
455 } else if (name == "bitsize") {
456 if (!value.getAsInteger(0, reg_info.byte_size))
457 reg_info.byte_size /= CHAR_BIT;
458 } else if (name == "offset") {
459 value.getAsInteger(0, reg_info.byte_offset);
460 } else if (name == "encoding") {
461 const Encoding encoding = Args::StringToEncoding(value);
462 if (encoding != eEncodingInvalid)
463 reg_info.encoding = encoding;
464 } else if (name == "format") {
465 if (!OptionArgParser::ToFormat(value.str().c_str(), reg_info.format, nullptr)
466 .Success())
467 reg_info.format =
468 llvm::StringSwitch<Format>(value)
469 .Case("binary", eFormatBinary)
470 .Case("decimal", eFormatDecimal)
471 .Case("hex", eFormatHex)
472 .Case("float", eFormatFloat)
473 .Case("vector-sint8", eFormatVectorOfSInt8)
474 .Case("vector-uint8", eFormatVectorOfUInt8)
475 .Case("vector-sint16", eFormatVectorOfSInt16)
476 .Case("vector-uint16", eFormatVectorOfUInt16)
477 .Case("vector-sint32", eFormatVectorOfSInt32)
478 .Case("vector-uint32", eFormatVectorOfUInt32)
479 .Case("vector-float32", eFormatVectorOfFloat32)
480 .Case("vector-uint64", eFormatVectorOfUInt64)
481 .Case("vector-uint128", eFormatVectorOfUInt128)
482 .Default(eFormatInvalid);
483 } else if (name == "set") {
484 reg_info.set_name.SetString(value);
485 } else if (name == "gcc" || name == "ehframe") {
486 value.getAsInteger(0, reg_info.regnum_ehframe);
487 } else if (name == "dwarf") {
488 value.getAsInteger(0, reg_info.regnum_dwarf);
489 } else if (name == "generic") {
491 } else if (name == "container-regs") {
493 } else if (name == "invalidate-regs") {
495 }
496 }
497
498 assert(reg_info.byte_size != 0);
499 registers.push_back(reg_info);
500 } else {
501 break; // ensure exit before reg_num is incremented
502 }
503 } else {
504 break;
505 }
506 }
507
508 if (registers.empty())
509 registers = GetFallbackRegisters(arch_to_use);
510
511 AddRemoteRegisters(registers, arch_to_use);
512}
513
515 return WillLaunchOrAttach();
516}
517
519 return WillLaunchOrAttach();
520}
521
523 bool wait_for_launch) {
524 return WillLaunchOrAttach();
525}
526
527Status ProcessGDBRemote::DoConnectRemote(llvm::StringRef remote_url) {
529
531 if (error.Fail())
532 return error;
533
534 error = ConnectToDebugserver(remote_url);
535 if (error.Fail())
536 return error;
537
539
541 if (pid == LLDB_INVALID_PROCESS_ID) {
542 // We don't have a valid process ID, so note that we are connected and
543 // could now request to launch or attach, or get remote process listings...
545 } else {
546 // We have a valid process
547 SetID(pid);
550 if (m_gdb_comm.GetStopReply(response)) {
551 SetLastStopPacket(response);
552
553 Target &target = GetTarget();
554 if (!target.GetArchitecture().IsValid()) {
557 } else {
560 }
561 }
562 }
563
564 const StateType state = SetThreadStopInfo(response);
565 if (state != eStateInvalid) {
566 SetPrivateState(state);
567 } else
568 error.SetErrorStringWithFormat(
569 "Process %" PRIu64 " was reported after connecting to "
570 "'%s', but state was not stopped: %s",
571 pid, remote_url.str().c_str(), StateAsCString(state));
572 } else
573 error.SetErrorStringWithFormat("Process %" PRIu64
574 " was reported after connecting to '%s', "
575 "but no stop reply packet was received",
576 pid, remote_url.str().c_str());
577 }
578
579 LLDB_LOGF(log,
580 "ProcessGDBRemote::%s pid %" PRIu64
581 ": normalizing target architecture initial triple: %s "
582 "(GetTarget().GetArchitecture().IsValid() %s, "
583 "m_gdb_comm.GetHostArchitecture().IsValid(): %s)",
584 __FUNCTION__, GetID(),
585 GetTarget().GetArchitecture().GetTriple().getTriple().c_str(),
586 GetTarget().GetArchitecture().IsValid() ? "true" : "false",
587 m_gdb_comm.GetHostArchitecture().IsValid() ? "true" : "false");
588
589 if (error.Success() && !GetTarget().GetArchitecture().IsValid() &&
591 // Prefer the *process'* architecture over that of the *host*, if
592 // available.
595 else
597 }
598
599 LLDB_LOGF(log,
600 "ProcessGDBRemote::%s pid %" PRIu64
601 ": normalized target architecture triple: %s",
602 __FUNCTION__, GetID(),
603 GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
604
605 return error;
606}
607
611 return error;
612}
613
614// Process Control
616 ProcessLaunchInfo &launch_info) {
619
620 LLDB_LOGF(log, "ProcessGDBRemote::%s() entered", __FUNCTION__);
621
622 uint32_t launch_flags = launch_info.GetFlags().Get();
623 FileSpec stdin_file_spec{};
624 FileSpec stdout_file_spec{};
625 FileSpec stderr_file_spec{};
626 FileSpec working_dir = launch_info.GetWorkingDirectory();
627
628 const FileAction *file_action;
629 file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
630 if (file_action) {
631 if (file_action->GetAction() == FileAction::eFileActionOpen)
632 stdin_file_spec = file_action->GetFileSpec();
633 }
634 file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
635 if (file_action) {
636 if (file_action->GetAction() == FileAction::eFileActionOpen)
637 stdout_file_spec = file_action->GetFileSpec();
638 }
639 file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
640 if (file_action) {
641 if (file_action->GetAction() == FileAction::eFileActionOpen)
642 stderr_file_spec = file_action->GetFileSpec();
643 }
644
645 if (log) {
646 if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
647 LLDB_LOGF(log,
648 "ProcessGDBRemote::%s provided with STDIO paths via "
649 "launch_info: stdin=%s, stdout=%s, stderr=%s",
650 __FUNCTION__,
651 stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
652 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
653 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
654 else
655 LLDB_LOGF(log,
656 "ProcessGDBRemote::%s no STDIO paths given via launch_info",
657 __FUNCTION__);
658 }
659
660 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
661 if (stdin_file_spec || disable_stdio) {
662 // the inferior will be reading stdin from the specified file or stdio is
663 // completely disabled
664 m_stdin_forward = false;
665 } else {
666 m_stdin_forward = true;
667 }
668
669 // ::LogSetBitMask (GDBR_LOG_DEFAULT);
670 // ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE |
671 // LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
672 // LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
673 // ::LogSetLogFile ("/dev/stdout");
674
675 error = EstablishConnectionIfNeeded(launch_info);
676 if (error.Success()) {
677 PseudoTerminal pty;
678 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
679
680 PlatformSP platform_sp(GetTarget().GetPlatform());
681 if (disable_stdio) {
682 // set to /dev/null unless redirected to a file above
683 if (!stdin_file_spec)
684 stdin_file_spec.SetFile(FileSystem::DEV_NULL,
685 FileSpec::Style::native);
686 if (!stdout_file_spec)
687 stdout_file_spec.SetFile(FileSystem::DEV_NULL,
688 FileSpec::Style::native);
689 if (!stderr_file_spec)
690 stderr_file_spec.SetFile(FileSystem::DEV_NULL,
691 FileSpec::Style::native);
692 } else if (platform_sp && platform_sp->IsHost()) {
693 // If the debugserver is local and we aren't disabling STDIO, lets use
694 // a pseudo terminal to instead of relying on the 'O' packets for stdio
695 // since 'O' packets can really slow down debugging if the inferior
696 // does a lot of output.
697 if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
698 !errorToBool(pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY))) {
699 FileSpec secondary_name(pty.GetSecondaryName());
700
701 if (!stdin_file_spec)
702 stdin_file_spec = secondary_name;
703
704 if (!stdout_file_spec)
705 stdout_file_spec = secondary_name;
706
707 if (!stderr_file_spec)
708 stderr_file_spec = secondary_name;
709 }
710 LLDB_LOGF(
711 log,
712 "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
713 "(IsHost() is true) using secondary: stdin=%s, stdout=%s, "
714 "stderr=%s",
715 __FUNCTION__,
716 stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
717 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
718 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
719 }
720
721 LLDB_LOGF(log,
722 "ProcessGDBRemote::%s final STDIO paths after all "
723 "adjustments: stdin=%s, stdout=%s, stderr=%s",
724 __FUNCTION__,
725 stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
726 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
727 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
728
729 if (stdin_file_spec)
730 m_gdb_comm.SetSTDIN(stdin_file_spec);
731 if (stdout_file_spec)
732 m_gdb_comm.SetSTDOUT(stdout_file_spec);
733 if (stderr_file_spec)
734 m_gdb_comm.SetSTDERR(stderr_file_spec);
735
736 m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
737 m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
738
740 GetTarget().GetArchitecture().GetArchitectureName());
741
742 const char *launch_event_data = launch_info.GetLaunchEventData();
743 if (launch_event_data != nullptr && *launch_event_data != '\0')
744 m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
745
746 if (working_dir) {
747 m_gdb_comm.SetWorkingDir(working_dir);
748 }
749
750 // Send the environment and the program + arguments after we connect
752
753 {
754 // Scope for the scoped timeout object
756 std::chrono::seconds(10));
757
758 // Since we can't send argv0 separate from the executable path, we need to
759 // make sure to use the actual executable path found in the launch_info...
760 Args args = launch_info.GetArguments();
761 if (FileSpec exe_file = launch_info.GetExecutableFile())
762 args.ReplaceArgumentAtIndex(0, exe_file.GetPath(false));
763 if (llvm::Error err = m_gdb_comm.LaunchProcess(args)) {
764 error.SetErrorStringWithFormatv("Cannot launch '{0}': {1}",
765 args.GetArgumentAtIndex(0),
766 llvm::fmt_consume(std::move(err)));
767 } else {
769 }
770 }
771
773 LLDB_LOGF(log, "failed to connect to debugserver: %s",
774 error.AsCString());
776 return error;
777 }
778
780 if (m_gdb_comm.GetStopReply(response)) {
781 SetLastStopPacket(response);
782
783 const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
784
785 if (process_arch.IsValid()) {
786 GetTarget().MergeArchitecture(process_arch);
787 } else {
788 const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
789 if (host_arch.IsValid())
790 GetTarget().MergeArchitecture(host_arch);
791 }
792
794
795 if (!disable_stdio) {
798 }
799 }
800 } else {
801 LLDB_LOGF(log, "failed to connect to debugserver: %s", error.AsCString());
802 }
803 return error;
804}
805
806Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
808 // Only connect if we have a valid connect URL
810
811 if (!connect_url.empty()) {
812 LLDB_LOGF(log, "ProcessGDBRemote::%s Connecting to %s", __FUNCTION__,
813 connect_url.str().c_str());
814 std::unique_ptr<ConnectionFileDescriptor> conn_up(
816 if (conn_up) {
817 const uint32_t max_retry_count = 50;
818 uint32_t retry_count = 0;
819 while (!m_gdb_comm.IsConnected()) {
820 if (conn_up->Connect(connect_url, &error) == eConnectionStatusSuccess) {
821 m_gdb_comm.SetConnection(std::move(conn_up));
822 break;
823 }
824
825 retry_count++;
826
827 if (retry_count >= max_retry_count)
828 break;
829
830 std::this_thread::sleep_for(std::chrono::milliseconds(100));
831 }
832 }
833 }
834
835 if (!m_gdb_comm.IsConnected()) {
836 if (error.Success())
837 error.SetErrorString("not connected to remote gdb server");
838 return error;
839 }
840
841 // We always seem to be able to open a connection to a local port so we need
842 // to make sure we can then send data to it. If we can't then we aren't
843 // actually connected to anything, so try and do the handshake with the
844 // remote GDB server and make sure that goes alright.
847 if (error.Success())
848 error.SetErrorString("not connected to remote gdb server");
849 return error;
850 }
851
859
860 // First dispatch any commands from the platform:
861 auto handle_cmds = [&] (const Args &args) -> void {
862 for (const Args::ArgEntry &entry : args) {
865 entry.c_str(), response);
866 }
867 };
868
869 PlatformSP platform_sp = GetTarget().GetPlatform();
870 if (platform_sp) {
871 handle_cmds(platform_sp->GetExtraStartupCommands());
872 }
873
874 // Then dispatch any process commands:
875 handle_cmds(GetExtraStartupCommands());
876
877 return error;
878}
879
883
884 // See if the GDB server supports qHostInfo or qProcessInfo packets. Prefer
885 // qProcessInfo as it will be more specific to our process.
886
887 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
888 if (remote_process_arch.IsValid()) {
889 process_arch = remote_process_arch;
890 LLDB_LOG(log, "gdb-remote had process architecture, using {0} {1}",
891 process_arch.GetArchitectureName(),
892 process_arch.GetTriple().getTriple());
893 } else {
894 process_arch = m_gdb_comm.GetHostArchitecture();
895 LLDB_LOG(log,
896 "gdb-remote did not have process architecture, using gdb-remote "
897 "host architecture {0} {1}",
898 process_arch.GetArchitectureName(),
899 process_arch.GetTriple().getTriple());
900 }
901
902 AddressableBits addressable_bits = m_gdb_comm.GetAddressableBits();
903 SetAddressableBitMasks(addressable_bits);
904
905 if (process_arch.IsValid()) {
906 const ArchSpec &target_arch = GetTarget().GetArchitecture();
907 if (target_arch.IsValid()) {
908 LLDB_LOG(log, "analyzing target arch, currently {0} {1}",
909 target_arch.GetArchitectureName(),
910 target_arch.GetTriple().getTriple());
911
912 // If the remote host is ARM and we have apple as the vendor, then
913 // ARM executables and shared libraries can have mixed ARM
914 // architectures.
915 // You can have an armv6 executable, and if the host is armv7, then the
916 // system will load the best possible architecture for all shared
917 // libraries it has, so we really need to take the remote host
918 // architecture as our defacto architecture in this case.
919
920 if ((process_arch.GetMachine() == llvm::Triple::arm ||
921 process_arch.GetMachine() == llvm::Triple::thumb) &&
922 process_arch.GetTriple().getVendor() == llvm::Triple::Apple) {
923 GetTarget().SetArchitecture(process_arch);
924 LLDB_LOG(log,
925 "remote process is ARM/Apple, "
926 "setting target arch to {0} {1}",
927 process_arch.GetArchitectureName(),
928 process_arch.GetTriple().getTriple());
929 } else {
930 // Fill in what is missing in the triple
931 const llvm::Triple &remote_triple = process_arch.GetTriple();
932 llvm::Triple new_target_triple = target_arch.GetTriple();
933 if (new_target_triple.getVendorName().size() == 0) {
934 new_target_triple.setVendor(remote_triple.getVendor());
935
936 if (new_target_triple.getOSName().size() == 0) {
937 new_target_triple.setOS(remote_triple.getOS());
938
939 if (new_target_triple.getEnvironmentName().size() == 0)
940 new_target_triple.setEnvironment(remote_triple.getEnvironment());
941 }
942
943 ArchSpec new_target_arch = target_arch;
944 new_target_arch.SetTriple(new_target_triple);
945 GetTarget().SetArchitecture(new_target_arch);
946 }
947 }
948
949 LLDB_LOG(log,
950 "final target arch after adjustments for remote architecture: "
951 "{0} {1}",
952 target_arch.GetArchitectureName(),
953 target_arch.GetTriple().getTriple());
954 } else {
955 // The target doesn't have a valid architecture yet, set it from the
956 // architecture we got from the remote GDB server
957 GetTarget().SetArchitecture(process_arch);
958 }
959 }
960
961 // Target and Process are reasonably initailized;
962 // load any binaries we have metadata for / set load address.
965
966 // Find out which StructuredDataPlugins are supported by the debug monitor.
967 // These plugins transmit data over async $J packets.
968 if (StructuredData::Array *supported_packets =
970 MapSupportedStructuredDataPlugins(*supported_packets);
971
972 // If connected to LLDB ("native-signals+"), use signal defs for
973 // the remote platform. If connected to GDB, just use the standard set.
975 SetUnixSignals(std::make_shared<GDBRemoteSignals>());
976 } else {
977 PlatformSP platform_sp = GetTarget().GetPlatform();
978 if (platform_sp && platform_sp->IsConnected())
979 SetUnixSignals(platform_sp->GetUnixSignals());
980 else
981 SetUnixSignals(UnixSignals::Create(GetTarget().GetArchitecture()));
982 }
983}
984
986 // The remote stub may know about the "main binary" in
987 // the context of a firmware debug session, and can
988 // give us a UUID and an address/slide of where the
989 // binary is loaded in memory.
990 UUID standalone_uuid;
991 addr_t standalone_value;
992 bool standalone_value_is_offset;
993 if (m_gdb_comm.GetProcessStandaloneBinary(standalone_uuid, standalone_value,
994 standalone_value_is_offset)) {
995 ModuleSP module_sp;
996
997 if (standalone_uuid.IsValid()) {
998 const bool force_symbol_search = true;
999 const bool notify = true;
1000 const bool set_address_in_target = true;
1001 const bool allow_memory_image_last_resort = false;
1003 this, "", standalone_uuid, standalone_value,
1004 standalone_value_is_offset, force_symbol_search, notify,
1005 set_address_in_target, allow_memory_image_last_resort);
1006 }
1007 }
1008
1009 // The remote stub may know about a list of binaries to
1010 // force load into the process -- a firmware type situation
1011 // where multiple binaries are present in virtual memory,
1012 // and we are only given the addresses of the binaries.
1013 // Not intended for use with userland debugging, when we use
1014 // a DynamicLoader plugin that knows how to find the loaded
1015 // binaries, and will track updates as binaries are added.
1016
1017 std::vector<addr_t> bin_addrs = m_gdb_comm.GetProcessStandaloneBinaries();
1018 if (bin_addrs.size()) {
1019 UUID uuid;
1020 const bool value_is_slide = false;
1021 for (addr_t addr : bin_addrs) {
1022 const bool notify = true;
1023 // First see if this is a special platform
1024 // binary that may determine the DynamicLoader and
1025 // Platform to be used in this Process and Target.
1026 if (GetTarget()
1027 .GetDebugger()
1028 .GetPlatformList()
1029 .LoadPlatformBinaryAndSetup(this, addr, notify))
1030 continue;
1031
1032 const bool force_symbol_search = true;
1033 const bool set_address_in_target = true;
1034 const bool allow_memory_image_last_resort = false;
1035 // Second manually load this binary into the Target.
1037 this, llvm::StringRef(), uuid, addr, value_is_slide,
1038 force_symbol_search, notify, set_address_in_target,
1039 allow_memory_image_last_resort);
1040 }
1041 }
1042}
1043
1045 ModuleSP module_sp = GetTarget().GetExecutableModule();
1046 if (!module_sp)
1047 return;
1048
1049 std::optional<QOffsets> offsets = m_gdb_comm.GetQOffsets();
1050 if (!offsets)
1051 return;
1052
1053 bool is_uniform =
1054 size_t(llvm::count(offsets->offsets, offsets->offsets[0])) ==
1055 offsets->offsets.size();
1056 if (!is_uniform)
1057 return; // TODO: Handle non-uniform responses.
1058
1059 bool changed = false;
1060 module_sp->SetLoadAddress(GetTarget(), offsets->offsets[0],
1061 /*value_is_offset=*/true, changed);
1062 if (changed) {
1063 ModuleList list;
1064 list.Append(module_sp);
1066 }
1067}
1068
1070 ArchSpec process_arch;
1071 DidLaunchOrAttach(process_arch);
1072}
1073
1075 lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info) {
1076 Log *log = GetLog(GDBRLog::Process);
1077 Status error;
1078
1079 LLDB_LOGF(log, "ProcessGDBRemote::%s()", __FUNCTION__);
1080
1081 // Clear out and clean up from any current state
1082 Clear();
1083 if (attach_pid != LLDB_INVALID_PROCESS_ID) {
1084 error = EstablishConnectionIfNeeded(attach_info);
1085 if (error.Success()) {
1087
1088 char packet[64];
1089 const int packet_len =
1090 ::snprintf(packet, sizeof(packet), "vAttach;%" PRIx64, attach_pid);
1091 SetID(attach_pid);
1092 auto data_sp =
1093 std::make_shared<EventDataBytes>(llvm::StringRef(packet, packet_len));
1095 } else
1096 SetExitStatus(-1, error.AsCString());
1097 }
1098
1099 return error;
1100}
1101
1103 const char *process_name, const ProcessAttachInfo &attach_info) {
1104 Status error;
1105 // Clear out and clean up from any current state
1106 Clear();
1107
1108 if (process_name && process_name[0]) {
1109 error = EstablishConnectionIfNeeded(attach_info);
1110 if (error.Success()) {
1111 StreamString packet;
1112
1114
1115 if (attach_info.GetWaitForLaunch()) {
1117 packet.PutCString("vAttachWait");
1118 } else {
1119 if (attach_info.GetIgnoreExisting())
1120 packet.PutCString("vAttachWait");
1121 else
1122 packet.PutCString("vAttachOrWait");
1123 }
1124 } else
1125 packet.PutCString("vAttachName");
1126 packet.PutChar(';');
1127 packet.PutBytesAsRawHex8(process_name, strlen(process_name),
1130
1131 auto data_sp = std::make_shared<EventDataBytes>(packet.GetString());
1133
1134 } else
1135 SetExitStatus(-1, error.AsCString());
1136 }
1137 return error;
1138}
1139
1140llvm::Expected<TraceSupportedResponse> ProcessGDBRemote::TraceSupported() {
1142}
1143
1145 return m_gdb_comm.SendTraceStop(request, GetInterruptTimeout());
1146}
1147
1148llvm::Error ProcessGDBRemote::TraceStart(const llvm::json::Value &request) {
1150}
1151
1152llvm::Expected<std::string>
1153ProcessGDBRemote::TraceGetState(llvm::StringRef type) {
1155}
1156
1157llvm::Expected<std::vector<uint8_t>>
1160}
1161
1163 // When we exit, disconnect from the GDB server communications
1165}
1166
1168 // If you can figure out what the architecture is, fill it in here.
1169 process_arch.Clear();
1170 DidLaunchOrAttach(process_arch);
1171}
1172
1174 m_continue_c_tids.clear();
1175 m_continue_C_tids.clear();
1176 m_continue_s_tids.clear();
1177 m_continue_S_tids.clear();
1178 m_jstopinfo_sp.reset();
1179 m_jthreadsinfo_sp.reset();
1180 return Status();
1181}
1182
1184 Status error;
1185 Log *log = GetLog(GDBRLog::Process);
1186 LLDB_LOGF(log, "ProcessGDBRemote::Resume()");
1187
1188 ListenerSP listener_sp(
1189 Listener::MakeListener("gdb-remote.resume-packet-sent"));
1190 if (listener_sp->StartListeningForEvents(
1192 listener_sp->StartListeningForEvents(
1195
1196 const size_t num_threads = GetThreadList().GetSize();
1197
1198 StreamString continue_packet;
1199 bool continue_packet_error = false;
1201 std::string pid_prefix;
1203 pid_prefix = llvm::formatv("p{0:x-}.", GetID());
1204
1205 if (m_continue_c_tids.size() == num_threads ||
1206 (m_continue_c_tids.empty() && m_continue_C_tids.empty() &&
1207 m_continue_s_tids.empty() && m_continue_S_tids.empty())) {
1208 // All threads are continuing
1210 continue_packet.Format("vCont;c:{0}-1", pid_prefix);
1211 else
1212 continue_packet.PutCString("c");
1213 } else {
1214 continue_packet.PutCString("vCont");
1215
1216 if (!m_continue_c_tids.empty()) {
1217 if (m_gdb_comm.GetVContSupported('c')) {
1218 for (tid_collection::const_iterator
1219 t_pos = m_continue_c_tids.begin(),
1220 t_end = m_continue_c_tids.end();
1221 t_pos != t_end; ++t_pos)
1222 continue_packet.Format(";c:{0}{1:x-}", pid_prefix, *t_pos);
1223 } else
1224 continue_packet_error = true;
1225 }
1226
1227 if (!continue_packet_error && !m_continue_C_tids.empty()) {
1228 if (m_gdb_comm.GetVContSupported('C')) {
1229 for (tid_sig_collection::const_iterator
1230 s_pos = m_continue_C_tids.begin(),
1231 s_end = m_continue_C_tids.end();
1232 s_pos != s_end; ++s_pos)
1233 continue_packet.Format(";C{0:x-2}:{1}{2:x-}", s_pos->second,
1234 pid_prefix, s_pos->first);
1235 } else
1236 continue_packet_error = true;
1237 }
1238
1239 if (!continue_packet_error && !m_continue_s_tids.empty()) {
1240 if (m_gdb_comm.GetVContSupported('s')) {
1241 for (tid_collection::const_iterator
1242 t_pos = m_continue_s_tids.begin(),
1243 t_end = m_continue_s_tids.end();
1244 t_pos != t_end; ++t_pos)
1245 continue_packet.Format(";s:{0}{1:x-}", pid_prefix, *t_pos);
1246 } else
1247 continue_packet_error = true;
1248 }
1249
1250 if (!continue_packet_error && !m_continue_S_tids.empty()) {
1251 if (m_gdb_comm.GetVContSupported('S')) {
1252 for (tid_sig_collection::const_iterator
1253 s_pos = m_continue_S_tids.begin(),
1254 s_end = m_continue_S_tids.end();
1255 s_pos != s_end; ++s_pos)
1256 continue_packet.Format(";S{0:x-2}:{1}{2:x-}", s_pos->second,
1257 pid_prefix, s_pos->first);
1258 } else
1259 continue_packet_error = true;
1260 }
1261
1262 if (continue_packet_error)
1263 continue_packet.Clear();
1264 }
1265 } else
1266 continue_packet_error = true;
1267
1268 if (continue_packet_error) {
1269 // Either no vCont support, or we tried to use part of the vCont packet
1270 // that wasn't supported by the remote GDB server. We need to try and
1271 // make a simple packet that can do our continue
1272 const size_t num_continue_c_tids = m_continue_c_tids.size();
1273 const size_t num_continue_C_tids = m_continue_C_tids.size();
1274 const size_t num_continue_s_tids = m_continue_s_tids.size();
1275 const size_t num_continue_S_tids = m_continue_S_tids.size();
1276 if (num_continue_c_tids > 0) {
1277 if (num_continue_c_tids == num_threads) {
1278 // All threads are resuming...
1280 continue_packet.PutChar('c');
1281 continue_packet_error = false;
1282 } else if (num_continue_c_tids == 1 && num_continue_C_tids == 0 &&
1283 num_continue_s_tids == 0 && num_continue_S_tids == 0) {
1284 // Only one thread is continuing
1286 continue_packet.PutChar('c');
1287 continue_packet_error = false;
1288 }
1289 }
1290
1291 if (continue_packet_error && num_continue_C_tids > 0) {
1292 if ((num_continue_C_tids + num_continue_c_tids) == num_threads &&
1293 num_continue_C_tids > 0 && num_continue_s_tids == 0 &&
1294 num_continue_S_tids == 0) {
1295 const int continue_signo = m_continue_C_tids.front().second;
1296 // Only one thread is continuing
1297 if (num_continue_C_tids > 1) {
1298 // More that one thread with a signal, yet we don't have vCont
1299 // support and we are being asked to resume each thread with a
1300 // signal, we need to make sure they are all the same signal, or we
1301 // can't issue the continue accurately with the current support...
1302 if (num_continue_C_tids > 1) {
1303 continue_packet_error = false;
1304 for (size_t i = 1; i < m_continue_C_tids.size(); ++i) {
1305 if (m_continue_C_tids[i].second != continue_signo)
1306 continue_packet_error = true;
1307 }
1308 }
1309 if (!continue_packet_error)
1311 } else {
1312 // Set the continue thread ID
1313 continue_packet_error = false;
1315 }
1316 if (!continue_packet_error) {
1317 // Add threads continuing with the same signo...
1318 continue_packet.Printf("C%2.2x", continue_signo);
1319 }
1320 }
1321 }
1322
1323 if (continue_packet_error && num_continue_s_tids > 0) {
1324 if (num_continue_s_tids == num_threads) {
1325 // All threads are resuming...
1327
1328 continue_packet.PutChar('s');
1329
1330 continue_packet_error = false;
1331 } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1332 num_continue_s_tids == 1 && num_continue_S_tids == 0) {
1333 // Only one thread is stepping
1335 continue_packet.PutChar('s');
1336 continue_packet_error = false;
1337 }
1338 }
1339
1340 if (!continue_packet_error && num_continue_S_tids > 0) {
1341 if (num_continue_S_tids == num_threads) {
1342 const int step_signo = m_continue_S_tids.front().second;
1343 // Are all threads trying to step with the same signal?
1344 continue_packet_error = false;
1345 if (num_continue_S_tids > 1) {
1346 for (size_t i = 1; i < num_threads; ++i) {
1347 if (m_continue_S_tids[i].second != step_signo)
1348 continue_packet_error = true;
1349 }
1350 }
1351 if (!continue_packet_error) {
1352 // Add threads stepping with the same signo...
1354 continue_packet.Printf("S%2.2x", step_signo);
1355 }
1356 } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1357 num_continue_s_tids == 0 && num_continue_S_tids == 1) {
1358 // Only one thread is stepping with signal
1360 continue_packet.Printf("S%2.2x", m_continue_S_tids.front().second);
1361 continue_packet_error = false;
1362 }
1363 }
1364 }
1365
1366 if (continue_packet_error) {
1367 error.SetErrorString("can't make continue packet for this resume");
1368 } else {
1369 EventSP event_sp;
1370 if (!m_async_thread.IsJoinable()) {
1371 error.SetErrorString("Trying to resume but the async thread is dead.");
1372 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: Trying to resume but the "
1373 "async thread is dead.");
1374 return error;
1375 }
1376
1377 auto data_sp =
1378 std::make_shared<EventDataBytes>(continue_packet.GetString());
1380
1381 if (!listener_sp->GetEvent(event_sp, std::chrono::seconds(5))) {
1382 error.SetErrorString("Resume timed out.");
1383 LLDB_LOGF(log, "ProcessGDBRemote::DoResume: Resume timed out.");
1384 } else if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
1385 error.SetErrorString("Broadcast continue, but the async thread was "
1386 "killed before we got an ack back.");
1387 LLDB_LOGF(log,
1388 "ProcessGDBRemote::DoResume: Broadcast continue, but the "
1389 "async thread was killed before we got an ack back.");
1390 return error;
1391 }
1392 }
1393 }
1394
1395 return error;
1396}
1397
1399 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1400 m_thread_ids.clear();
1401 m_thread_pcs.clear();
1402}
1403
1405 llvm::StringRef value) {
1406 m_thread_ids.clear();
1408 StringExtractorGDBRemote thread_ids{value};
1409
1410 do {
1411 auto pid_tid = thread_ids.GetPidTid(pid);
1412 if (pid_tid && pid_tid->first == pid) {
1413 lldb::tid_t tid = pid_tid->second;
1414 if (tid != LLDB_INVALID_THREAD_ID &&
1416 m_thread_ids.push_back(tid);
1417 }
1418 } while (thread_ids.GetChar() == ',');
1419
1420 return m_thread_ids.size();
1421}
1422
1424 llvm::StringRef value) {
1425 m_thread_pcs.clear();
1426 for (llvm::StringRef x : llvm::split(value, ',')) {
1428 if (llvm::to_integer(x, pc, 16))
1429 m_thread_pcs.push_back(pc);
1430 }
1431 return m_thread_pcs.size();
1432}
1433
1435 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1436
1437 if (m_jthreadsinfo_sp) {
1438 // If we have the JSON threads info, we can get the thread list from that
1439 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
1440 if (thread_infos && thread_infos->GetSize() > 0) {
1441 m_thread_ids.clear();
1442 m_thread_pcs.clear();
1443 thread_infos->ForEach([this](StructuredData::Object *object) -> bool {
1444 StructuredData::Dictionary *thread_dict = object->GetAsDictionary();
1445 if (thread_dict) {
1446 // Set the thread stop info from the JSON dictionary
1447 SetThreadStopInfo(thread_dict);
1449 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>("tid", tid))
1450 m_thread_ids.push_back(tid);
1451 }
1452 return true; // Keep iterating through all thread_info objects
1453 });
1454 }
1455 if (!m_thread_ids.empty())
1456 return true;
1457 } else {
1458 // See if we can get the thread IDs from the current stop reply packets
1459 // that might contain a "threads" key/value pair
1460
1461 if (m_last_stop_packet) {
1462 // Get the thread stop info
1464 const std::string &stop_info_str = std::string(stop_info.GetStringRef());
1465
1466 m_thread_pcs.clear();
1467 const size_t thread_pcs_pos = stop_info_str.find(";thread-pcs:");
1468 if (thread_pcs_pos != std::string::npos) {
1469 const size_t start = thread_pcs_pos + strlen(";thread-pcs:");
1470 const size_t end = stop_info_str.find(';', start);
1471 if (end != std::string::npos) {
1472 std::string value = stop_info_str.substr(start, end - start);
1474 }
1475 }
1476
1477 const size_t threads_pos = stop_info_str.find(";threads:");
1478 if (threads_pos != std::string::npos) {
1479 const size_t start = threads_pos + strlen(";threads:");
1480 const size_t end = stop_info_str.find(';', start);
1481 if (end != std::string::npos) {
1482 std::string value = stop_info_str.substr(start, end - start);
1484 return true;
1485 }
1486 }
1487 }
1488 }
1489
1490 bool sequence_mutex_unavailable = false;
1491 m_gdb_comm.GetCurrentThreadIDs(m_thread_ids, sequence_mutex_unavailable);
1492 if (sequence_mutex_unavailable) {
1493 return false; // We just didn't get the list
1494 }
1495 return true;
1496}
1497
1499 ThreadList &new_thread_list) {
1500 // locker will keep a mutex locked until it goes out of scope
1501 Log *log = GetLog(GDBRLog::Thread);
1502 LLDB_LOGV(log, "pid = {0}", GetID());
1503
1504 size_t num_thread_ids = m_thread_ids.size();
1505 // The "m_thread_ids" thread ID list should always be updated after each stop
1506 // reply packet, but in case it isn't, update it here.
1507 if (num_thread_ids == 0) {
1508 if (!UpdateThreadIDList())
1509 return false;
1510 num_thread_ids = m_thread_ids.size();
1511 }
1512
1513 ThreadList old_thread_list_copy(old_thread_list);
1514 if (num_thread_ids > 0) {
1515 for (size_t i = 0; i < num_thread_ids; ++i) {
1516 tid_t tid = m_thread_ids[i];
1517 ThreadSP thread_sp(
1518 old_thread_list_copy.RemoveThreadByProtocolID(tid, false));
1519 if (!thread_sp) {
1520 thread_sp = std::make_shared<ThreadGDBRemote>(*this, tid);
1521 LLDB_LOGV(log, "Making new thread: {0} for thread ID: {1:x}.",
1522 thread_sp.get(), thread_sp->GetID());
1523 } else {
1524 LLDB_LOGV(log, "Found old thread: {0} for thread ID: {1:x}.",
1525 thread_sp.get(), thread_sp->GetID());
1526 }
1527
1528 SetThreadPc(thread_sp, i);
1529 new_thread_list.AddThreadSortedByIndexID(thread_sp);
1530 }
1531 }
1532
1533 // Whatever that is left in old_thread_list_copy are not present in
1534 // new_thread_list. Remove non-existent threads from internal id table.
1535 size_t old_num_thread_ids = old_thread_list_copy.GetSize(false);
1536 for (size_t i = 0; i < old_num_thread_ids; i++) {
1537 ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
1538 if (old_thread_sp) {
1539 lldb::tid_t old_thread_id = old_thread_sp->GetProtocolID();
1540 m_thread_id_to_index_id_map.erase(old_thread_id);
1541 }
1542 }
1543
1544 return true;
1545}
1546
1547void ProcessGDBRemote::SetThreadPc(const ThreadSP &thread_sp, uint64_t index) {
1548 if (m_thread_ids.size() == m_thread_pcs.size() && thread_sp.get() &&
1550 ThreadGDBRemote *gdb_thread =
1551 static_cast<ThreadGDBRemote *>(thread_sp.get());
1552 RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
1553 if (reg_ctx_sp) {
1554 uint32_t pc_regnum = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1556 if (pc_regnum != LLDB_INVALID_REGNUM) {
1557 gdb_thread->PrivateSetRegisterValue(pc_regnum, m_thread_pcs[index]);
1558 }
1559 }
1560 }
1561}
1562
1564 ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp) {
1565 // See if we got thread stop infos for all threads via the "jThreadsInfo"
1566 // packet
1567 if (thread_infos_sp) {
1568 StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray();
1569 if (thread_infos) {
1570 lldb::tid_t tid;
1571 const size_t n = thread_infos->GetSize();
1572 for (size_t i = 0; i < n; ++i) {
1573 StructuredData::Dictionary *thread_dict =
1574 thread_infos->GetItemAtIndex(i)->GetAsDictionary();
1575 if (thread_dict) {
1576 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>(
1577 "tid", tid, LLDB_INVALID_THREAD_ID)) {
1578 if (tid == thread->GetID())
1579 return (bool)SetThreadStopInfo(thread_dict);
1580 }
1581 }
1582 }
1583 }
1584 }
1585 return false;
1586}
1587
1589 // See if we got thread stop infos for all threads via the "jThreadsInfo"
1590 // packet
1592 return true;
1593
1594 // See if we got thread stop info for any threads valid stop info reasons
1595 // threads via the "jstopinfo" packet stop reply packet key/value pair?
1596 if (m_jstopinfo_sp) {
1597 // If we have "jstopinfo" then we have stop descriptions for all threads
1598 // that have stop reasons, and if there is no entry for a thread, then it
1599 // has no stop reason.
1600 thread->GetRegisterContext()->InvalidateIfNeeded(true);
1602 // If a thread is stopped at a breakpoint site, set that as the stop
1603 // reason even if it hasn't executed the breakpoint instruction yet.
1604 // We will silently step over the breakpoint when we resume execution
1605 // and miss the fact that this thread hit the breakpoint.
1606 const size_t num_thread_ids = m_thread_ids.size();
1607 for (size_t i = 0; i < num_thread_ids; i++) {
1608 if (m_thread_ids[i] == thread->GetID() && m_thread_pcs.size() > i) {
1609 addr_t pc = m_thread_pcs[i];
1610 lldb::BreakpointSiteSP bp_site_sp =
1611 thread->GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
1612 if (bp_site_sp) {
1613 if (bp_site_sp->ValidForThisThread(*thread)) {
1614 thread->SetStopInfo(
1616 *thread, bp_site_sp->GetID()));
1617 return true;
1618 }
1619 }
1620 }
1621 }
1622 thread->SetStopInfo(StopInfoSP());
1623 }
1624 return true;
1625 }
1626
1627 // Fall back to using the qThreadStopInfo packet
1628 StringExtractorGDBRemote stop_packet;
1629 if (GetGDBRemote().GetThreadStopInfo(thread->GetProtocolID(), stop_packet))
1630 return SetThreadStopInfo(stop_packet) == eStateStopped;
1631 return false;
1632}
1633
1635 ExpeditedRegisterMap &expedited_register_map, ThreadSP thread_sp) {
1636 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *>(thread_sp.get());
1637 RegisterContextSP gdb_reg_ctx_sp(gdb_thread->GetRegisterContext());
1638
1639 for (const auto &pair : expedited_register_map) {
1640 StringExtractor reg_value_extractor(pair.second);
1641 WritableDataBufferSP buffer_sp(
1642 new DataBufferHeap(reg_value_extractor.GetStringRef().size() / 2, 0));
1643 reg_value_extractor.GetHexBytes(buffer_sp->GetData(), '\xcc');
1644 uint32_t lldb_regnum = gdb_reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1645 eRegisterKindProcessPlugin, pair.first);
1646 gdb_thread->PrivateSetRegisterValue(lldb_regnum, buffer_sp->GetData());
1647 }
1648}
1649
1651 lldb::tid_t tid, ExpeditedRegisterMap &expedited_register_map,
1652 uint8_t signo, const std::string &thread_name, const std::string &reason,
1653 const std::string &description, uint32_t exc_type,
1654 const std::vector<addr_t> &exc_data, addr_t thread_dispatch_qaddr,
1655 bool queue_vars_valid, // Set to true if queue_name, queue_kind and
1656 // queue_serial are valid
1657 LazyBool associated_with_dispatch_queue, addr_t dispatch_queue_t,
1658 std::string &queue_name, QueueKind queue_kind, uint64_t queue_serial) {
1659
1660 if (tid == LLDB_INVALID_THREAD_ID)
1661 return nullptr;
1662
1663 ThreadSP thread_sp;
1664 // Scope for "locker" below
1665 {
1666 // m_thread_list_real does have its own mutex, but we need to hold onto the
1667 // mutex between the call to m_thread_list_real.FindThreadByID(...) and the
1668 // m_thread_list_real.AddThread(...) so it doesn't change on us
1669 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1670 thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
1671
1672 if (!thread_sp) {
1673 // Create the thread if we need to
1674 thread_sp = std::make_shared<ThreadGDBRemote>(*this, tid);
1675 m_thread_list_real.AddThread(thread_sp);
1676 }
1677 }
1678
1679 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *>(thread_sp.get());
1680 RegisterContextSP reg_ctx_sp(gdb_thread->GetRegisterContext());
1681
1682 reg_ctx_sp->InvalidateIfNeeded(true);
1683
1684 auto iter = std::find(m_thread_ids.begin(), m_thread_ids.end(), tid);
1685 if (iter != m_thread_ids.end())
1686 SetThreadPc(thread_sp, iter - m_thread_ids.begin());
1687
1688 ParseExpeditedRegisters(expedited_register_map, thread_sp);
1689
1690 if (reg_ctx_sp->ReconfigureRegisterInfo()) {
1691 // Now we have changed the offsets of all the registers, so the values
1692 // will be corrupted.
1693 reg_ctx_sp->InvalidateAllRegisters();
1694 // Expedited registers values will never contain registers that would be
1695 // resized by a reconfigure. So we are safe to continue using these
1696 // values.
1697 ParseExpeditedRegisters(expedited_register_map, thread_sp);
1698 }
1699
1700 thread_sp->SetName(thread_name.empty() ? nullptr : thread_name.c_str());
1701
1702 gdb_thread->SetThreadDispatchQAddr(thread_dispatch_qaddr);
1703 // Check if the GDB server was able to provide the queue name, kind and serial
1704 // number
1705 if (queue_vars_valid)
1706 gdb_thread->SetQueueInfo(std::move(queue_name), queue_kind, queue_serial,
1707 dispatch_queue_t, associated_with_dispatch_queue);
1708 else
1709 gdb_thread->ClearQueueInfo();
1710
1711 gdb_thread->SetAssociatedWithLibdispatchQueue(associated_with_dispatch_queue);
1712
1713 if (dispatch_queue_t != LLDB_INVALID_ADDRESS)
1714 gdb_thread->SetQueueLibdispatchQueueAddress(dispatch_queue_t);
1715
1716 // Make sure we update our thread stop reason just once, but don't overwrite
1717 // the stop info for threads that haven't moved:
1718 StopInfoSP current_stop_info_sp = thread_sp->GetPrivateStopInfo(false);
1719 if (thread_sp->GetTemporaryResumeState() == eStateSuspended &&
1720 current_stop_info_sp) {
1721 thread_sp->SetStopInfo(current_stop_info_sp);
1722 return thread_sp;
1723 }
1724
1725 if (!thread_sp->StopInfoIsUpToDate()) {
1726 thread_sp->SetStopInfo(StopInfoSP());
1727 // If there's a memory thread backed by this thread, we need to use it to
1728 // calculate StopInfo.
1729 if (ThreadSP memory_thread_sp = m_thread_list.GetBackingThread(thread_sp))
1730 thread_sp = memory_thread_sp;
1731
1732 if (exc_type != 0) {
1733 const size_t exc_data_size = exc_data.size();
1734
1735 thread_sp->SetStopInfo(
1737 *thread_sp, exc_type, exc_data_size,
1738 exc_data_size >= 1 ? exc_data[0] : 0,
1739 exc_data_size >= 2 ? exc_data[1] : 0,
1740 exc_data_size >= 3 ? exc_data[2] : 0));
1741 } else {
1742 bool handled = false;
1743 bool did_exec = false;
1744 // debugserver can send reason = "none" which is equivalent
1745 // to no reason.
1746 if (!reason.empty() && reason != "none") {
1747 if (reason == "trace") {
1748 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1749 lldb::BreakpointSiteSP bp_site_sp =
1750 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
1751 pc);
1752
1753 // If the current pc is a breakpoint site then the StopInfo should be
1754 // set to Breakpoint Otherwise, it will be set to Trace.
1755 if (bp_site_sp && bp_site_sp->ValidForThisThread(*thread_sp)) {
1756 thread_sp->SetStopInfo(
1758 *thread_sp, bp_site_sp->GetID()));
1759 } else
1760 thread_sp->SetStopInfo(
1762 handled = true;
1763 } else if (reason == "breakpoint") {
1764 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1765 lldb::BreakpointSiteSP bp_site_sp =
1766 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
1767 pc);
1768 if (bp_site_sp) {
1769 // If the breakpoint is for this thread, then we'll report the hit,
1770 // but if it is for another thread, we can just report no reason.
1771 // We don't need to worry about stepping over the breakpoint here,
1772 // that will be taken care of when the thread resumes and notices
1773 // that there's a breakpoint under the pc.
1774 handled = true;
1775 if (bp_site_sp->ValidForThisThread(*thread_sp)) {
1776 thread_sp->SetStopInfo(
1778 *thread_sp, bp_site_sp->GetID()));
1779 } else {
1780 StopInfoSP invalid_stop_info_sp;
1781 thread_sp->SetStopInfo(invalid_stop_info_sp);
1782 }
1783 }
1784 } else if (reason == "trap") {
1785 // Let the trap just use the standard signal stop reason below...
1786 } else if (reason == "watchpoint") {
1787 // We will have between 1 and 3 fields in the description.
1788 //
1789 // \a wp_addr which is the original start address that
1790 // lldb requested be watched, or an address that the
1791 // hardware reported. This address should be within the
1792 // range of a currently active watchpoint region - lldb
1793 // should be able to find a watchpoint with this address.
1794 //
1795 // \a wp_index is the hardware watchpoint register number.
1796 //
1797 // \a wp_hit_addr is the actual address reported by the hardware,
1798 // which may be outside the range of a region we are watching.
1799 //
1800 // On MIPS, we may get a false watchpoint exception where an
1801 // access to the same 8 byte granule as a watchpoint will trigger,
1802 // even if the access was not within the range of the watched
1803 // region. When we get a \a wp_hit_addr outside the range of any
1804 // set watchpoint, continue execution without making it visible to
1805 // the user.
1806 //
1807 // On ARM, a related issue where a large access that starts
1808 // before the watched region (and extends into the watched
1809 // region) may report a hit address before the watched region.
1810 // lldb will not find the "nearest" watchpoint to
1811 // disable/step/re-enable it, so one of the valid watchpoint
1812 // addresses should be provided as \a wp_addr.
1813 StringExtractor desc_extractor(description.c_str());
1814 // FIXME NativeThreadLinux::SetStoppedByWatchpoint sends this
1815 // up as
1816 // <address within wp range> <wp hw index> <actual accessed addr>
1817 // but this is not reading the <wp hw index>. Seems like it
1818 // wouldn't work on MIPS, where that third field is important.
1819 addr_t wp_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
1820 addr_t wp_hit_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
1822 bool silently_continue = false;
1823 WatchpointResourceSP wp_resource_sp;
1824 if (wp_hit_addr != LLDB_INVALID_ADDRESS) {
1825 wp_resource_sp =
1827 // On MIPS, \a wp_hit_addr outside the range of a watched
1828 // region means we should silently continue, it is a false hit.
1830 if (!wp_resource_sp && core >= ArchSpec::kCore_mips_first &&
1832 silently_continue = true;
1833 }
1834 if (!wp_resource_sp && wp_addr != LLDB_INVALID_ADDRESS)
1835 wp_resource_sp = m_watchpoint_resource_list.FindByAddress(wp_addr);
1836 if (!wp_resource_sp) {
1838 LLDB_LOGF(log, "failed to find watchpoint");
1839 watch_id = LLDB_INVALID_SITE_ID;
1840 } else {
1841 // LWP_TODO: This is hardcoding a single Watchpoint in a
1842 // Resource, need to add
1843 // StopInfo::CreateStopReasonWithWatchpointResource which
1844 // represents all watchpoints that were tripped at this stop.
1845 watch_id = wp_resource_sp->GetConstituentAtIndex(0)->GetID();
1846 }
1847 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithWatchpointID(
1848 *thread_sp, watch_id, silently_continue));
1849 handled = true;
1850 } else if (reason == "exception") {
1851 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
1852 *thread_sp, description.c_str()));
1853 handled = true;
1854 } else if (reason == "exec") {
1855 did_exec = true;
1856 thread_sp->SetStopInfo(
1858 handled = true;
1859 } else if (reason == "processor trace") {
1860 thread_sp->SetStopInfo(StopInfo::CreateStopReasonProcessorTrace(
1861 *thread_sp, description.c_str()));
1862 } else if (reason == "fork") {
1863 StringExtractor desc_extractor(description.c_str());
1864 lldb::pid_t child_pid =
1865 desc_extractor.GetU64(LLDB_INVALID_PROCESS_ID);
1866 lldb::tid_t child_tid = desc_extractor.GetU64(LLDB_INVALID_THREAD_ID);
1867 thread_sp->SetStopInfo(
1868 StopInfo::CreateStopReasonFork(*thread_sp, child_pid, child_tid));
1869 handled = true;
1870 } else if (reason == "vfork") {
1871 StringExtractor desc_extractor(description.c_str());
1872 lldb::pid_t child_pid =
1873 desc_extractor.GetU64(LLDB_INVALID_PROCESS_ID);
1874 lldb::tid_t child_tid = desc_extractor.GetU64(LLDB_INVALID_THREAD_ID);
1875 thread_sp->SetStopInfo(StopInfo::CreateStopReasonVFork(
1876 *thread_sp, child_pid, child_tid));
1877 handled = true;
1878 } else if (reason == "vforkdone") {
1879 thread_sp->SetStopInfo(
1881 handled = true;
1882 }
1883 } else if (!signo) {
1884 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1885 lldb::BreakpointSiteSP bp_site_sp =
1886 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
1887
1888 // If a thread is stopped at a breakpoint site, set that as the stop
1889 // reason even if it hasn't executed the breakpoint instruction yet.
1890 // We will silently step over the breakpoint when we resume execution
1891 // and miss the fact that this thread hit the breakpoint.
1892 if (bp_site_sp && bp_site_sp->ValidForThisThread(*thread_sp)) {
1894 *thread_sp, bp_site_sp->GetID()));
1895 handled = true;
1896 }
1897 }
1898
1899 if (!handled && signo && !did_exec) {
1900 if (signo == SIGTRAP) {
1901 // Currently we are going to assume SIGTRAP means we are either
1902 // hitting a breakpoint or hardware single stepping.
1903 handled = true;
1904 addr_t pc =
1905 thread_sp->GetRegisterContext()->GetPC() + m_breakpoint_pc_offset;
1906 lldb::BreakpointSiteSP bp_site_sp =
1907 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
1908 pc);
1909
1910 if (bp_site_sp) {
1911 // If the breakpoint is for this thread, then we'll report the hit,
1912 // but if it is for another thread, we can just report no reason.
1913 // We don't need to worry about stepping over the breakpoint here,
1914 // that will be taken care of when the thread resumes and notices
1915 // that there's a breakpoint under the pc.
1916 if (bp_site_sp->ValidForThisThread(*thread_sp)) {
1917 if (m_breakpoint_pc_offset != 0)
1918 thread_sp->GetRegisterContext()->SetPC(pc);
1919 thread_sp->SetStopInfo(
1921 *thread_sp, bp_site_sp->GetID()));
1922 } else {
1923 StopInfoSP invalid_stop_info_sp;
1924 thread_sp->SetStopInfo(invalid_stop_info_sp);
1925 }
1926 } else {
1927 // If we were stepping then assume the stop was the result of the
1928 // trace. If we were not stepping then report the SIGTRAP.
1929 // FIXME: We are still missing the case where we single step over a
1930 // trap instruction.
1931 if (thread_sp->GetTemporaryResumeState() == eStateStepping)
1932 thread_sp->SetStopInfo(
1934 else
1935 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1936 *thread_sp, signo, description.c_str()));
1937 }
1938 }
1939 if (!handled)
1940 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1941 *thread_sp, signo, description.c_str()));
1942 }
1943
1944 if (!description.empty()) {
1945 lldb::StopInfoSP stop_info_sp(thread_sp->GetStopInfo());
1946 if (stop_info_sp) {
1947 const char *stop_info_desc = stop_info_sp->GetDescription();
1948 if (!stop_info_desc || !stop_info_desc[0])
1949 stop_info_sp->SetDescription(description.c_str());
1950 } else {
1951 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
1952 *thread_sp, description.c_str()));
1953 }
1954 }
1955 }
1956 }
1957 return thread_sp;
1958}
1959
1962 static constexpr llvm::StringLiteral g_key_tid("tid");
1963 static constexpr llvm::StringLiteral g_key_name("name");
1964 static constexpr llvm::StringLiteral g_key_reason("reason");
1965 static constexpr llvm::StringLiteral g_key_metype("metype");
1966 static constexpr llvm::StringLiteral g_key_medata("medata");
1967 static constexpr llvm::StringLiteral g_key_qaddr("qaddr");
1968 static constexpr llvm::StringLiteral g_key_dispatch_queue_t(
1969 "dispatch_queue_t");
1970 static constexpr llvm::StringLiteral g_key_associated_with_dispatch_queue(
1971 "associated_with_dispatch_queue");
1972 static constexpr llvm::StringLiteral g_key_queue_name("qname");
1973 static constexpr llvm::StringLiteral g_key_queue_kind("qkind");
1974 static constexpr llvm::StringLiteral g_key_queue_serial_number("qserialnum");
1975 static constexpr llvm::StringLiteral g_key_registers("registers");
1976 static constexpr llvm::StringLiteral g_key_memory("memory");
1977 static constexpr llvm::StringLiteral g_key_description("description");
1978 static constexpr llvm::StringLiteral g_key_signal("signal");
1979
1980 // Stop with signal and thread info
1982 uint8_t signo = 0;
1983 std::string value;
1984 std::string thread_name;
1985 std::string reason;
1986 std::string description;
1987 uint32_t exc_type = 0;
1988 std::vector<addr_t> exc_data;
1989 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
1990 ExpeditedRegisterMap expedited_register_map;
1991 bool queue_vars_valid = false;
1992 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS;
1993 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
1994 std::string queue_name;
1995 QueueKind queue_kind = eQueueKindUnknown;
1996 uint64_t queue_serial_number = 0;
1997 // Iterate through all of the thread dictionary key/value pairs from the
1998 // structured data dictionary
1999
2000 // FIXME: we're silently ignoring invalid data here
2001 thread_dict->ForEach([this, &tid, &expedited_register_map, &thread_name,
2002 &signo, &reason, &description, &exc_type, &exc_data,
2003 &thread_dispatch_qaddr, &queue_vars_valid,
2004 &associated_with_dispatch_queue, &dispatch_queue_t,
2005 &queue_name, &queue_kind, &queue_serial_number](
2006 llvm::StringRef key,
2007 StructuredData::Object *object) -> bool {
2008 if (key == g_key_tid) {
2009 // thread in big endian hex
2010 tid = object->GetUnsignedIntegerValue(LLDB_INVALID_THREAD_ID);
2011 } else if (key == g_key_metype) {
2012 // exception type in big endian hex
2013 exc_type = object->GetUnsignedIntegerValue(0);
2014 } else if (key == g_key_medata) {
2015 // exception data in big endian hex
2016 StructuredData::Array *array = object->GetAsArray();
2017 if (array) {
2018 array->ForEach([&exc_data](StructuredData::Object *object) -> bool {
2019 exc_data.push_back(object->GetUnsignedIntegerValue());
2020 return true; // Keep iterating through all array items
2021 });
2022 }
2023 } else if (key == g_key_name) {
2024 thread_name = std::string(object->GetStringValue());
2025 } else if (key == g_key_qaddr) {
2026 thread_dispatch_qaddr =
2027 object->GetUnsignedIntegerValue(LLDB_INVALID_ADDRESS);
2028 } else if (key == g_key_queue_name) {
2029 queue_vars_valid = true;
2030 queue_name = std::string(object->GetStringValue());
2031 } else if (key == g_key_queue_kind) {
2032 std::string queue_kind_str = std::string(object->GetStringValue());
2033 if (queue_kind_str == "serial") {
2034 queue_vars_valid = true;
2035 queue_kind = eQueueKindSerial;
2036 } else if (queue_kind_str == "concurrent") {
2037 queue_vars_valid = true;
2038 queue_kind = eQueueKindConcurrent;
2039 }
2040 } else if (key == g_key_queue_serial_number) {
2041 queue_serial_number = object->GetUnsignedIntegerValue(0);
2042 if (queue_serial_number != 0)
2043 queue_vars_valid = true;
2044 } else if (key == g_key_dispatch_queue_t) {
2045 dispatch_queue_t = object->GetUnsignedIntegerValue(0);
2046 if (dispatch_queue_t != 0 && dispatch_queue_t != LLDB_INVALID_ADDRESS)
2047 queue_vars_valid = true;
2048 } else if (key == g_key_associated_with_dispatch_queue) {
2049 queue_vars_valid = true;
2050 bool associated = object->GetBooleanValue();
2051 if (associated)
2052 associated_with_dispatch_queue = eLazyBoolYes;
2053 else
2054 associated_with_dispatch_queue = eLazyBoolNo;
2055 } else if (key == g_key_reason) {
2056 reason = std::string(object->GetStringValue());
2057 } else if (key == g_key_description) {
2058 description = std::string(object->GetStringValue());
2059 } else if (key == g_key_registers) {
2060 StructuredData::Dictionary *registers_dict = object->GetAsDictionary();
2061
2062 if (registers_dict) {
2063 registers_dict->ForEach(
2064 [&expedited_register_map](llvm::StringRef key,
2065 StructuredData::Object *object) -> bool {
2066 uint32_t reg;
2067 if (llvm::to_integer(key, reg))
2068 expedited_register_map[reg] =
2069 std::string(object->GetStringValue());
2070 return true; // Keep iterating through all array items
2071 });
2072 }
2073 } else if (key == g_key_memory) {
2074 StructuredData::Array *array = object->GetAsArray();
2075 if (array) {
2076 array->ForEach([this](StructuredData::Object *object) -> bool {
2077 StructuredData::Dictionary *mem_cache_dict =
2078 object->GetAsDictionary();
2079 if (mem_cache_dict) {
2080 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
2081 if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>(
2082 "address", mem_cache_addr)) {
2083 if (mem_cache_addr != LLDB_INVALID_ADDRESS) {
2084 llvm::StringRef str;
2085 if (mem_cache_dict->GetValueForKeyAsString("bytes", str)) {
2086 StringExtractor bytes(str);
2087 bytes.SetFilePos(0);
2088
2089 const size_t byte_size = bytes.GetStringRef().size() / 2;
2090 WritableDataBufferSP data_buffer_sp(
2091 new DataBufferHeap(byte_size, 0));
2092 const size_t bytes_copied =
2093 bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
2094 if (bytes_copied == byte_size)
2095 m_memory_cache.AddL1CacheData(mem_cache_addr,
2096 data_buffer_sp);
2097 }
2098 }
2099 }
2100 }
2101 return true; // Keep iterating through all array items
2102 });
2103 }
2104
2105 } else if (key == g_key_signal)
2106 signo = object->GetUnsignedIntegerValue(LLDB_INVALID_SIGNAL_NUMBER);
2107 return true; // Keep iterating through all dictionary key/value pairs
2108 });
2109
2110 return SetThreadStopInfo(tid, expedited_register_map, signo, thread_name,
2111 reason, description, exc_type, exc_data,
2112 thread_dispatch_qaddr, queue_vars_valid,
2113 associated_with_dispatch_queue, dispatch_queue_t,
2114 queue_name, queue_kind, queue_serial_number);
2115}
2116
2119 stop_packet.SetFilePos(0);
2120 const char stop_type = stop_packet.GetChar();
2121 switch (stop_type) {
2122 case 'T':
2123 case 'S': {
2124 // This is a bit of a hack, but it is required. If we did exec, we need to
2125 // clear our thread lists and also know to rebuild our dynamic register
2126 // info before we lookup and threads and populate the expedited register
2127 // values so we need to know this right away so we can cleanup and update
2128 // our registers.
2129 const uint32_t stop_id = GetStopID();
2130 if (stop_id == 0) {
2131 // Our first stop, make sure we have a process ID, and also make sure we
2132 // know about our registers
2134 SetID(pid);
2136 }
2137 // Stop with signal and thread info
2140 const uint8_t signo = stop_packet.GetHexU8();
2141 llvm::StringRef key;
2142 llvm::StringRef value;
2143 std::string thread_name;
2144 std::string reason;
2145 std::string description;
2146 uint32_t exc_type = 0;
2147 std::vector<addr_t> exc_data;
2148 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
2149 bool queue_vars_valid =
2150 false; // says if locals below that start with "queue_" are valid
2151 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS;
2152 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2153 std::string queue_name;
2154 QueueKind queue_kind = eQueueKindUnknown;
2155 uint64_t queue_serial_number = 0;
2156 ExpeditedRegisterMap expedited_register_map;
2157 AddressableBits addressable_bits;
2158 while (stop_packet.GetNameColonValue(key, value)) {
2159 if (key.compare("metype") == 0) {
2160 // exception type in big endian hex
2161 value.getAsInteger(16, exc_type);
2162 } else if (key.compare("medata") == 0) {
2163 // exception data in big endian hex
2164 uint64_t x;
2165 value.getAsInteger(16, x);
2166 exc_data.push_back(x);
2167 } else if (key.compare("thread") == 0) {
2168 // thread-id
2169 StringExtractorGDBRemote thread_id{value};
2170 auto pid_tid = thread_id.GetPidTid(pid);
2171 if (pid_tid) {
2172 stop_pid = pid_tid->first;
2173 tid = pid_tid->second;
2174 } else
2176 } else if (key.compare("threads") == 0) {
2177 std::lock_guard<std::recursive_mutex> guard(
2180 } else if (key.compare("thread-pcs") == 0) {
2181 m_thread_pcs.clear();
2182 // A comma separated list of all threads in the current
2183 // process that includes the thread for this stop reply packet
2185 while (!value.empty()) {
2186 llvm::StringRef pc_str;
2187 std::tie(pc_str, value) = value.split(',');
2188 if (pc_str.getAsInteger(16, pc))
2190 m_thread_pcs.push_back(pc);
2191 }
2192 } else if (key.compare("jstopinfo") == 0) {
2193 StringExtractor json_extractor(value);
2194 std::string json;
2195 // Now convert the HEX bytes into a string value
2196 json_extractor.GetHexByteString(json);
2197
2198 // This JSON contains thread IDs and thread stop info for all threads.
2199 // It doesn't contain expedited registers, memory or queue info.
2201 } else if (key.compare("hexname") == 0) {
2202 StringExtractor name_extractor(value);
2203 std::string name;
2204 // Now convert the HEX bytes into a string value
2205 name_extractor.GetHexByteString(thread_name);
2206 } else if (key.compare("name") == 0) {
2207 thread_name = std::string(value);
2208 } else if (key.compare("qaddr") == 0) {
2209 value.getAsInteger(16, thread_dispatch_qaddr);
2210 } else if (key.compare("dispatch_queue_t") == 0) {
2211 queue_vars_valid = true;
2212 value.getAsInteger(16, dispatch_queue_t);
2213 } else if (key.compare("qname") == 0) {
2214 queue_vars_valid = true;
2215 StringExtractor name_extractor(value);
2216 // Now convert the HEX bytes into a string value
2217 name_extractor.GetHexByteString(queue_name);
2218 } else if (key.compare("qkind") == 0) {
2219 queue_kind = llvm::StringSwitch<QueueKind>(value)
2220 .Case("serial", eQueueKindSerial)
2221 .Case("concurrent", eQueueKindConcurrent)
2222 .Default(eQueueKindUnknown);
2223 queue_vars_valid = queue_kind != eQueueKindUnknown;
2224 } else if (key.compare("qserialnum") == 0) {
2225 if (!value.getAsInteger(0, queue_serial_number))
2226 queue_vars_valid = true;
2227 } else if (key.compare("reason") == 0) {
2228 reason = std::string(value);
2229 } else if (key.compare("description") == 0) {
2230 StringExtractor desc_extractor(value);
2231 // Now convert the HEX bytes into a string value
2232 desc_extractor.GetHexByteString(description);
2233 } else if (key.compare("memory") == 0) {
2234 // Expedited memory. GDB servers can choose to send back expedited
2235 // memory that can populate the L1 memory cache in the process so that
2236 // things like the frame pointer backchain can be expedited. This will
2237 // help stack backtracing be more efficient by not having to send as
2238 // many memory read requests down the remote GDB server.
2239
2240 // Key/value pair format: memory:<addr>=<bytes>;
2241 // <addr> is a number whose base will be interpreted by the prefix:
2242 // "0x[0-9a-fA-F]+" for hex
2243 // "0[0-7]+" for octal
2244 // "[1-9]+" for decimal
2245 // <bytes> is native endian ASCII hex bytes just like the register
2246 // values
2247 llvm::StringRef addr_str, bytes_str;
2248 std::tie(addr_str, bytes_str) = value.split('=');
2249 if (!addr_str.empty() && !bytes_str.empty()) {
2250 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
2251 if (!addr_str.getAsInteger(0, mem_cache_addr)) {
2252 StringExtractor bytes(bytes_str);
2253 const size_t byte_size = bytes.GetBytesLeft() / 2;
2254 WritableDataBufferSP data_buffer_sp(
2255 new DataBufferHeap(byte_size, 0));
2256 const size_t bytes_copied =
2257 bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
2258 if (bytes_copied == byte_size)
2259 m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp);
2260 }
2261 }
2262 } else if (key.compare("watch") == 0 || key.compare("rwatch") == 0 ||
2263 key.compare("awatch") == 0) {
2264 // Support standard GDB remote stop reply packet 'TAAwatch:addr'
2266 value.getAsInteger(16, wp_addr);
2267
2268 WatchpointResourceSP wp_resource_sp =
2270
2271 // Rewrite gdb standard watch/rwatch/awatch to
2272 // "reason:watchpoint" + "description:ADDR",
2273 // which is parsed in SetThreadStopInfo.
2274 reason = "watchpoint";
2275 StreamString ostr;
2276 ostr.Printf("%" PRIu64, wp_addr);
2277 description = std::string(ostr.GetString());
2278 } else if (key.compare("library") == 0) {
2279 auto error = LoadModules();
2280 if (error) {
2282 LLDB_LOG_ERROR(log, std::move(error), "Failed to load modules: {0}");
2283 }
2284 } else if (key.compare("fork") == 0 || key.compare("vfork") == 0) {
2285 // fork includes child pid/tid in thread-id format
2286 StringExtractorGDBRemote thread_id{value};
2287 auto pid_tid = thread_id.GetPidTid(LLDB_INVALID_PROCESS_ID);
2288 if (!pid_tid) {
2290 LLDB_LOG(log, "Invalid PID/TID to fork: {0}", value);
2292 }
2293
2294 reason = key.str();
2295 StreamString ostr;
2296 ostr.Printf("%" PRIu64 " %" PRIu64, pid_tid->first, pid_tid->second);
2297 description = std::string(ostr.GetString());
2298 } else if (key.compare("addressing_bits") == 0) {
2299 uint64_t addressing_bits;
2300 if (!value.getAsInteger(0, addressing_bits)) {
2301 addressable_bits.SetAddressableBits(addressing_bits);
2302 }
2303 } else if (key.compare("low_mem_addressing_bits") == 0) {
2304 uint64_t addressing_bits;
2305 if (!value.getAsInteger(0, addressing_bits)) {
2306 addressable_bits.SetLowmemAddressableBits(addressing_bits);
2307 }
2308 } else if (key.compare("high_mem_addressing_bits") == 0) {
2309 uint64_t addressing_bits;
2310 if (!value.getAsInteger(0, addressing_bits)) {
2311 addressable_bits.SetHighmemAddressableBits(addressing_bits);
2312 }
2313 } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
2314 uint32_t reg = UINT32_MAX;
2315 if (!key.getAsInteger(16, reg))
2316 expedited_register_map[reg] = std::string(std::move(value));
2317 }
2318 }
2319
2320 if (stop_pid != LLDB_INVALID_PROCESS_ID && stop_pid != pid) {
2321 Log *log = GetLog(GDBRLog::Process);
2322 LLDB_LOG(log,
2323 "Received stop for incorrect PID = {0} (inferior PID = {1})",
2324 stop_pid, pid);
2325 return eStateInvalid;
2326 }
2327
2328 if (tid == LLDB_INVALID_THREAD_ID) {
2329 // A thread id may be invalid if the response is old style 'S' packet
2330 // which does not provide the
2331 // thread information. So update the thread list and choose the first
2332 // one.
2334
2335 if (!m_thread_ids.empty()) {
2336 tid = m_thread_ids.front();
2337 }
2338 }
2339
2340 SetAddressableBitMasks(addressable_bits);
2341
2342 ThreadSP thread_sp = SetThreadStopInfo(
2343 tid, expedited_register_map, signo, thread_name, reason, description,
2344 exc_type, exc_data, thread_dispatch_qaddr, queue_vars_valid,
2345 associated_with_dispatch_queue, dispatch_queue_t, queue_name,
2346 queue_kind, queue_serial_number);
2347
2348 return eStateStopped;
2349 } break;
2350
2351 case 'W':
2352 case 'X':
2353 // process exited
2354 return eStateExited;
2355
2356 default:
2357 break;
2358 }
2359 return eStateInvalid;
2360}
2361
2363 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
2364
2365 m_thread_ids.clear();
2366 m_thread_pcs.clear();
2367
2368 // Set the thread stop info. It might have a "threads" key whose value is a
2369 // list of all thread IDs in the current process, so m_thread_ids might get
2370 // set.
2371 // Check to see if SetThreadStopInfo() filled in m_thread_ids?
2372 if (m_thread_ids.empty()) {
2373 // No, we need to fetch the thread list manually
2375 }
2376
2377 // We might set some stop info's so make sure the thread list is up to
2378 // date before we do that or we might overwrite what was computed here.
2380
2383 m_last_stop_packet.reset();
2384
2385 // If we have queried for a default thread id
2389 }
2390
2391 // Let all threads recover from stopping and do any clean up based on the
2392 // previous thread state (if any).
2394}
2395
2397 Status error;
2398
2400 // We are being asked to halt during an attach. We used to just close our
2401 // file handle and debugserver will go away, but with remote proxies, it
2402 // is better to send a positive signal, so let's send the interrupt first...
2403 caused_stop = m_gdb_comm.Interrupt(GetInterruptTimeout());
2405 } else
2406 caused_stop = m_gdb_comm.Interrupt(GetInterruptTimeout());
2407 return error;
2408}
2409
2411 Status error;
2412 Log *log = GetLog(GDBRLog::Process);
2413 LLDB_LOGF(log, "ProcessGDBRemote::DoDetach(keep_stopped: %i)", keep_stopped);
2414
2415 error = m_gdb_comm.Detach(keep_stopped);
2416 if (log) {
2417 if (error.Success())
2418 log->PutCString(
2419 "ProcessGDBRemote::DoDetach() detach packet sent successfully");
2420 else
2421 LLDB_LOGF(log,
2422 "ProcessGDBRemote::DoDetach() detach packet send failed: %s",
2423 error.AsCString() ? error.AsCString() : "<unknown error>");
2424 }
2425
2426 if (!error.Success())
2427 return error;
2428
2429 // Sleep for one second to let the process get all detached...
2431
2434
2435 // KillDebugserverProcess ();
2436 return error;
2437}
2438
2440 Log *log = GetLog(GDBRLog::Process);
2441 LLDB_LOGF(log, "ProcessGDBRemote::DoDestroy()");
2442
2443 // Interrupt if our inferior is running...
2444 int exit_status = SIGABRT;
2445 std::string exit_string;
2446
2447 if (m_gdb_comm.IsConnected()) {
2449 llvm::Expected<int> kill_res = m_gdb_comm.KillProcess(GetID());
2450
2451 if (kill_res) {
2452 exit_status = kill_res.get();
2453#if defined(__APPLE__)
2454 // For Native processes on Mac OS X, we launch through the Host
2455 // Platform, then hand the process off to debugserver, which becomes
2456 // the parent process through "PT_ATTACH". Then when we go to kill
2457 // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then
2458 // we call waitpid which returns with no error and the correct
2459 // status. But amusingly enough that doesn't seem to actually reap
2460 // the process, but instead it is left around as a Zombie. Probably
2461 // the kernel is in the process of switching ownership back to lldb
2462 // which was the original parent, and gets confused in the handoff.
2463 // Anyway, so call waitpid here to finally reap it.
2464 PlatformSP platform_sp(GetTarget().GetPlatform());
2465 if (platform_sp && platform_sp->IsHost()) {
2466 int status;
2467 ::pid_t reap_pid;
2468 reap_pid = waitpid(GetID(), &status, WNOHANG);
2469 LLDB_LOGF(log, "Reaped pid: %d, status: %d.\n", reap_pid, status);
2470 }
2471#endif
2473 exit_string.assign("killed");
2474 } else {
2475 exit_string.assign(llvm::toString(kill_res.takeError()));
2476 }
2477 } else {
2478 exit_string.assign("killed or interrupted while attaching.");
2479 }
2480 } else {
2481 // If we missed setting the exit status on the way out, do it here.
2482 // NB set exit status can be called multiple times, the first one sets the
2483 // status.
2484 exit_string.assign("destroying when not connected to debugserver");
2485 }
2486
2487 SetExitStatus(exit_status, exit_string.c_str());
2488
2491 return Status();
2492}
2493
2495 const StringExtractorGDBRemote &response) {
2496 const bool did_exec =
2497 response.GetStringRef().find(";reason:exec;") != std::string::npos;
2498 if (did_exec) {
2499 Log *log = GetLog(GDBRLog::Process);
2500 LLDB_LOGF(log, "ProcessGDBRemote::SetLastStopPacket () - detected exec");
2501
2506 }
2507
2508 m_last_stop_packet = response;
2509}
2510
2512 Process::SetUnixSignals(std::make_shared<GDBRemoteSignals>(signals_sp));
2513}
2514
2515// Process Queries
2516
2519}
2520
2522 // request the link map address via the $qShlibInfoAddr packet
2524
2525 // the loaded module list can also provides a link map address
2526 if (addr == LLDB_INVALID_ADDRESS) {
2527 llvm::Expected<LoadedModuleInfoList> list = GetLoadedModuleList();
2528 if (!list) {
2529 Log *log = GetLog(GDBRLog::Process);
2530 LLDB_LOG_ERROR(log, list.takeError(), "Failed to read module list: {0}.");
2531 } else {
2532 addr = list->m_link_map;
2533 }
2534 }
2535
2536 return addr;
2537}
2538
2540 // See if the GDB remote client supports the JSON threads info. If so, we
2541 // gather stop info for all threads, expedited registers, expedited memory,
2542 // runtime queue information (iOS and MacOSX only), and more. Expediting
2543 // memory will help stack backtracing be much faster. Expediting registers
2544 // will make sure we don't have to read the thread registers for GPRs.
2546
2547 if (m_jthreadsinfo_sp) {
2548 // Now set the stop info for each thread and also expedite any registers
2549 // and memory that was in the jThreadsInfo response.
2550 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
2551 if (thread_infos) {
2552 const size_t n = thread_infos->GetSize();
2553 for (size_t i = 0; i < n; ++i) {
2554 StructuredData::Dictionary *thread_dict =
2555 thread_infos->GetItemAtIndex(i)->GetAsDictionary();
2556 if (thread_dict)
2557 SetThreadStopInfo(thread_dict);
2558 }
2559 }
2560 }
2561}
2562
2563// Process Memory
2564size_t ProcessGDBRemote::DoReadMemory(addr_t addr, void *buf, size_t size,
2565 Status &error) {
2567 bool binary_memory_read = m_gdb_comm.GetxPacketSupported();
2568 // M and m packets take 2 bytes for 1 byte of memory
2569 size_t max_memory_size =
2570 binary_memory_read ? m_max_memory_size : m_max_memory_size / 2;
2571 if (size > max_memory_size) {
2572 // Keep memory read sizes down to a sane limit. This function will be
2573 // called multiple times in order to complete the task by
2574 // lldb_private::Process so it is ok to do this.
2575 size = max_memory_size;
2576 }
2577
2578 char packet[64];
2579 int packet_len;
2580 packet_len = ::snprintf(packet, sizeof(packet), "%c%" PRIx64 ",%" PRIx64,
2581 binary_memory_read ? 'x' : 'm', (uint64_t)addr,
2582 (uint64_t)size);
2583 assert(packet_len + 1 < (int)sizeof(packet));
2584 UNUSED_IF_ASSERT_DISABLED(packet_len);
2585 StringExtractorGDBRemote response;
2586 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response,
2589 if (response.IsNormalResponse()) {
2590 error.Clear();
2591 if (binary_memory_read) {
2592 // The lower level GDBRemoteCommunication packet receive layer has
2593 // already de-quoted any 0x7d character escaping that was present in
2594 // the packet
2595
2596 size_t data_received_size = response.GetBytesLeft();
2597 if (data_received_size > size) {
2598 // Don't write past the end of BUF if the remote debug server gave us
2599 // too much data for some reason.
2600 data_received_size = size;
2601 }
2602 memcpy(buf, response.GetStringRef().data(), data_received_size);
2603 return data_received_size;
2604 } else {
2605 return response.GetHexBytes(
2606 llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, size), '\xdd');
2607 }
2608 } else if (response.IsErrorResponse())
2609 error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr);
2610 else if (response.IsUnsupportedResponse())
2611 error.SetErrorStringWithFormat(
2612 "GDB server does not support reading memory");
2613 else
2614 error.SetErrorStringWithFormat(
2615 "unexpected response to GDB server memory read packet '%s': '%s'",
2616 packet, response.GetStringRef().data());
2617 } else {
2618 error.SetErrorStringWithFormat("failed to send packet: '%s'", packet);
2619 }
2620 return 0;
2621}
2622
2625}
2626
2627llvm::Expected<std::vector<uint8_t>>
2629 int32_t type) {
2630 // By this point ReadMemoryTags has validated that tagging is enabled
2631 // for this target/process/address.
2632 DataBufferSP buffer_sp = m_gdb_comm.ReadMemoryTags(addr, len, type);
2633 if (!buffer_sp) {
2634 return llvm::createStringError(llvm::inconvertibleErrorCode(),
2635 "Error reading memory tags from remote");
2636 }
2637
2638 // Return the raw tag data
2639 llvm::ArrayRef<uint8_t> tag_data = buffer_sp->GetData();
2640 std::vector<uint8_t> got;
2641 got.reserve(tag_data.size());
2642 std::copy(tag_data.begin(), tag_data.end(), std::back_inserter(got));
2643 return got;
2644}
2645
2647 int32_t type,
2648 const std::vector<uint8_t> &tags) {
2649 // By now WriteMemoryTags should have validated that tagging is enabled
2650 // for this target/process.
2651 return m_gdb_comm.WriteMemoryTags(addr, len, type, tags);
2652}
2653
2655 std::vector<ObjectFile::LoadableData> entries) {
2656 Status error;
2657 // Sort the entries by address because some writes, like those to flash
2658 // memory, must happen in order of increasing address.
2659 std::stable_sort(
2660 std::begin(entries), std::end(entries),
2662 return a.Dest < b.Dest;
2663 });
2664 m_allow_flash_writes = true;
2666 if (error.Success())
2667 error = FlashDone();
2668 else
2669 // Even though some of the writing failed, try to send a flash done if some
2670 // of the writing succeeded so the flash state is reset to normal, but
2671 // don't stomp on the error status that was set in the write failure since
2672 // that's the one we want to report back.
2673 FlashDone();
2674 m_allow_flash_writes = false;
2675 return error;
2676}
2677
2679 auto size = m_erased_flash_ranges.GetSize();
2680 for (size_t i = 0; i < size; ++i)
2682 return true;
2683 return false;
2684}
2685
2687 Status status;
2688
2689 MemoryRegionInfo region;
2690 status = GetMemoryRegionInfo(addr, region);
2691 if (!status.Success())
2692 return status;
2693
2694 // The gdb spec doesn't say if erasures are allowed across multiple regions,
2695 // but we'll disallow it to be safe and to keep the logic simple by worring
2696 // about only one region's block size. DoMemoryWrite is this function's
2697 // primary user, and it can easily keep writes within a single memory region
2698 if (addr + size > region.GetRange().GetRangeEnd()) {
2699 status.SetErrorString("Unable to erase flash in multiple regions");
2700 return status;
2701 }
2702
2703 uint64_t blocksize = region.GetBlocksize();
2704 if (blocksize == 0) {
2705 status.SetErrorString("Unable to erase flash because blocksize is 0");
2706 return status;
2707 }
2708
2709 // Erasures can only be done on block boundary adresses, so round down addr
2710 // and round up size
2711 lldb::addr_t block_start_addr = addr - (addr % blocksize);
2712 size += (addr - block_start_addr);
2713 if ((size % blocksize) != 0)
2714 size += (blocksize - size % blocksize);
2715
2716 FlashRange range(block_start_addr, size);
2717
2718 if (HasErased(range))
2719 return status;
2720
2721 // We haven't erased the entire range, but we may have erased part of it.
2722 // (e.g., block A is already erased and range starts in A and ends in B). So,
2723 // adjust range if necessary to exclude already erased blocks.
2725 // Assuming that writes and erasures are done in increasing addr order,
2726 // because that is a requirement of the vFlashWrite command. Therefore, we
2727 // only need to look at the last range in the list for overlap.
2728 const auto &last_range = *m_erased_flash_ranges.Back();
2729 if (range.GetRangeBase() < last_range.GetRangeEnd()) {
2730 auto overlap = last_range.GetRangeEnd() - range.GetRangeBase();
2731 // overlap will be less than range.GetByteSize() or else HasErased()
2732 // would have been true
2733 range.SetByteSize(range.GetByteSize() - overlap);
2734 range.SetRangeBase(range.GetRangeBase() + overlap);
2735 }
2736 }
2737
2738 StreamString packet;
2739 packet.Printf("vFlashErase:%" PRIx64 ",%" PRIx64, range.GetRangeBase(),
2740 (uint64_t)range.GetByteSize());
2741
2742 StringExtractorGDBRemote response;
2743 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
2746 if (response.IsOKResponse()) {
2747 m_erased_flash_ranges.Insert(range, true);
2748 } else {
2749 if (response.IsErrorResponse())
2750 status.SetErrorStringWithFormat("flash erase failed for 0x%" PRIx64,
2751 addr);
2752 else if (response.IsUnsupportedResponse())
2753 status.SetErrorStringWithFormat("GDB server does not support flashing");
2754 else
2756 "unexpected response to GDB server flash erase packet '%s': '%s'",
2757 packet.GetData(), response.GetStringRef().data());
2758 }
2759 } else {
2760 status.SetErrorStringWithFormat("failed to send packet: '%s'",
2761 packet.GetData());
2762 }
2763 return status;
2764}
2765
2767 Status status;
2768 // If we haven't erased any blocks, then we must not have written anything
2769 // either, so there is no need to actually send a vFlashDone command
2771 return status;
2772 StringExtractorGDBRemote response;
2773 if (m_gdb_comm.SendPacketAndWaitForResponse("vFlashDone", response,
2776 if (response.IsOKResponse()) {
2778 } else {
2779 if (response.IsErrorResponse())
2780 status.SetErrorStringWithFormat("flash done failed");
2781 else if (response.IsUnsupportedResponse())
2782 status.SetErrorStringWithFormat("GDB server does not support flashing");
2783 else
2785 "unexpected response to GDB server flash done packet: '%s'",
2786 response.GetStringRef().data());
2787 }
2788 } else {
2789 status.SetErrorStringWithFormat("failed to send flash done packet");
2790 }
2791 return status;
2792}
2793
2794size_t ProcessGDBRemote::DoWriteMemory(addr_t addr, const void *buf,
2795 size_t size, Status &error) {
2797 // M and m packets take 2 bytes for 1 byte of memory
2798 size_t max_memory_size = m_max_memory_size / 2;
2799 if (size > max_memory_size) {
2800 // Keep memory read sizes down to a sane limit. This function will be
2801 // called multiple times in order to complete the task by
2802 // lldb_private::Process so it is ok to do this.
2803 size = max_memory_size;
2804 }
2805
2806 StreamGDBRemote packet;
2807
2808 MemoryRegionInfo region;
2809 Status region_status = GetMemoryRegionInfo(addr, region);
2810
2811 bool is_flash =
2812 region_status.Success() && region.GetFlash() == MemoryRegionInfo::eYes;
2813
2814 if (is_flash) {
2815 if (!m_allow_flash_writes) {
2816 error.SetErrorString("Writing to flash memory is not allowed");
2817 return 0;
2818 }
2819 // Keep the write within a flash memory region
2820 if (addr + size > region.GetRange().GetRangeEnd())
2821 size = region.GetRange().GetRangeEnd() - addr;
2822 // Flash memory must be erased before it can be written
2823 error = FlashErase(addr, size);
2824 if (!error.Success())
2825 return 0;
2826 packet.Printf("vFlashWrite:%" PRIx64 ":", addr);
2827 packet.PutEscapedBytes(buf, size);
2828 } else {
2829 packet.Printf("M%" PRIx64 ",%" PRIx64 ":", addr, (uint64_t)size);
2830 packet.PutBytesAsRawHex8(buf, size, endian::InlHostByteOrder(),
2832 }
2833 StringExtractorGDBRemote response;
2834 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
2837 if (response.IsOKResponse()) {
2838 error.Clear();
2839 return size;
2840 } else if (response.IsErrorResponse())
2841 error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64,
2842 addr);
2843 else if (response.IsUnsupportedResponse())
2844 error.SetErrorStringWithFormat(
2845 "GDB server does not support writing memory");
2846 else
2847 error.SetErrorStringWithFormat(
2848 "unexpected response to GDB server memory write packet '%s': '%s'",
2849 packet.GetData(), response.GetStringRef().data());
2850 } else {
2851 error.SetErrorStringWithFormat("failed to send packet: '%s'",
2852 packet.GetData());
2853 }
2854 return 0;
2855}
2856
2858 uint32_t permissions,
2859 Status &error) {
2861 addr_t allocated_addr = LLDB_INVALID_ADDRESS;
2862
2864 allocated_addr = m_gdb_comm.AllocateMemory(size, permissions);
2865 if (allocated_addr != LLDB_INVALID_ADDRESS ||
2867 return allocated_addr;
2868 }
2869
2871 // Call mmap() to create memory in the inferior..
2872 unsigned prot = 0;
2873 if (permissions & lldb::ePermissionsReadable)
2874 prot |= eMmapProtRead;
2875 if (permissions & lldb::ePermissionsWritable)
2876 prot |= eMmapProtWrite;
2877 if (permissions & lldb::ePermissionsExecutable)
2878 prot |= eMmapProtExec;
2879
2880 if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
2882 m_addr_to_mmap_size[allocated_addr] = size;
2883 else {
2884 allocated_addr = LLDB_INVALID_ADDRESS;
2885 LLDB_LOGF(log,
2886 "ProcessGDBRemote::%s no direct stub support for memory "
2887 "allocation, and InferiorCallMmap also failed - is stub "
2888 "missing register context save/restore capability?",
2889 __FUNCTION__);
2890 }
2891 }
2892
2893 if (allocated_addr == LLDB_INVALID_ADDRESS)
2894 error.SetErrorStringWithFormat(
2895 "unable to allocate %" PRIu64 " bytes of memory with permissions %s",
2896 (uint64_t)size, GetPermissionsAsCString(permissions));
2897 else
2898 error.Clear();
2899 return allocated_addr;
2900}
2901
2903 MemoryRegionInfo &region_info) {
2904
2905 Status error(m_gdb_comm.GetMemoryRegionInfo(load_addr, region_info));
2906 return error;
2907}
2908
2911}
2912
2915}
2916
2918 Status error;
2920
2921 switch (supported) {
2922 case eLazyBoolCalculate:
2923 // We should never be deallocating memory without allocating memory first
2924 // so we should never get eLazyBoolCalculate
2925 error.SetErrorString(
2926 "tried to deallocate memory without ever allocating memory");
2927 break;
2928
2929 case eLazyBoolYes:
2930 if (!m_gdb_comm.DeallocateMemory(addr))
2931 error.SetErrorStringWithFormat(
2932 "unable to deallocate memory at 0x%" PRIx64, addr);
2933 break;
2934
2935 case eLazyBoolNo:
2936 // Call munmap() to deallocate memory in the inferior..
2937 {
2938 MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
2939 if (pos != m_addr_to_mmap_size.end() &&
2940 InferiorCallMunmap(this, addr, pos->second))
2941 m_addr_to_mmap_size.erase(pos);
2942 else
2943 error.SetErrorStringWithFormat(
2944 "unable to deallocate memory at 0x%" PRIx64, addr);
2945 }
2946 break;
2947 }
2948
2949 return error;
2950}
2951
2952// Process STDIO
2953size_t ProcessGDBRemote::PutSTDIN(const char *src, size_t src_len,
2954 Status &error) {
2956 ConnectionStatus status;
2957 m_stdio_communication.WriteAll(src, src_len, status, nullptr);
2958 } else if (m_stdin_forward) {
2959 m_gdb_comm.SendStdinNotification(src, src_len);
2960 }
2961 return 0;
2962}
2963
2965 Status error;
2966 assert(bp_site != nullptr);
2967
2968 // Get logging info
2970 user_id_t site_id = bp_site->GetID();
2971
2972 // Get the breakpoint address
2973 const addr_t addr = bp_site->GetLoadAddress();
2974
2975 // Log that a breakpoint was requested
2976 LLDB_LOGF(log,
2977 "ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64
2978 ") address = 0x%" PRIx64,
2979 site_id, (uint64_t)addr);
2980
2981 // Breakpoint already exists and is enabled
2982 if (bp_site->IsEnabled()) {
2983 LLDB_LOGF(log,
2984 "ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64
2985 ") address = 0x%" PRIx64 " -- SUCCESS (already enabled)",
2986 site_id, (uint64_t)addr);
2987 return error;
2988 }
2989
2990 // Get the software breakpoint trap opcode size
2991 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
2992
2993 // SupportsGDBStoppointPacket() simply checks a boolean, indicating if this
2994 // breakpoint type is supported by the remote stub. These are set to true by
2995 // default, and later set to false only after we receive an unimplemented
2996 // response when sending a breakpoint packet. This means initially that
2997 // unless we were specifically instructed to use a hardware breakpoint, LLDB
2998 // will attempt to set a software breakpoint. HardwareRequired() also queries
2999 // a boolean variable which indicates if the user specifically asked for
3000 // hardware breakpoints. If true then we will skip over software
3001 // breakpoints.
3003 (!bp_site->HardwareRequired())) {
3004 // Try to send off a software breakpoint packet ($Z0)
3005 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3006 eBreakpointSoftware, true, addr, bp_op_size, GetInterruptTimeout());
3007 if (error_no == 0) {
3008 // The breakpoint was placed successfully
3009 bp_site->SetEnabled(true);
3011 return error;
3012 }
3013
3014 // SendGDBStoppointTypePacket() will return an error if it was unable to
3015 // set this breakpoint. We need to differentiate between a error specific
3016 // to placing this breakpoint or if we have learned that this breakpoint
3017 // type is unsupported. To do this, we must test the support boolean for
3018 // this breakpoint type to see if it now indicates that this breakpoint
3019 // type is unsupported. If they are still supported then we should return
3020 // with the error code. If they are now unsupported, then we would like to
3021 // fall through and try another form of breakpoint.
3023 if (error_no != UINT8_MAX)
3024 error.SetErrorStringWithFormat(
3025 "error: %d sending the breakpoint request", error_no);
3026 else
3027 error.SetErrorString("error sending the breakpoint request");
3028 return error;
3029 }
3030
3031 // We reach here when software breakpoints have been found to be
3032 // unsupported. For future calls to set a breakpoint, we will not attempt
3033 // to set a breakpoint with a type that is known not to be supported.
3034 LLDB_LOGF(log, "Software breakpoints are unsupported");
3035
3036 // So we will fall through and try a hardware breakpoint
3037 }
3038
3039 // The process of setting a hardware breakpoint is much the same as above.
3040 // We check the supported boolean for this breakpoint type, and if it is
3041 // thought to be supported then we will try to set this breakpoint with a
3042 // hardware breakpoint.
3044 // Try to send off a hardware breakpoint packet ($Z1)
3045 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3046 eBreakpointHardware, true, addr, bp_op_size, GetInterruptTimeout());
3047 if (error_no == 0) {
3048 // The breakpoint was placed successfully
3049 bp_site->SetEnabled(true);
3051 return error;
3052 }
3053
3054 // Check if the error was something other then an unsupported breakpoint
3055 // type
3057 // Unable to set this hardware breakpoint
3058 if (error_no != UINT8_MAX)
3059 error.SetErrorStringWithFormat(
3060 "error: %d sending the hardware breakpoint request "
3061 "(hardware breakpoint resources might be exhausted or unavailable)",
3062 error_no);
3063 else
3064 error.SetErrorString("error sending the hardware breakpoint request "
3065 "(hardware breakpoint resources "
3066 "might be exhausted or unavailable)");
3067 return error;
3068 }
3069
3070 // We will reach here when the stub gives an unsupported response to a
3071 // hardware breakpoint
3072 LLDB_LOGF(log, "Hardware breakpoints are unsupported");
3073
3074 // Finally we will falling through to a #trap style breakpoint
3075 }
3076
3077 // Don't fall through when hardware breakpoints were specifically requested
3078 if (bp_site->HardwareRequired()) {
3079 error.SetErrorString("hardware breakpoints are not supported");
3080 return error;
3081 }
3082
3083 // As a last resort we want to place a manual breakpoint. An instruction is
3084 // placed into the process memory using memory write packets.
3085 return EnableSoftwareBreakpoint(bp_site);
3086}
3087
3089 Status error;
3090 assert(bp_site != nullptr);
3091 addr_t addr = bp_site->GetLoadAddress();
3092 user_id_t site_id = bp_site->GetID();
3094 LLDB_LOGF(log,
3095 "ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64
3096 ") addr = 0x%8.8" PRIx64,
3097 site_id, (uint64_t)addr);
3098
3099 if (bp_site->IsEnabled()) {
3100 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
3101
3102 BreakpointSite::Type bp_type = bp_site->GetType();
3103 switch (bp_type) {
3106 break;
3107
3110 addr, bp_op_size,
3112 error.SetErrorToGenericError();
3113 break;
3114
3117 addr, bp_op_size,
3119 error.SetErrorToGenericError();
3120 } break;
3121 }
3122 if (error.Success())
3123 bp_site->SetEnabled(false);
3124 } else {
3125 LLDB_LOGF(log,
3126 "ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64
3127 ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
3128 site_id, (uint64_t)addr);
3129 return error;
3130 }
3131
3132 if (error.Success())
3133 error.SetErrorToGenericError();
3134 return error;
3135}
3136
3137// Pre-requisite: wp != NULL.
3138static GDBStoppointType
3140 assert(wp_res_sp);
3141 bool read = wp_res_sp->WatchpointResourceRead();
3142 bool write = wp_res_sp->WatchpointResourceWrite();
3143
3144 assert((read || write) &&
3145 "WatchpointResource type is neither read nor write");
3146 if (read && write)
3147 return eWatchpointReadWrite;
3148 else if (read)
3149 return eWatchpointRead;
3150 else
3151 return eWatchpointWrite;
3152}
3153
3155 Status error;
3156 if (!wp_sp) {
3157 error.SetErrorString("No watchpoint specified");
3158 return error;
3159 }
3160 user_id_t watchID = wp_sp->GetID();
3161 addr_t addr = wp_sp->GetLoadAddress();
3163 LLDB_LOGF(log, "ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64 ")",
3164 watchID);
3165 if (wp_sp->IsEnabled()) {
3166 LLDB_LOGF(log,
3167 "ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64
3168 ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
3169 watchID, (uint64_t)addr);
3170 return error;
3171 }
3172
3173 bool read = wp_sp->WatchpointRead();
3174 bool write = wp_sp->WatchpointWrite() || wp_sp->WatchpointModify();
3175 size_t size = wp_sp->GetByteSize();
3176
3177 ArchSpec target_arch = GetTarget().GetArchitecture();
3178 WatchpointHardwareFeature supported_features =
3180
3181 std::vector<WatchpointResourceSP> resources =
3183 addr, size, read, write, supported_features, target_arch);
3184
3185 // LWP_TODO: Now that we know the WP Resources needed to implement this
3186 // Watchpoint, we need to look at currently allocated Resources in the
3187 // Process and if they match, or are within the same memory granule, or
3188 // overlapping memory ranges, then we need to combine them. e.g. one
3189 // Watchpoint watching 1 byte at 0x1002 and a second watchpoint watching 1
3190 // byte at 0x1003, they must use the same hardware watchpoint register
3191 // (Resource) to watch them.
3192
3193 // This may mean that an existing resource changes its type (read to
3194 // read+write) or address range it is watching, in which case the old
3195 // watchpoint needs to be disabled and the new Resource addr/size/type
3196 // watchpoint enabled.
3197
3198 // If we modify a shared Resource to accomodate this newly added Watchpoint,
3199 // and we are unable to set all of the Resources for it in the inferior, we
3200 // will return an error for this Watchpoint and the shared Resource should
3201 // be restored. e.g. this Watchpoint requires three Resources, one which
3202 // is shared with another Watchpoint. We extend the shared Resouce to
3203 // handle both Watchpoints and we try to set two new ones. But if we don't
3204 // have sufficient watchpoint register for all 3, we need to show an error
3205 // for creating this Watchpoint and we should reset the shared Resource to
3206 // its original configuration because it is no longer shared.
3207
3208 bool set_all_resources = true;
3209 std::vector<WatchpointResourceSP> succesfully_set_resources;
3210 for (const auto &wp_res_sp : resources) {
3211 addr_t addr = wp_res_sp->GetLoadAddress();
3212 size_t size = wp_res_sp->GetByteSize();
3213 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
3215 m_gdb_comm.SendGDBStoppointTypePacket(type, true, addr, size,
3217 set_all_resources = false;
3218 break;
3219 } else {
3220 succesfully_set_resources.push_back(wp_res_sp);
3221 }
3222 }
3223 if (set_all_resources) {
3224 wp_sp->SetEnabled(true, notify);
3225 for (const auto &wp_res_sp : resources) {
3226 // LWP_TODO: If we expanded/reused an existing Resource,
3227 // it's already in the WatchpointResourceList.
3228 wp_res_sp->AddConstituent(wp_sp);
3230 }
3231 return error;
3232 } else {
3233 // We failed to allocate one of the resources. Unset all
3234 // of the new resources we did successfully set in the
3235 // process.
3236 for (const auto &wp_res_sp : succesfully_set_resources) {
3237 addr_t addr = wp_res_sp->GetLoadAddress();
3238 size_t size = wp_res_sp->GetByteSize();
3239 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
3240 m_gdb_comm.SendGDBStoppointTypePacket(type, false, addr, size,
3242 }
3243 error.SetErrorString("Setting one of the watchpoint resources failed");
3244 }
3245 return error;
3246}
3247
3249 Status error;
3250 if (!wp_sp) {
3251 error.SetErrorString("Watchpoint argument was NULL.");
3252 return error;
3253 }
3254
3255 user_id_t watchID = wp_sp->GetID();
3256
3258
3259 addr_t addr = wp_sp->GetLoadAddress();
3260
3261 LLDB_LOGF(log,
3262 "ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
3263 ") addr = 0x%8.8" PRIx64,
3264 watchID, (uint64_t)addr);
3265
3266 if (!wp_sp->IsEnabled()) {
3267 LLDB_LOGF(log,
3268 "ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
3269 ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
3270 watchID, (uint64_t)addr);
3271 // See also 'class WatchpointSentry' within StopInfo.cpp. This disabling
3272 // attempt might come from the user-supplied actions, we'll route it in
3273 // order for the watchpoint object to intelligently process this action.
3274 wp_sp->SetEnabled(false, notify);
3275 return error;
3276 }
3277
3278 if (wp_sp->IsHardware()) {
3279 bool disabled_all = true;
3280
3281 std::vector<WatchpointResourceSP> unused_resources;
3282 for (const auto &wp_res_sp : m_watchpoint_resource_list.Sites()) {
3283 if (wp_res_sp->ConstituentsContains(wp_sp)) {
3284 GDBStoppointType type = GetGDBStoppointType(wp_res_sp);
3285 addr_t addr = wp_res_sp->GetLoadAddress();
3286 size_t size = wp_res_sp->GetByteSize();
3287 if (m_gdb_comm.SendGDBStoppointTypePacket(type, false, addr, size,
3289 disabled_all = false;
3290 } else {
3291 wp_res_sp->RemoveConstituent(wp_sp);
3292 if (wp_res_sp->GetNumberOfConstituents() == 0)
3293 unused_resources.push_back(wp_res_sp);
3294 }
3295 }
3296 }
3297 for (auto &wp_res_sp : unused_resources)
3298 m_watchpoint_resource_list.Remove(wp_res_sp->GetID());
3299
3300 wp_sp->SetEnabled(false, notify);
3301 if (!disabled_all)
3302 error.SetErrorString("Failure disabling one of the watchpoint locations");
3303 }
3304 return error;
3305}
3306
3310}
3311
3313 Status error;
3314 Log *log = GetLog(GDBRLog::Process);
3315 LLDB_LOGF(log, "ProcessGDBRemote::DoSignal (signal = %d)", signo);
3316
3318 error.SetErrorStringWithFormat("failed to send signal %i", signo);
3319 return error;
3320}
3321
3322Status
3324 // Make sure we aren't already connected?
3325 if (m_gdb_comm.IsConnected())
3326 return Status();
3327
3328 PlatformSP platform_sp(GetTarget().GetPlatform());
3329 if (platform_sp && !platform_sp->IsHost())
3330 return Status("Lost debug server connection");
3331
3332 auto error = LaunchAndConnectToDebugserver(process_info);
3333 if (error.Fail()) {
3334 const char *error_string = error.AsCString();
3335 if (error_string == nullptr)
3336 error_string = "unable to launch " DEBUGSERVER_BASENAME;
3337 }
3338 return error;
3339}
3340#if !defined(_WIN32)
3341#define USE_SOCKETPAIR_FOR_LOCAL_CONNECTION 1
3342#endif
3343
3344#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3345static bool SetCloexecFlag(int fd) {
3346#if defined(FD_CLOEXEC)
3347 int flags = ::fcntl(fd, F_GETFD);
3348 if (flags == -1)
3349 return false;
3350 return (::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == 0);
3351#else
3352 return false;
3353#endif
3354}
3355#endif
3356
3358 const ProcessInfo &process_info) {
3359 using namespace std::placeholders; // For _1, _2, etc.
3360
3361 Status error;
3363 // If we locate debugserver, keep that located version around
3364 static FileSpec g_debugserver_file_spec;
3365
3366 ProcessLaunchInfo debugserver_launch_info;
3367 // Make debugserver run in its own session so signals generated by special
3368 // terminal key sequences (^C) don't affect debugserver.
3369 debugserver_launch_info.SetLaunchInSeparateProcessGroup(true);
3370
3371 const std::weak_ptr<ProcessGDBRemote> this_wp =
3372 std::static_pointer_cast<ProcessGDBRemote>(shared_from_this());
3373 debugserver_launch_info.SetMonitorProcessCallback(
3374 std::bind(MonitorDebugserverProcess, this_wp, _1, _2, _3));
3375 debugserver_launch_info.SetUserID(process_info.GetUserID());
3376
3377#if defined(__APPLE__)
3378 // On macOS 11, we need to support x86_64 applications translated to
3379 // arm64. We check whether a binary is translated and spawn the correct
3380 // debugserver accordingly.
3381 int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
3382 static_cast<int>(process_info.GetProcessID()) };
3383 struct kinfo_proc processInfo;
3384 size_t bufsize = sizeof(processInfo);
3385 if (sysctl(mib, (unsigned)(sizeof(mib)/sizeof(int)), &processInfo,
3386 &bufsize, NULL, 0) == 0 && bufsize > 0) {
3387 if (processInfo.kp_proc.p_flag & P_TRANSLATED) {
3388 FileSpec rosetta_debugserver("/Library/Apple/usr/libexec/oah/debugserver");
3389 debugserver_launch_info.SetExecutableFile(rosetta_debugserver, false);
3390 }
3391 }
3392#endif
3393
3394 int communication_fd = -1;
3395#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3396 // Use a socketpair on non-Windows systems for security and performance
3397 // reasons.
3398 int sockets[2]; /* the pair of socket descriptors */
3399 if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == -1) {
3400 error.SetErrorToErrno();
3401 return error;
3402 }
3403
3404 int our_socket = sockets[0];
3405 int gdb_socket = sockets[1];
3406 auto cleanup_our = llvm::make_scope_exit([&]() { close(our_socket); });
3407 auto cleanup_gdb = llvm::make_scope_exit([&]() { close(gdb_socket); });
3408
3409 // Don't let any child processes inherit our communication socket
3410 SetCloexecFlag(our_socket);
3411 communication_fd = gdb_socket;
3412#endif
3413
3415 nullptr, GetTarget().GetPlatform().get(), debugserver_launch_info,
3416 nullptr, nullptr, communication_fd);
3417
3418 if (error.Success())
3419 m_debugserver_pid = debugserver_launch_info.GetProcessID();
3420 else
3422
3424#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3425 // Our process spawned correctly, we can now set our connection to use
3426 // our end of the socket pair
3427 cleanup_our.release();
3429 std::make_unique<ConnectionFileDescriptor>(our_socket, true));
3430#endif
3432 }
3433
3434 if (error.Fail()) {
3435 Log *log = GetLog(GDBRLog::Process);
3436
3437 LLDB_LOGF(log, "failed to start debugserver process: %s",
3438 error.AsCString());
3439 return error;
3440 }
3441
3442 if (m_gdb_comm.IsConnected()) {
3443 // Finish the connection process by doing the handshake without
3444 // connecting (send NULL URL)
3446 } else {
3447 error.SetErrorString("connection failed");
3448 }
3449 }
3450 return error;
3451}
3452
3454 std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid,
3455 int signo, // Zero for no signal
3456 int exit_status // Exit value of process if signal is zero
3457) {
3458 // "debugserver_pid" argument passed in is the process ID for debugserver
3459 // that we are tracking...
3460 Log *log = GetLog(GDBRLog::Process);
3461
3462 LLDB_LOGF(log,
3463 "ProcessGDBRemote::%s(process_wp, pid=%" PRIu64
3464 ", signo=%i (0x%x), exit_status=%i)",
3465 __FUNCTION__, debugserver_pid, signo, signo, exit_status);
3466
3467 std::shared_ptr<ProcessGDBRemote> process_sp = process_wp.lock();
3468 LLDB_LOGF(log, "ProcessGDBRemote::%s(process = %p)", __FUNCTION__,
3469 static_cast<void *>(process_sp.get()));
3470 if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
3471 return;
3472
3473 // Sleep for a half a second to make sure our inferior process has time to
3474 // set its exit status before we set it incorrectly when both the debugserver
3475 // and the inferior process shut down.
3476 std::this_thread::sleep_for(std::chrono::milliseconds(500));
3477
3478 // If our process hasn't yet exited, debugserver might have died. If the
3479 // process did exit, then we are reaping it.
3480 const StateType state = process_sp->GetState();
3481
3482 if (state != eStateInvalid && state != eStateUnloaded &&
3483 state != eStateExited && state != eStateDetached) {
3484 StreamString stream;
3485 if (signo == 0)
3486 stream.Format(DEBUGSERVER_BASENAME " died with an exit status of {0:x8}",
3487 exit_status);
3488 else {
3489 llvm::StringRef signal_name =
3490 process_sp->GetUnixSignals()->GetSignalAsStringRef(signo);
3491 const char *format_str = DEBUGSERVER_BASENAME " died with signal {0}";
3492 if (!signal_name.empty())
3493 stream.Format(format_str, signal_name);
3494 else
3495 stream.Format(format_str, signo);
3496 }
3497 process_sp->SetExitStatus(-1, stream.GetString());
3498 }
3499 // Debugserver has exited we need to let our ProcessGDBRemote know that it no
3500 // longer has a debugserver instance
3501 process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
3502}
3503
3509 }
3510}
3511
3513 static llvm::once_flag g_once_flag;
3514
3515 llvm::call_once(g_once_flag, []() {
3519 });
3520}
3521
3524 debugger, PluginProperties::GetSettingName())) {
3525 const bool is_global_setting = true;
3528 "Properties for the gdb-remote process plug-in.", is_global_setting);
3529 }
3530}
3531
3533 Log *log = GetLog(GDBRLog::Process);
3534
3535 LLDB_LOGF(log, "ProcessGDBRemote::%s ()", __FUNCTION__);
3536
3537 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3538 if (!m_async_thread.IsJoinable()) {
3539 // Create a thread that watches our internal state and controls which
3540 // events make it to clients (into the DCProcess event queue).
3541
3542 llvm::Expected<HostThread> async_thread =
3543 ThreadLauncher::LaunchThread("<lldb.process.gdb-remote.async>", [this] {
3545 });
3546 if (!async_thread) {
3547 LLDB_LOG_ERROR(GetLog(LLDBLog::Host), async_thread.takeError(),
3548 "failed to launch host thread: {0}");
3549 return false;
3550 }
3551 m_async_thread = *async_thread;
3552 } else
3553 LLDB_LOGF(log,
3554 "ProcessGDBRemote::%s () - Called when Async thread was "
3555 "already running.",
3556 __FUNCTION__);
3557
3558 return m_async_thread.IsJoinable();
3559}
3560
3562 Log *log = GetLog(GDBRLog::Process);
3563
3564 LLDB_LOGF(log, "ProcessGDBRemote::%s ()", __FUNCTION__);
3565
3566 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3567 if (m_async_thread.IsJoinable()) {
3569
3570 // This will shut down the async thread.
3571 m_gdb_comm.Disconnect(); // Disconnect from the debug server.
3572
3573 // Stop the stdio thread
3574 m_async_thread.Join(nullptr);
3576 } else
3577 LLDB_LOGF(
3578 log,
3579 "ProcessGDBRemote::%s () - Called when Async thread was not running.",
3580 __FUNCTION__);
3581}
3582
3584 Log *log = GetLog(GDBRLog::Process);
3585 LLDB_LOGF(log, "ProcessGDBRemote::%s(pid = %" PRIu64 ") thread starting...",
3586 __FUNCTION__, GetID());
3587
3588 EventSP event_sp;
3589
3590 // We need to ignore any packets that come in after we have
3591 // have decided the process has exited. There are some
3592 // situations, for instance when we try to interrupt a running
3593 // process and the interrupt fails, where another packet might
3594 // get delivered after we've decided to give up on the process.
3595 // But once we've decided we are done with the process we will
3596 // not be in a state to do anything useful with new packets.
3597 // So it is safer to simply ignore any remaining packets by
3598 // explicitly checking for eStateExited before reentering the
3599 // fetch loop.
3600
3601 bool done = false;
3602 while (!done && GetPrivateState() != eStateExited) {
3603 LLDB_LOGF(log,
3604 "ProcessGDBRemote::%s(pid = %" PRIu64
3605 ") listener.WaitForEvent (NULL, event_sp)...",
3606 __FUNCTION__, GetID());
3607
3608 if (m_async_listener_sp->GetEvent(event_sp, std::nullopt)) {
3609 const uint32_t event_type = event_sp->GetType();
3610 if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
3611 LLDB_LOGF(log,
3612 "ProcessGDBRemote::%s(pid = %" PRIu64
3613 ") Got an event of type: %d...",
3614 __FUNCTION__, GetID(), event_type);
3615
3616 switch (event_type) {
3618 const EventDataBytes *continue_packet =
3620
3621 if (continue_packet) {
3622 const char *continue_cstr =
3623 (const char *)continue_packet->GetBytes();
3624 const size_t continue_cstr_len = continue_packet->GetByteSize();
3625 LLDB_LOGF(log,
3626 "ProcessGDBRemote::%s(pid = %" PRIu64
3627 ") got eBroadcastBitAsyncContinue: %s",
3628 __FUNCTION__, GetID(), continue_cstr);
3629
3630 if (::strstr(continue_cstr, "vAttach") == nullptr)
3632 StringExtractorGDBRemote response;
3633
3634 StateType stop_state =
3636 *this, *GetUnixSignals(),
3637 llvm::StringRef(continue_cstr, continue_cstr_len),
3638 GetInterruptTimeout(), response);
3639
3640 // We need to immediately clear the thread ID list so we are sure
3641 // to get a valid list of threads. The thread ID list might be
3642 // contained within the "response", or the stop reply packet that
3643 // caused the stop. So clear it now before we give the stop reply
3644 // packet to the process using the
3645 // SetLastStopPacket()...
3647
3648 switch (stop_state) {
3649 case eStateStopped:
3650 case eStateCrashed:
3651 case eStateSuspended:
3652 SetLastStopPacket(response);
3653 SetPrivateState(stop_state);
3654 break;
3655
3656 case eStateExited: {
3657 SetLastStopPacket(response);
3659 response.SetFilePos(1);
3660
3661 int exit_status = response.GetHexU8();
3662 std::string desc_string;
3663 if (response.GetBytesLeft() > 0 && response.GetChar('-') == ';') {
3664 llvm::StringRef desc_str;
3665 llvm::StringRef desc_token;
3666 while (response.GetNameColonValue(desc_token, desc_str)) {
3667 if (desc_token != "description")
3668 continue;
3669 StringExtractor extractor(desc_str);
3670 extractor.GetHexByteString(desc_string);
3671 }
3672 }
3673 SetExitStatus(exit_status, desc_string.c_str());
3674 done = true;
3675 break;
3676 }
3677 case eStateInvalid: {
3678 // Check to see if we were trying to attach and if we got back
3679 // the "E87" error code from debugserver -- this indicates that
3680 // the process is not debuggable. Return a slightly more
3681 // helpful error message about why the attach failed.
3682 if (::strstr(continue_cstr, "vAttach") != nullptr &&
3683 response.GetError() == 0x87) {
3684 SetExitStatus(-1, "cannot attach to process due to "
3685 "System Integrity Protection");
3686 } else if (::strstr(continue_cstr, "vAttach") != nullptr &&
3687 response.GetStatus().Fail()) {
3688 SetExitStatus(-1, response.GetStatus().AsCString());
3689 } else {
3690 SetExitStatus(-1, "lost connection");
3691 }
3692 done = true;
3693 break;
3694 }
3695
3696 default:
3697 SetPrivateState(stop_state);
3698 break;
3699 } // switch(stop_state)
3700 } // if (continue_packet)
3701 } // case eBroadcastBitAsyncContinue
3702 break;
3703
3705 LLDB_LOGF(log,
3706 "ProcessGDBRemote::%s(pid = %" PRIu64
3707 ") got eBroadcastBitAsyncThreadShouldExit...",
3708 __FUNCTION__, GetID());
3709 done = true;
3710 break;
3711
3712 default:
3713 LLDB_LOGF(log,
3714 "ProcessGDBRemote::%s(pid = %" PRIu64
3715 ") got unknown event 0x%8.8x",
3716 __FUNCTION__, GetID(), event_type);
3717 done = true;
3718 break;
3719 }
3720 }
3721 } else {
3722 LLDB_LOGF(log,
3723 "ProcessGDBRemote::%s(pid = %" PRIu64
3724 ") listener.WaitForEvent (NULL, event_sp) => false",
3725 __FUNCTION__, GetID());
3726 done = true;
3727 }
3728 }
3729
3730 LLDB_LOGF(log, "ProcessGDBRemote::%s(pid = %" PRIu64 ") thread exiting...",
3731 __FUNCTION__, GetID());
3732
3733 return {};
3734}
3735
3736// uint32_t
3737// ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList
3738// &matches, std::vector<lldb::pid_t> &pids)
3739//{
3740// // If we are planning to launch the debugserver remotely, then we need to
3741// fire up a debugserver
3742// // process and ask it for the list of processes. But if we are local, we
3743// can let the Host do it.
3744// if (m_local_debugserver)
3745// {
3746// return Host::ListProcessesMatchingName (name, matches, pids);
3747// }
3748// else
3749// {
3750// // FIXME: Implement talking to the remote debugserver.
3751// return 0;
3752// }
3753//
3754//}
3755//
3757 void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
3758 lldb::user_id_t break_loc_id) {
3759 // I don't think I have to do anything here, just make sure I notice the new
3760 // thread when it starts to
3761 // run so I can stop it if that's what I want to do.
3762 Log *log = GetLog(LLDBLog::Step);
3763 LLDB_LOGF(log, "Hit New Thread Notification breakpoint.");
3764 return false;
3765}
3766
3768 Log *log = GetLog(GDBRLog::Process);
3769 LLDB_LOG(log, "Check if need to update ignored signals");
3770
3771 // QPassSignals package is not supported by the server, there is no way we
3772 // can ignore any signals on server side.
3774 return Status();
3775
3776 // No signals, nothing to send.
3777 if (m_unix_signals_sp == nullptr)
3778 return Status();
3779
3780 // Signals' version hasn't changed, no need to send anything.
3781 uint64_t new_signals_version = m_unix_signals_sp->GetVersion();
3782 if (new_signals_version == m_last_signals_version) {
3783 LLDB_LOG(log, "Signals' version hasn't changed. version={0}",
3785 return Status();
3786 }
3787
3788 auto signals_to_ignore =
3789 m_unix_signals_sp->GetFilteredSignals(false, false, false);
3790 Status error = m_gdb_comm.SendSignalsToIgnore(signals_to_ignore);
3791
3792 LLDB_LOG(log,
3793 "Signals' version changed. old version={0}, new version={1}, "
3794 "signals ignored={2}, update result={3}",
3795 m_last_signals_version, new_signals_version,
3796 signals_to_ignore.size(), error);
3797
3798 if (error.Success())
3799 m_last_signals_version = new_signals_version;
3800
3801 return error;
3802}
3803
3805 Log *log = GetLog(LLDBLog::Step);
3807 if (log && log->GetVerbose())
3808 LLDB_LOGF(log, "Enabled noticing new thread breakpoint.");
3809 m_thread_create_bp_sp->SetEnabled(true);
3810 } else {
3811 PlatformSP platform_sp(GetTarget().GetPlatform());
3812 if (platform_sp) {
3814 platform_sp->SetThreadCreationBreakpoint(GetTarget());
3816 if (log && log->GetVerbose())
3817 LLDB_LOGF(
3818 log, "Successfully created new thread notification breakpoint %i",
3819 m_thread_create_bp_sp->GetID());
3820 m_thread_create_bp_sp->SetCallback(
3822 } else {
3823 LLDB_LOGF(log, "Failed to create new thread notification breakpoint.");
3824 }
3825 }
3826 }
3827 return m_thread_create_bp_sp.get() != nullptr;
3828}
3829
3831 Log *log = GetLog(LLDBLog::Step);
3832 if (log && log->GetVerbose())
3833 LLDB_LOGF(log, "Disabling new thread notification breakpoint.");
3834
3836 m_thread_create_bp_sp->SetEnabled(false);
3837
3838 return true;
3839}
3840
3842 if (m_dyld_up.get() == nullptr)
3843 m_dyld_up.reset(DynamicLoader::FindPlugin(this, ""));
3844 return m_dyld_up.get();
3845}
3846
3848 int return_value;
3849 bool was_supported;
3850
3851 Status error;
3852
3853 return_value = m_gdb_comm.SendLaunchEventDataPacket(data, &was_supported);
3854 if (return_value != 0) {
3855 if (!was_supported)
3856 error.SetErrorString("Sending events is not supported for this process.");
3857 else
3858 error.SetErrorStringWithFormat("Error sending event data: %d.",
3859 return_value);
3860 }
3861 return error;
3862}
3863
3865 DataBufferSP buf;
3867 llvm::Expected<std::string> response = m_gdb_comm.ReadExtFeature("auxv", "");
3868 if (response)
3869 buf = std::make_shared<DataBufferHeap>(response->c_str(),
3870 response->length());
3871 else
3872 LLDB_LOG_ERROR(GetLog(GDBRLog::Process), response.takeError(), "{0}");
3873 }
3875}
3876
3879 StructuredData::ObjectSP object_sp;
3880
3883 SystemRuntime *runtime = GetSystemRuntime();
3884 if (runtime) {
3885 runtime->AddThreadExtendedInfoPacketHints(args_dict);
3886 }
3887 args_dict->GetAsDictionary()->AddIntegerItem("thread", tid);
3888
3889 StreamString packet;
3890 packet << "jThreadExtendedInfo:";
3891 args_dict->Dump(packet, false);
3892
3893 // FIXME the final character of a JSON dictionary, '}', is the escape
3894 // character in gdb-remote binary mode. lldb currently doesn't escape
3895 // these characters in its packet output -- so we add the quoted version of
3896 // the } character here manually in case we talk to a debugserver which un-
3897 // escapes the characters at packet read time.
3898 packet << (char)(0x7d ^ 0x20);
3899
3900 StringExtractorGDBRemote response;
3901 response.SetResponseValidatorToJSON();
3902 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
3905 response.GetResponseType();
3906 if (response_type == StringExtractorGDBRemote::eResponse) {
3907 if (!response.Empty()) {
3908 object_sp = StructuredData::ParseJSON(response.GetStringRef());
3909 }
3910 }
3911 }
3912 }
3913 return object_sp;
3914}
3915
3917 lldb::addr_t image_list_address, lldb::addr_t image_count) {
3918
3920 args_dict->GetAsDictionary()->AddIntegerItem("image_list_address",
3921 image_list_address);
3922 args_dict->GetAsDictionary()->AddIntegerItem("image_count", image_count);
3923
3924 return GetLoadedDynamicLibrariesInfos_sender(args_dict);
3925}
3926
3929
3930 args_dict->GetAsDictionary()->AddBooleanItem("fetch_all_solibs", true);
3931
3932 return GetLoadedDynamicLibrariesInfos_sender(args_dict);
3933}
3934
3936 const std::vector<lldb::addr_t> &load_addresses) {
3939
3940 for (auto addr : load_addresses)
3941 addresses->AddIntegerItem(addr);
3942
3943 args_dict->GetAsDictionary()->AddItem("solib_addresses", addresses);
3944
3945 return GetLoadedDynamicLibrariesInfos_sender(args_dict);
3946}
3947
3950 StructuredData::ObjectSP args_dict) {
3951 StructuredData::ObjectSP object_sp;
3952
3954 // Scope for the scoped timeout object
3956 std::chrono::seconds(10));
3957
3958 StreamString packet;
3959 packet << "jGetLoadedDynamicLibrariesInfos:";
3960 args_dict->Dump(packet, false);
3961
3962 // FIXME the final character of a JSON dictionary, '}', is the escape
3963 // character in gdb-remote binary mode. lldb currently doesn't escape
3964 // these characters in its packet output -- so we add the quoted version of
3965 // the } character here manually in case we talk to a debugserver which un-
3966 // escapes the characters at packet read time.
3967 packet << (char)(0x7d ^ 0x20);
3968
3969 StringExtractorGDBRemote response;
3970 response.SetResponseValidatorToJSON();
3971 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
3974 response.GetResponseType();
3975 if (response_type == StringExtractorGDBRemote::eResponse) {
3976 if (!response.Empty()) {
3977 object_sp = StructuredData::ParseJSON(response.GetStringRef());
3978 }
3979 }
3980 }
3981 }
3982 return object_sp;
3983}
3984
3986 StructuredData::ObjectSP object_sp;
3988
3990 StringExtractorGDBRemote response;
3991 response.SetResponseValidatorToJSON();
3992 if (m_gdb_comm.SendPacketAndWaitForResponse("jGetDyldProcessState",
3993 response) ==
3996 response.GetResponseType();
3997 if (response_type == StringExtractorGDBRemote::eResponse) {
3998 if (!response.Empty()) {
3999 object_sp = StructuredData::ParseJSON(response.GetStringRef());
4000 }
4001 }
4002 }
4003 }
4004 return object_sp;
4005}
4006
4008 StructuredData::ObjectSP object_sp;
4010
4012 StreamString packet;
4013 packet << "jGetSharedCacheInfo:";
4014 args_dict->Dump(packet, false);
4015
4016 // FIXME the final character of a JSON dictionary, '}', is the escape
4017 // character in gdb-remote binary mode. lldb currently doesn't escape
4018 // these characters in its packet output -- so we add the quoted version of
4019 // the } character here manually in case we talk to a debugserver which un-
4020 // escapes the characters at packet read time.
4021 packet << (char)(0x7d ^ 0x20);
4022
4023 StringExtractorGDBRemote response;
4024 response.SetResponseValidatorToJSON();
4025 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
4028 response.GetResponseType();
4029 if (response_type == StringExtractorGDBRemote::eResponse) {
4030 if (!response.Empty()) {
4031 object_sp = StructuredData::ParseJSON(response.GetStringRef());
4032 }
4033 }
4034 }
4035 }
4036 return object_sp;
4037}
4038
4040 llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp) {
4041 return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
4042}
4043
4044// Establish the largest memory read/write payloads we should use. If the
4045// remote stub has a max packet size, stay under that size.
4046//
4047// If the remote stub's max packet size is crazy large, use a reasonable
4048// largeish default.
4049//
4050// If the remote stub doesn't advertise a max packet size, use a conservative
4051// default.
4052
4054 const uint64_t reasonable_largeish_default = 128 * 1024;
4055 const uint64_t conservative_default = 512;
4056
4057 if (m_max_memory_size == 0) {
4058 uint64_t stub_max_size = m_gdb_comm.GetRemoteMaxPacketSize();
4059 if (stub_max_size != UINT64_MAX && stub_max_size != 0) {
4060 // Save the stub's claimed maximum packet size
4061 m_remote_stub_max_memory_size = stub_max_size;
4062
4063 // Even if the stub says it can support ginormous packets, don't exceed
4064 // our reasonable largeish default packet size.
4065 if (stub_max_size > reasonable_largeish_default) {
4066 stub_max_size = reasonable_largeish_default;
4067 }
4068
4069 // Memory packet have other overheads too like Maddr,size:#NN Instead of
4070 // calculating the bytes taken by size and addr every time, we take a
4071 // maximum guess here.
4072 if (stub_max_size > 70)
4073 stub_max_size -= 32 + 32 + 6;
4074 else {
4075 // In unlikely scenario that max packet size is less then 70, we will
4076 // hope that data being written is small enough to fit.
4078 if (log)
4079 log->Warning("Packet size is too small. "
4080 "LLDB may face problems while writing memory");
4081 }
4082
4083 m_max_memory_size = stub_max_size;
4084 } else {
4085 m_max_memory_size = conservative_default;
4086 }
4087 }
4088}
4089
4091 uint64_t user_specified_max) {
4092 if (user_specified_max != 0) {
4094
4096 if (m_remote_stub_max_memory_size < user_specified_max) {
4098 // packet size too
4099 // big, go as big
4100 // as the remote stub says we can go.
4101 } else {
4102 m_max_memory_size = user_specified_max; // user's packet size is good
4103 }
4104 } else {
4106 user_specified_max; // user's packet size is probably fine
4107 }
4108 }
4109}
4110
4111bool ProcessGDBRemote::GetModuleSpec(const FileSpec &module_file_spec,
4112 const ArchSpec &arch,
4113 ModuleSpec &module_spec) {
4115
4116 const ModuleCacheKey key(module_file_spec.GetPath(),
4117 arch.GetTriple().getTriple());
4118 auto cached = m_cached_module_specs.find(key);
4119 if (cached != m_cached_module_specs.end()) {
4120 module_spec = cached->second;
4121 return bool(module_spec);
4122 }
4123
4124 if (!m_gdb_comm.GetModuleInfo(module_file_spec, arch, module_spec)) {
4125 LLDB_LOGF(log, "ProcessGDBRemote::%s - failed to get module info for %s:%s",
4126 __FUNCTION__, module_file_spec.GetPath().c_str(),
4127 arch.GetTriple().getTriple().c_str());
4128 return false;
4129 }
4130
4131 if (log) {
4132 StreamString stream;
4133 module_spec.Dump(stream);
4134 LLDB_LOGF(log, "ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
4135 __FUNCTION__, module_file_spec.GetPath().c_str(),
4136 arch.GetTriple().getTriple().c_str(), stream.GetData());
4137 }
4138
4139 m_cached_module_specs[key] = module_spec;
4140 return true;
4141}
4142
4144 llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
4145 auto module_specs = m_gdb_comm.GetModulesInfo(module_file_specs, triple);
4146 if (module_specs) {
4147 for (const FileSpec &spec : module_file_specs)
4149 triple.getTriple())] = ModuleSpec();
4150 for (const ModuleSpec &spec : *module_specs)
4151 m_cached_module_specs[ModuleCacheKey(spec.GetFileSpec().GetPath(),
4152 triple.getTriple())] = spec;
4153 }
4154}
4155
4157 return m_gdb_comm.GetOSVersion();
4158}
4159
4162}
4163
4164namespace {
4165
4166typedef std::vector<std::string> stringVec;
4167
4168typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
4169struct RegisterSetInfo {
4170 ConstString name;
4171};
4172
4173typedef std::map<uint32_t, RegisterSetInfo> RegisterSetMap;
4174
4175struct GdbServerTargetInfo {
4176 std::string arch;
4177 std::string osabi;
4178 stringVec includes;
4179 RegisterSetMap reg_set_map;
4180};
4181
4182static std::vector<RegisterFlags::Field> ParseFlagsFields(XMLNode flags_node,
4183 unsigned size) {
4184 Log *log(GetLog(GDBRLog::Process));
4185 const unsigned max_start_bit = size * 8 - 1;
4186
4187 // Process the fields of this set of flags.
4188 std::vector<RegisterFlags::Field> fields;
4189 flags_node.ForEachChildElementWithName("field", [&fields, max_start_bit,
4190 &log](const XMLNode
4191 &field_node) {
4192 std::optional<llvm::StringRef> name;
4193 std::optional<unsigned> start;
4194 std::optional<unsigned> end;
4195
4196 field_node.ForEachAttribute([&name, &start, &end, max_start_bit,
4197 &log](const llvm::StringRef &attr_name,
4198 const llvm::StringRef &attr_value) {
4199 // Note that XML in general requires that each of these attributes only
4200 // appears once, so we don't have to handle that here.
4201 if (attr_name == "name") {
4202 LLDB_LOG(
4203 log,
4204 "ProcessGDBRemote::ParseFlagsFields Found field node name \"{0}\"",
4205 attr_value.data());
4206 name = attr_value;
4207 } else if (attr_name == "start") {
4208 unsigned parsed_start = 0;
4209 if (llvm::to_integer(attr_value, parsed_start)) {
4210 if (parsed_start > max_start_bit) {
4211 LLDB_LOG(log,
4212 "ProcessGDBRemote::ParseFlagsFields Invalid start {0} in "
4213 "field node, "
4214 "cannot be > {1}",
4215 parsed_start, max_start_bit);
4216 } else
4217 start = parsed_start;
4218 } else {
4219 LLDB_LOG(
4220 log,
4221 "ProcessGDBRemote::ParseFlagsFields Invalid start \"{0}\" in "
4222 "field node",
4223 attr_value.data());
4224 }
4225 } else if (attr_name == "end") {
4226 unsigned parsed_end = 0;
4227 if (llvm::to_integer(attr_value, parsed_end))
4228 if (parsed_end > max_start_bit) {
4229 LLDB_LOG(log,
4230 "ProcessGDBRemote::ParseFlagsFields Invalid end {0} in "
4231 "field node, "
4232 "cannot be > {1}",
4233 parsed_end, max_start_bit);
4234 } else
4235 end = parsed_end;
4236 else {
4237 LLDB_LOG(log,
4238 "ProcessGDBRemote::ParseFlagsFields Invalid end \"{0}\" in "
4239 "field node",
4240 attr_value.data());
4241 }
4242 } else if (attr_name == "type") {
4243 // Type is a known attribute but we do not currently use it and it is
4244 // not required.
4245 } else {
4246 LLDB_LOG(
4247 log,
4248 "ProcessGDBRemote::ParseFlagsFields Ignoring unknown attribute "
4249 "\"{0}\" in field node",
4250 attr_name.data());
4251 }
4252
4253 return true; // Walk all attributes of the field.
4254 });
4255
4256 if (name && start && end) {
4257 if (*start > *end) {
4258 LLDB_LOG(
4259 log,
4260 "ProcessGDBRemote::ParseFlagsFields Start {0} > end {1} in field "
4261 "\"{2}\", ignoring",
4262 *start, *end, name->data());
4263 } else {
4264 fields.push_back(RegisterFlags::Field(name->str(), *start, *end));
4265 }
4266 }
4267
4268 return true; // Iterate all "field" nodes.
4269 });
4270 return fields;
4271}
4272
4273void ParseFlags(
4274 XMLNode feature_node,
4275 llvm::StringMap<std::unique_ptr<RegisterFlags>> &registers_flags_types) {
4276 Log *log(GetLog(GDBRLog::Process));
4277
4278 feature_node.ForEachChildElementWithName(
4279 "flags",
4280 [&log, &registers_flags_types](const XMLNode &flags_node) -> bool {
4281 LLDB_LOG(log, "ProcessGDBRemote::ParseFlags Found flags node \"{0}\"",
4282 flags_node.GetAttributeValue("id").c_str());
4283
4284 std::optional<llvm::StringRef> id;
4285 std::optional<unsigned> size;
4286 flags_node.ForEachAttribute(
4287 [&id, &size, &log](const llvm::StringRef &name,
4288 const llvm::StringRef &value) {
4289 if (name == "id") {
4290 id = value;
4291 } else if (name == "size") {
4292 unsigned parsed_size = 0;
4293 if (llvm::to_integer(value, parsed_size))
4294 size = parsed_size;
4295 else {
4296 LLDB_LOG(log,
4297 "ProcessGDBRemote::ParseFlags Invalid size \"{0}\" "
4298 "in flags node",
4299 value.data());
4300 }
4301 } else {
4302 LLDB_LOG(log,
4303 "ProcessGDBRemote::ParseFlags Ignoring unknown "
4304 "attribute \"{0}\" in flags node",
4305 name.data());
4306 }
4307 return true; // Walk all attributes.
4308 });
4309
4310 if (id && size) {
4311 // Process the fields of this set of flags.
4312 std::vector<RegisterFlags::Field> fields =
4313 ParseFlagsFields(flags_node, *size);
4314 if (fields.size()) {
4315 // Sort so that the fields with the MSBs are first.
4316 std::sort(fields.rbegin(), fields.rend());
4317 std::vector<RegisterFlags::Field>::const_iterator overlap =
4318 std::adjacent_find(fields.begin(), fields.end(),
4319 [](const RegisterFlags::Field &lhs,
4320 const RegisterFlags::Field &rhs) {
4321 return lhs.Overlaps(rhs);
4322 });
4323
4324 // If no fields overlap, use them.
4325 if (overlap == fields.end()) {
4326 if (registers_flags_types.contains(*id)) {
4327 // In theory you could define some flag set, use it with a
4328 // register then redefine it. We do not know if anyone does
4329 // that, or what they would expect to happen in that case.
4330 //
4331 // LLDB chooses to take the first definition and ignore the rest
4332 // as waiting until everything has been processed is more
4333 // expensive and difficult. This means that pointers to flag
4334 // sets in the register info remain valid if later the flag set
4335 // is redefined. If we allowed redefinitions, LLDB would crash
4336 // when you tried to print a register that used the original
4337 // definition.
4338 LLDB_LOG(
4339 log,
4340 "ProcessGDBRemote::ParseFlags Definition of flags "
4341 "\"{0}\" shadows "
4342 "previous definition, using original definition instead.",
4343 id->data());
4344 } else {
4345 registers_flags_types.insert_or_assign(
4346 *id, std::make_unique<RegisterFlags>(id->str(), *size,
4347 std::move(fields)));
4348 }
4349 } else {
4350 // If any fields overlap, ignore the whole set of flags.
4351 std::vector<RegisterFlags::Field>::const_iterator next =
4352 std::next(overlap);
4353 LLDB_LOG(
4354 log,
4355 "ProcessGDBRemote::ParseFlags Ignoring flags because fields "
4356 "{0} (start: {1} end: {2}) and {3} (start: {4} end: {5}) "
4357 "overlap.",
4358 overlap->GetName().c_str(), overlap->GetStart(),
4359 overlap->GetEnd(), next->GetName().c_str(), next->GetStart(),
4360 next->GetEnd());
4361 }
4362 } else {
4363 LLDB_LOG(
4364 log,
4365 "ProcessGDBRemote::ParseFlags Ignoring definition of flags "
4366 "\"{0}\" because it contains no fields.",
4367 id->data());
4368 }
4369 }
4370
4371 return true; // Keep iterating through all "flags" elements.
4372 });
4373}
4374
4375bool ParseRegisters(
4376 XMLNode feature_node, GdbServerTargetInfo &target_info,
4377 std::vector<DynamicRegisterInfo::Register> &registers,
4378 llvm::StringMap<std::unique_ptr<RegisterFlags>> &registers_flags_types) {
4379 if (!feature_node)
4380 return false;
4381
4382 Log *log(GetLog(GDBRLog::Process));
4383
4384 ParseFlags(feature_node, registers_flags_types);
4385 for (const auto &flags : registers_flags_types)
4386 flags.second->DumpToLog(log);
4387
4388 feature_node.ForEachChildElementWithName(
4389 "reg",
4390 [&target_info, &registers, &registers_flags_types,
4391 log](const XMLNode &reg_node) -> bool {
4392 std::string gdb_group;
4393 std::string gdb_type;
4395 bool encoding_set = false;
4396 bool format_set = false;
4397
4398 // FIXME: we're silently ignoring invalid data here
4399 reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type,
4400 &encoding_set, &format_set, &reg_info,
4401 log](const llvm::StringRef &name,
4402 const llvm::StringRef &value) -> bool {
4403 if (name == "name") {
4404 reg_info.name.SetString(value);
4405 } else if (name == "bitsize") {
4406 if (llvm::to_integer(value, reg_info.byte_size))
4407 reg_info.byte_size =
4408 llvm::divideCeil(reg_info.byte_size, CHAR_BIT);
4409 } else if (name == "type") {
4410 gdb_type = value.str();
4411 } else if (name == "group") {
4412 gdb_group = value.str();
4413 } else if (name == "regnum") {
4414 llvm::to_integer(value, reg_info.regnum_remote);
4415 } else if (name == "offset") {
4416 llvm::to_integer(value, reg_info.byte_offset);
4417 } else if (name == "altname") {
4418 reg_info.alt_name.SetString(value);
4419 } else if (name == "encoding") {
4420 encoding_set = true;
4422 } else if (name == "format") {
4423 format_set = true;
4424 if (!OptionArgParser::ToFormat(value.data(), reg_info.format,
4425 nullptr)
4426 .Success())
4427 reg_info.format =
4428 llvm::StringSwitch<lldb::Format>(value)
4429 .Case("vector-sint8", eFormatVectorOfSInt8)
4430 .Case("vector-uint8", eFormatVectorOfUInt8)
4431 .Case("vector-sint16", eFormatVectorOfSInt16)
4432 .Case("vector-uint16", eFormatVectorOfUInt16)
4433 .Case("vector-sint32", eFormatVectorOfSInt32)
4434 .Case("vector-uint32", eFormatVectorOfUInt32)
4435 .Case("vector-float32", eFormatVectorOfFloat32)
4436 .Case("vector-uint64", eFormatVectorOfUInt64)
4437 .Case("vector-uint128", eFormatVectorOfUInt128)
4438 .Default(eFormatInvalid);
4439 } else if (name == "group_id") {
4440 uint32_t set_id = UINT32_MAX;
4441 llvm::to_integer(value, set_id);
4442 RegisterSetMap::const_iterator pos =
4443 target_info.reg_set_map.find(set_id);
4444 if (pos != target_info.reg_set_map.end())
4445 reg_info.set_name = pos->second.name;
4446 } else if (name == "gcc_regnum" || name == "ehframe_regnum") {
4447 llvm::to_integer(value, reg_info.regnum_ehframe);
4448 } else if (name == "dwarf_regnum") {
4449 llvm::to_integer(value, reg_info.regnum_dwarf);
4450 } else if (name == "generic") {
4452 } else if (name == "value_regnums") {
4454 0);
4455 } else if (name == "invalidate_regnums") {
4457 value, reg_info.invalidate_regs, 0);
4458 } else {
4459 LLDB_LOGF(log,
4460 "ProcessGDBRemote::ParseRegisters unhandled reg "
4461 "attribute %s = %s",
4462 name.data(), value.data());
4463 }
4464 return true; // Keep iterating through all attributes
4465 });
4466
4467 if (!gdb_type.empty()) {
4468 // gdb_type could reference some flags type defined in XML.
4469 llvm::StringMap<std::unique_ptr<RegisterFlags>>::iterator it =
4470 registers_flags_types.find(gdb_type);
4471 if (it != registers_flags_types.end()) {
4472 auto flags_type = it->second.get();
4473 if (reg_info.byte_size == flags_type->GetSize())
4474 reg_info.flags_type = flags_type;
4475 else
4476 LLDB_LOGF(log,
4477 "ProcessGDBRemote::ParseRegisters Size of register "
4478 "flags %s (%d bytes) for "
4479 "register %s does not match the register size (%d "
4480 "bytes). Ignoring this set of flags.",
4481 flags_type->GetID().c_str(), flags_type->GetSize(),
4482 reg_info.name.AsCString(), reg_info.byte_size);
4483 }
4484
4485 // There's a slim chance that the gdb_type name is both a flags type
4486 // and a simple type. Just in case, look for that too (setting both
4487 // does no harm).
4488 if (!gdb_type.empty() && !(encoding_set || format_set)) {
4489 if (llvm::StringRef(gdb_type).starts_with("int")) {
4490 reg_info.format = eFormatHex;
4491 reg_info.encoding = eEncodingUint;
4492 } else if (gdb_type == "data_ptr" || gdb_type == "code_ptr") {
4493 reg_info.format = eFormatAddressInfo;
4494 reg_info.encoding = eEncodingUint;
4495 } else if (gdb_type == "float") {
4496 reg_info.format = eFormatFloat;
4497 reg_info.encoding = eEncodingIEEE754;
4498 } else if (gdb_type == "aarch64v" ||
4499 llvm::StringRef(gdb_type).starts_with("vec") ||
4500 gdb_type == "i387_ext" || gdb_type == "uint128") {
4501 // lldb doesn't handle 128-bit uints correctly (for ymm*h), so
4502 // treat them as vector (similarly to xmm/ymm)
4503 reg_info.format = eFormatVectorOfUInt8;
4504 reg_info.encoding = eEncodingVector;
4505 } else {
4506 LLDB_LOGF(
4507 log,
4508 "ProcessGDBRemote::ParseRegisters Could not determine lldb"
4509 "format and encoding for gdb type %s",
4510 gdb_type.c_str());
4511 }
4512 }
4513 }
4514
4515 // Only update the register set name if we didn't get a "reg_set"
4516 // attribute. "set_name" will be empty if we didn't have a "reg_set"
4517 // attribute.
4518 if (!reg_info.set_name) {
4519 if (!gdb_group.empty()) {
4520 reg_info.set_name.SetCString(gdb_group.c_str());
4521 } else {
4522 // If no register group name provided anywhere,
4523 // we'll create a 'general' register set
4524 reg_info.set_name.SetCString("general");
4525 }
4526 }
4527
4528 if (reg_info.byte_size == 0) {
4529 LLDB_LOGF(log,
4530 "ProcessGDBRemote::%s Skipping zero bitsize register %s",
4531 __FUNCTION__, reg_info.name.AsCString());
4532 } else
4533 registers.push_back(reg_info);
4534
4535 return true; // Keep iterating through all "reg" elements
4536 });
4537 return true;
4538}
4539
4540} // namespace
4541
4542// This method fetches a register description feature xml file from
4543// the remote stub and adds registers/register groupsets/architecture
4544// information to the current process. It will call itself recursively
4545// for nested register definition files. It returns true if it was able
4546// to fetch and parse an xml file.
4548 ArchSpec &arch_to_use, std::string xml_filename,
4549 std::vector<DynamicRegisterInfo::Register> &registers) {
4550 // request the target xml file
4551 llvm::Expected<std::string> raw = m_gdb_comm.ReadExtFeature("features", xml_filename);
4552 if (errorToBool(raw.takeError()))
4553 return false;
4554
4555 XMLDocument xml_document;
4556
4557 if (xml_document.ParseMemory(raw->c_str(), raw->size(),
4558 xml_filename.c_str())) {
4559 GdbServerTargetInfo target_info;
4560 std::vector<XMLNode> feature_nodes;
4561
4562 // The top level feature XML file will start with a <target> tag.
4563 XMLNode target_node = xml_document.GetRootElement("target");
4564 if (target_node) {
4565 target_node.ForEachChildElement([&target_info, &feature_nodes](
4566 const XMLNode &node) -> bool {
4567 llvm::StringRef name = node.GetName();
4568 if (name == "architecture") {
4569 node.GetElementText(target_info.arch);
4570 } else if (name == "osabi") {
4571 node.GetElementText(target_info.osabi);
4572 } else if (name == "xi:include" || name == "include") {
4573 std::string href = node.GetAttributeValue("href");
4574 if (!href.empty())
4575 target_info.includes.push_back(href);
4576 } else if (name == "feature") {
4577 feature_nodes.push_back(node);
4578 } else if (name == "groups") {
4580 "group", [&target_info](const XMLNode &node) -> bool {
4581 uint32_t set_id = UINT32_MAX;
4582 RegisterSetInfo set_info;
4583
4584 node.ForEachAttribute(
4585 [&set_id, &set_info](const llvm::StringRef &name,
4586 const llvm::StringRef &value) -> bool {
4587 // FIXME: we're silently ignoring invalid data here
4588 if (name == "id")
4589 llvm::to_integer(value, set_id);
4590 if (name == "name")
4591 set_info.name = ConstString(value);
4592 return true; // Keep iterating through all attributes
4593 });
4594
4595 if (set_id != UINT32_MAX)
4596 target_info.reg_set_map[set_id] = set_info;
4597 return true; // Keep iterating through all "group" elements
4598 });
4599 }
4600 return true; // Keep iterating through all children of the target_node
4601 });
4602 } else {
4603 // In an included XML feature file, we're already "inside" the <target>
4604 // tag of the initial XML file; this included file will likely only have
4605 // a <feature> tag. Need to check for any more included files in this
4606 // <feature> element.
4607 XMLNode feature_node = xml_document.GetRootElement("feature");
4608 if (feature_node) {
4609 feature_nodes.push_back(feature_node);
4610 feature_node.ForEachChildElement([&target_info](
4611 const XMLNode &node) -> bool {
4612 llvm::StringRef name = node.GetName();
4613 if (name == "xi:include" || name == "include") {
4614 std::string href = node.GetAttributeValue("href");
4615 if (!href.empty())
4616 target_info.includes.push_back(href);
4617 }
4618 return true;
4619 });
4620 }
4621 }
4622
4623 // gdbserver does not implement the LLDB packets used to determine host
4624 // or process architecture. If that is the case, attempt to use
4625 // the <architecture/> field from target.xml, e.g.:
4626 //
4627 // <architecture>i386:x86-64</architecture> (seen from VMWare ESXi)
4628 // <architecture>arm</architecture> (seen from Segger JLink on unspecified
4629 // arm board)
4630 if (!arch_to_use.IsValid() && !target_info.arch.empty()) {
4631 // We don't have any information about vendor or OS.
4632 arch_to_use.SetTriple(llvm::StringSwitch<std::string>(target_info.arch)
4633 .Case("i386:x86-64", "x86_64")
4634 .Case("riscv:rv64", "riscv64")
4635 .Case("riscv:rv32", "riscv32")
4636 .Default(target_info.arch) +
4637 "--");
4638
4639 if (arch_to_use.IsValid())
4640 GetTarget().MergeArchitecture(arch_to_use);
4641 }
4642
4643 if (arch_to_use.IsValid()) {
4644 for (auto &feature_node : feature_nodes) {
4645 ParseRegisters(feature_node, target_info, registers,
4647 }
4648
4649 for (const auto &include : target_info.includes) {
4650 GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, include,
4651 registers);
4652 }
4653 }
4654 } else {
4655 return false;
4656 }
4657 return true;
4658}
4659
4661 std::vector<DynamicRegisterInfo::Register> &registers,
4662 const ArchSpec &arch_to_use) {
4663 std::map<uint32_t, uint32_t> remote_to_local_map;
4664 uint32_t remote_regnum = 0;
4665 for (auto it : llvm::enumerate(registers)) {
4666 DynamicRegisterInfo::Register &remote_reg_info = it.value();
4667
4668 // Assign successive remote regnums if missing.
4669 if (remote_reg_info.regnum_remote == LLDB_INVALID_REGNUM)
4670 remote_reg_info.regnum_remote = remote_regnum;
4671
4672 // Create a mapping from remote to local regnos.
4673 remote_to_local_map[remote_reg_info.regnum_remote] = it.index();
4674
4675 remote_regnum = remote_reg_info.regnum_remote + 1;
4676 }
4677
4678 for (DynamicRegisterInfo::Register &remote_reg_info : registers) {
4679 auto proc_to_lldb = [&remote_to_local_map](uint32_t process_regnum) {
4680 auto lldb_regit = remote_to_local_map.find(process_regnum);
4681 return lldb_regit != remote_to_local_map.end() ? lldb_regit->second
4683 };
4684
4685 llvm::transform(remote_reg_info.value_regs,
4686 remote_reg_info.value_regs.begin(), proc_to_lldb);
4687 llvm::transform(remote_reg_info.invalidate_regs,
4688 remote_reg_info.invalidate_regs.begin(), proc_to_lldb);
4689 }
4690
4691 // Don't use Process::GetABI, this code gets called from DidAttach, and
4692 // in that context we haven't set the Target's architecture yet, so the
4693 // ABI is also potentially incorrect.
4694 if (ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use))
4695 abi_sp->AugmentRegisterInfo(registers);
4696
4697 m_register_info_sp->SetRegisterInfo(std::move(registers), arch_to_use);
4698}
4699
4700// query the target of gdb-remote for extended target information returns
4701// true on success (got register definitions), false on failure (did not).
4703 // Make sure LLDB has an XML parser it can use first
4705 return false;
4706
4707 // check that we have extended feature read support
4709 return false;
4710
4711 // This holds register flags information for the whole of target.xml.
4712 // target.xml may include further documents that
4713 // GetGDBServerRegisterInfoXMLAndProcess will recurse to fetch and process.
4714 // That's why we clear the cache here, and not in
4715 // GetGDBServerRegisterInfoXMLAndProcess. To prevent it being cleared on every
4716 // include read.
4718 std::vector<DynamicRegisterInfo::Register> registers;
4719 if (GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, "target.xml",
4720 registers))
4721 AddRemoteRegisters(registers, arch_to_use);
4722
4723 return m_register_info_sp->GetNumRegisters() > 0;
4724}
4725
4726llvm::Expected<LoadedModuleInfoList> ProcessGDBRemote::GetLoadedModuleList() {
4727 // Make sure LLDB has an XML parser it can use first
4729 return llvm::createStringError(llvm::inconvertibleErrorCode(),
4730 "XML parsing not available");
4731
4732 Log *log = GetLog(LLDBLog::Process);
4733 LLDB_LOGF(log, "ProcessGDBRemote::%s", __FUNCTION__);
4734
4737 bool can_use_svr4 = GetGlobalPluginProperties().GetUseSVR4();
4738
4739 // check that we have extended feature read support
4740 if (can_use_svr4 && comm.GetQXferLibrariesSVR4ReadSupported()) {
4741 // request the loaded library list
4742 llvm::Expected<std::string> raw = comm.ReadExtFeature("libraries-svr4", "");
4743 if (!raw)
4744 return raw.takeError();
4745
4746 // parse the xml file in memory
4747 LLDB_LOGF(log, "parsing: %s", raw->c_str());
4748 XMLDocument doc;
4749
4750 if (!doc.ParseMemory(raw->c_str(), raw->size(), "noname.xml"))
4751 return llvm::createStringError(llvm::inconvertibleErrorCode(),
4752 "Error reading noname.xml");
4753
4754 XMLNode root_element = doc.GetRootElement("library-list-svr4");
4755 if (!root_element)
4756 return llvm::createStringError(
4757 llvm::inconvertibleErrorCode(),
4758 "Error finding library-list-svr4 xml element");
4759
4760 // main link map structure
4761 std::string main_lm = root_element.GetAttributeValue("main-lm");
4762 // FIXME: we're silently ignoring invalid data here
4763 if (!main_lm.empty())
4764 llvm::to_integer(main_lm, list.m_link_map);
4765
4766 root_element.ForEachChildElementWithName(
4767 "library", [log, &list](const XMLNode &library) -> bool {
4769
4770 // FIXME: we're silently ignoring invalid data here
4771 library.ForEachAttribute(
4772 [&module](const llvm::StringRef &name,
4773 const llvm::StringRef &value) -> bool {
4774 uint64_t uint_value = LLDB_INVALID_ADDRESS;
4775 if (name == "name")
4776 module.set_name(value.str());
4777 else if (name == "lm") {
4778 // the address of the link_map struct.
4779 llvm::to_integer(value, uint_value);
4780 module.set_link_map(uint_value);
4781 } else if (name == "l_addr") {
4782 // the displacement as read from the field 'l_addr' of the
4783 // link_map struct.
4784 llvm::to_integer(value, uint_value);
4785 module.set_base(uint_value);
4786 // base address is always a displacement, not an absolute
4787 // value.
4788 module.set_base_is_offset(true);
4789 } else if (name == "l_ld") {
4790 // the memory address of the libraries PT_DYNAMIC section.
4791 llvm::to_integer(value, uint_value);
4792 module.set_dynamic(uint_value);
4793 }
4794
4795 return true; // Keep iterating over all properties of "library"
4796 });
4797
4798 if (log) {
4799 std::string name;
4800 lldb::addr_t lm = 0, base = 0, ld = 0;
4801 bool base_is_offset;
4802
4803 module.get_name(name);
4804 module.get_link_map(lm);
4805 module.get_base(base);
4806 module.get_base_is_offset(base_is_offset);
4807 module.get_dynamic(ld);
4808
4809 LLDB_LOGF(log,
4810 "found (link_map:0x%08" PRIx64 ", base:0x%08" PRIx64
4811 "[%s], ld:0x%08" PRIx64 ", name:'%s')",
4812 lm, base, (base_is_offset ? "offset" : "absolute"), ld,
4813 name.c_str());
4814 }
4815
4816 list.add(module);
4817 return true; // Keep iterating over all "library" elements in the root
4818 // node
4819 });
4820
4821 if (log)
4822 LLDB_LOGF(log, "found %" PRId32 " modules in total",
4823 (int)list.m_list.size());
4824 return list;
4825 } else if (comm.GetQXferLibrariesReadSupported()) {
4826 // request the loaded library list
4827 llvm::Expected<std::string> raw = comm.ReadExtFeature("libraries", "");
4828
4829 if (!raw)
4830 return raw.takeError();
4831
4832 LLDB_LOGF(log, "parsing: %s", raw->c_str());
4833 XMLDocument doc;
4834
4835 if (!doc.ParseMemory(raw->c_str(), raw->size(), "noname.xml"))
4836 return llvm::createStringError(llvm::inconvertibleErrorCode(),
4837 "Error reading noname.xml");
4838
4839 XMLNode root_element = doc.GetRootElement("library-list");
4840 if (!root_element)
4841 return llvm::createStringError(llvm::inconvertibleErrorCode(),
4842 "Error finding library-list xml element");
4843
4844 // FIXME: we're silently ignoring invalid data here
4845 root_element.ForEachChildElementWithName(
4846 "library", [log, &list](const XMLNode &library) -> bool {
4848
4849 std::string name = library.GetAttributeValue("name");
4850 module.set_name(name);
4851
4852 // The base address of a given library will be the address of its
4853 // first section. Most remotes send only one section for Windows
4854 // targets for example.
4855 const XMLNode &section =
4856 library.FindFirstChildElementWithName("section");
4857 std::string address = section.GetAttributeValue("address");
4858 uint64_t address_value = LLDB_INVALID_ADDRESS;
4859 llvm::to_integer(address, address_value);
4860 module.set_base(address_value);
4861 // These addresses are absolute values.
4862 module.set_base_is_offset(false);
4863
4864 if (log) {
4865 std::string name;
4866 lldb::addr_t base = 0;
4867 bool base_is_offset;
4868 module.get_name(name);
4869 module.get_base(base);
4870 module.get_base_is_offset(base_is_offset);
4871
4872 LLDB_LOGF(log, "found (base:0x%08" PRIx64 "[%s], name:'%s')", base,
4873 (base_is_offset ? "offset" : "absolute"), name.c_str());
4874 }
4875
4876 list.add(module);
4877 return true; // Keep iterating over all "library" elements in the root
4878 // node
4879 });
4880
4881 if (log)
4882 LLDB_LOGF(log, "found %" PRId32 " modules in total",
4883 (int)list.m_list.size());
4884 return list;
4885 } else {
4886 return llvm::createStringError(llvm::inconvertibleErrorCode(),
4887 "Remote libraries not supported");
4888 }
4889}
4890
4892 lldb::addr_t link_map,
4893 lldb::addr_t base_addr,
4894 bool value_is_offset) {
4895 DynamicLoader *loader = GetDynamicLoader();
4896 if (!loader)
4897 return nullptr;
4898
4899 return loader->LoadModuleAtAddress(file, link_map, base_addr,
4900 value_is_offset);