1 //===-- GDBRemoteCommunicationServerCommon.cpp ------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "GDBRemoteCommunicationServerCommon.h"
17 #include <TargetConditionals.h>
24 // Other libraries and framework includes
25 #include "lldb/Core/ModuleSpec.h"
26 #include "lldb/Host/Config.h"
27 #include "lldb/Host/File.h"
28 #include "lldb/Host/FileSystem.h"
29 #include "lldb/Host/Host.h"
30 #include "lldb/Host/HostInfo.h"
31 #include "lldb/Interpreter/OptionArgParser.h"
32 #include "lldb/Symbol/ObjectFile.h"
33 #include "lldb/Target/FileAction.h"
34 #include "lldb/Target/Platform.h"
35 #include "lldb/Target/Process.h"
36 #include "lldb/Utility/Endian.h"
37 #include "lldb/Utility/JSON.h"
38 #include "lldb/Utility/Log.h"
39 #include "lldb/Utility/SafeMachO.h"
40 #include "lldb/Utility/StreamGDBRemote.h"
41 #include "lldb/Utility/StreamString.h"
42 #include "llvm/ADT/Triple.h"
45 #include "ProcessGDBRemoteLog.h"
46 #include "lldb/Utility/StringExtractorGDBRemote.h"
49 #include "lldb/Host/android/HostInfoAndroid.h"
52 #include "llvm/ADT/StringSwitch.h"
55 using namespace lldb_private;
56 using namespace lldb_private::process_gdb_remote;
59 const static uint32_t g_default_packet_timeout_sec = 20; // seconds
61 const static uint32_t g_default_packet_timeout_sec = 0; // not specified
64 //----------------------------------------------------------------------
65 // GDBRemoteCommunicationServerCommon constructor
66 //----------------------------------------------------------------------
67 GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon(
68 const char *comm_name, const char *listener_name)
69 : GDBRemoteCommunicationServer(comm_name, listener_name),
70 m_process_launch_info(), m_process_launch_error(), m_proc_infos(),
71 m_proc_infos_index(0), m_thread_suffix_supported(false),
72 m_list_threads_in_stop_reply(false) {
73 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_A,
74 &GDBRemoteCommunicationServerCommon::Handle_A);
75 RegisterMemberFunctionHandler(
76 StringExtractorGDBRemote::eServerPacketType_QEnvironment,
77 &GDBRemoteCommunicationServerCommon::Handle_QEnvironment);
78 RegisterMemberFunctionHandler(
79 StringExtractorGDBRemote::eServerPacketType_QEnvironmentHexEncoded,
80 &GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded);
81 RegisterMemberFunctionHandler(
82 StringExtractorGDBRemote::eServerPacketType_qfProcessInfo,
83 &GDBRemoteCommunicationServerCommon::Handle_qfProcessInfo);
84 RegisterMemberFunctionHandler(
85 StringExtractorGDBRemote::eServerPacketType_qGroupName,
86 &GDBRemoteCommunicationServerCommon::Handle_qGroupName);
87 RegisterMemberFunctionHandler(
88 StringExtractorGDBRemote::eServerPacketType_qHostInfo,
89 &GDBRemoteCommunicationServerCommon::Handle_qHostInfo);
90 RegisterMemberFunctionHandler(
91 StringExtractorGDBRemote::eServerPacketType_QLaunchArch,
92 &GDBRemoteCommunicationServerCommon::Handle_QLaunchArch);
93 RegisterMemberFunctionHandler(
94 StringExtractorGDBRemote::eServerPacketType_qLaunchSuccess,
95 &GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess);
96 RegisterMemberFunctionHandler(
97 StringExtractorGDBRemote::eServerPacketType_QListThreadsInStopReply,
98 &GDBRemoteCommunicationServerCommon::Handle_QListThreadsInStopReply);
99 RegisterMemberFunctionHandler(
100 StringExtractorGDBRemote::eServerPacketType_qEcho,
101 &GDBRemoteCommunicationServerCommon::Handle_qEcho);
102 RegisterMemberFunctionHandler(
103 StringExtractorGDBRemote::eServerPacketType_qModuleInfo,
104 &GDBRemoteCommunicationServerCommon::Handle_qModuleInfo);
105 RegisterMemberFunctionHandler(
106 StringExtractorGDBRemote::eServerPacketType_jModulesInfo,
107 &GDBRemoteCommunicationServerCommon::Handle_jModulesInfo);
108 RegisterMemberFunctionHandler(
109 StringExtractorGDBRemote::eServerPacketType_qPlatform_chmod,
110 &GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod);
111 RegisterMemberFunctionHandler(
112 StringExtractorGDBRemote::eServerPacketType_qPlatform_mkdir,
113 &GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir);
114 RegisterMemberFunctionHandler(
115 StringExtractorGDBRemote::eServerPacketType_qPlatform_shell,
116 &GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell);
117 RegisterMemberFunctionHandler(
118 StringExtractorGDBRemote::eServerPacketType_qProcessInfoPID,
119 &GDBRemoteCommunicationServerCommon::Handle_qProcessInfoPID);
120 RegisterMemberFunctionHandler(
121 StringExtractorGDBRemote::eServerPacketType_QSetDetachOnError,
122 &GDBRemoteCommunicationServerCommon::Handle_QSetDetachOnError);
123 RegisterMemberFunctionHandler(
124 StringExtractorGDBRemote::eServerPacketType_QSetSTDERR,
125 &GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR);
126 RegisterMemberFunctionHandler(
127 StringExtractorGDBRemote::eServerPacketType_QSetSTDIN,
128 &GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN);
129 RegisterMemberFunctionHandler(
130 StringExtractorGDBRemote::eServerPacketType_QSetSTDOUT,
131 &GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT);
132 RegisterMemberFunctionHandler(
133 StringExtractorGDBRemote::eServerPacketType_qSpeedTest,
134 &GDBRemoteCommunicationServerCommon::Handle_qSpeedTest);
135 RegisterMemberFunctionHandler(
136 StringExtractorGDBRemote::eServerPacketType_qsProcessInfo,
137 &GDBRemoteCommunicationServerCommon::Handle_qsProcessInfo);
138 RegisterMemberFunctionHandler(
139 StringExtractorGDBRemote::eServerPacketType_QStartNoAckMode,
140 &GDBRemoteCommunicationServerCommon::Handle_QStartNoAckMode);
141 RegisterMemberFunctionHandler(
142 StringExtractorGDBRemote::eServerPacketType_qSupported,
143 &GDBRemoteCommunicationServerCommon::Handle_qSupported);
144 RegisterMemberFunctionHandler(
145 StringExtractorGDBRemote::eServerPacketType_QThreadSuffixSupported,
146 &GDBRemoteCommunicationServerCommon::Handle_QThreadSuffixSupported);
147 RegisterMemberFunctionHandler(
148 StringExtractorGDBRemote::eServerPacketType_qUserName,
149 &GDBRemoteCommunicationServerCommon::Handle_qUserName);
150 RegisterMemberFunctionHandler(
151 StringExtractorGDBRemote::eServerPacketType_vFile_close,
152 &GDBRemoteCommunicationServerCommon::Handle_vFile_Close);
153 RegisterMemberFunctionHandler(
154 StringExtractorGDBRemote::eServerPacketType_vFile_exists,
155 &GDBRemoteCommunicationServerCommon::Handle_vFile_Exists);
156 RegisterMemberFunctionHandler(
157 StringExtractorGDBRemote::eServerPacketType_vFile_md5,
158 &GDBRemoteCommunicationServerCommon::Handle_vFile_MD5);
159 RegisterMemberFunctionHandler(
160 StringExtractorGDBRemote::eServerPacketType_vFile_mode,
161 &GDBRemoteCommunicationServerCommon::Handle_vFile_Mode);
162 RegisterMemberFunctionHandler(
163 StringExtractorGDBRemote::eServerPacketType_vFile_open,
164 &GDBRemoteCommunicationServerCommon::Handle_vFile_Open);
165 RegisterMemberFunctionHandler(
166 StringExtractorGDBRemote::eServerPacketType_vFile_pread,
167 &GDBRemoteCommunicationServerCommon::Handle_vFile_pRead);
168 RegisterMemberFunctionHandler(
169 StringExtractorGDBRemote::eServerPacketType_vFile_pwrite,
170 &GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite);
171 RegisterMemberFunctionHandler(
172 StringExtractorGDBRemote::eServerPacketType_vFile_size,
173 &GDBRemoteCommunicationServerCommon::Handle_vFile_Size);
174 RegisterMemberFunctionHandler(
175 StringExtractorGDBRemote::eServerPacketType_vFile_stat,
176 &GDBRemoteCommunicationServerCommon::Handle_vFile_Stat);
177 RegisterMemberFunctionHandler(
178 StringExtractorGDBRemote::eServerPacketType_vFile_symlink,
179 &GDBRemoteCommunicationServerCommon::Handle_vFile_symlink);
180 RegisterMemberFunctionHandler(
181 StringExtractorGDBRemote::eServerPacketType_vFile_unlink,
182 &GDBRemoteCommunicationServerCommon::Handle_vFile_unlink);
185 //----------------------------------------------------------------------
187 //----------------------------------------------------------------------
188 GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() {}
190 GDBRemoteCommunication::PacketResult
191 GDBRemoteCommunicationServerCommon::Handle_qHostInfo(
192 StringExtractorGDBRemote &packet) {
193 StreamString response;
195 // $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00
197 ArchSpec host_arch(HostInfo::GetArchitecture());
198 const llvm::Triple &host_triple = host_arch.GetTriple();
199 response.PutCString("triple:");
200 response.PutCStringAsRawHex8(host_triple.getTriple().c_str());
201 response.Printf(";ptrsize:%u;", host_arch.GetAddressByteSize());
203 const char *distribution_id = host_arch.GetDistributionId().AsCString();
204 if (distribution_id) {
205 response.PutCString("distribution_id:");
206 response.PutCStringAsRawHex8(distribution_id);
207 response.PutCString(";");
210 #if defined(__APPLE__)
211 // For parity with debugserver, we'll include the vendor key.
212 response.PutCString("vendor:apple;");
214 // Send out MachO info.
215 uint32_t cpu = host_arch.GetMachOCPUType();
216 uint32_t sub = host_arch.GetMachOCPUSubType();
217 if (cpu != LLDB_INVALID_CPUTYPE)
218 response.Printf("cputype:%u;", cpu);
219 if (sub != LLDB_INVALID_CPUTYPE)
220 response.Printf("cpusubtype:%u;", sub);
222 if (cpu == llvm::MachO::CPU_TYPE_ARM
223 || cpu == llvm::MachO::CPU_TYPE_ARM64) {
224 // Indicate the OS type.
225 #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
226 response.PutCString("ostype:tvos;");
227 #elif defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
228 response.PutCString("ostype:watchos;");
229 #elif defined(TARGET_OS_BRIDGE) && TARGET_OS_BRIDGE == 1
230 response.PutCString("ostype:bridgeos;");
232 response.PutCString("ostype:ios;");
235 // On arm, we use "synchronous" watchpoints which means the exception is
236 // delivered before the instruction executes.
237 response.PutCString("watchpoint_exceptions_received:before;");
239 response.PutCString("ostype:macosx;");
240 response.Printf("watchpoint_exceptions_received:after;");
244 if (host_arch.GetMachine() == llvm::Triple::aarch64 ||
245 host_arch.GetMachine() == llvm::Triple::aarch64_be ||
246 host_arch.GetMachine() == llvm::Triple::arm ||
247 host_arch.GetMachine() == llvm::Triple::armeb ||
248 host_arch.GetMachine() == llvm::Triple::mips64 ||
249 host_arch.GetMachine() == llvm::Triple::mips64el ||
250 host_arch.GetMachine() == llvm::Triple::mips ||
251 host_arch.GetMachine() == llvm::Triple::mipsel)
252 response.Printf("watchpoint_exceptions_received:before;");
254 response.Printf("watchpoint_exceptions_received:after;");
257 switch (endian::InlHostByteOrder()) {
259 response.PutCString("endian:big;");
261 case eByteOrderLittle:
262 response.PutCString("endian:little;");
265 response.PutCString("endian:pdp;");
268 response.PutCString("endian:unknown;");
272 llvm::VersionTuple version = HostInfo::GetOSVersion();
273 if (!version.empty()) {
274 response.Format("os_version:{0}", version.getAsString());
275 response.PutChar(';');
279 if (HostInfo::GetOSBuildString(s)) {
280 response.PutCString("os_build:");
281 response.PutCStringAsRawHex8(s.c_str());
282 response.PutChar(';');
284 if (HostInfo::GetOSKernelDescription(s)) {
285 response.PutCString("os_kernel:");
286 response.PutCStringAsRawHex8(s.c_str());
287 response.PutChar(';');
290 #if defined(__APPLE__)
292 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
293 // For iOS devices, we are connected through a USB Mux so we never pretend to
294 // actually have a hostname as far as the remote lldb that is connecting to
295 // this lldb-platform is concerned
296 response.PutCString("hostname:");
297 response.PutCStringAsRawHex8("127.0.0.1");
298 response.PutChar(';');
299 #else // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
300 if (HostInfo::GetHostname(s)) {
301 response.PutCString("hostname:");
302 response.PutCStringAsRawHex8(s.c_str());
303 response.PutChar(';');
305 #endif // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
307 #else // #if defined(__APPLE__)
308 if (HostInfo::GetHostname(s)) {
309 response.PutCString("hostname:");
310 response.PutCStringAsRawHex8(s.c_str());
311 response.PutChar(';');
313 #endif // #if defined(__APPLE__)
315 if (g_default_packet_timeout_sec > 0)
316 response.Printf("default_packet_timeout:%u;", g_default_packet_timeout_sec);
318 return SendPacketNoLock(response.GetString());
321 GDBRemoteCommunication::PacketResult
322 GDBRemoteCommunicationServerCommon::Handle_qProcessInfoPID(
323 StringExtractorGDBRemote &packet) {
324 // Packet format: "qProcessInfoPID:%i" where %i is the pid
325 packet.SetFilePos(::strlen("qProcessInfoPID:"));
326 lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID);
327 if (pid != LLDB_INVALID_PROCESS_ID) {
328 ProcessInstanceInfo proc_info;
329 if (Host::GetProcessInfo(pid, proc_info)) {
330 StreamString response;
331 CreateProcessInfoResponse(proc_info, response);
332 return SendPacketNoLock(response.GetString());
335 return SendErrorResponse(1);
338 GDBRemoteCommunication::PacketResult
339 GDBRemoteCommunicationServerCommon::Handle_qfProcessInfo(
340 StringExtractorGDBRemote &packet) {
341 m_proc_infos_index = 0;
342 m_proc_infos.Clear();
344 ProcessInstanceInfoMatch match_info;
345 packet.SetFilePos(::strlen("qfProcessInfo"));
346 if (packet.GetChar() == ':') {
348 llvm::StringRef value;
349 while (packet.GetNameColonValue(key, value)) {
351 if (key.equals("name")) {
352 StringExtractor extractor(value);
354 extractor.GetHexByteString(file);
355 match_info.GetProcessInfo().GetExecutableFile().SetFile(
356 file, false, FileSpec::Style::native);
357 } else if (key.equals("name_match")) {
358 NameMatch name_match = llvm::StringSwitch<NameMatch>(value)
359 .Case("equals", NameMatch::Equals)
360 .Case("starts_with", NameMatch::StartsWith)
361 .Case("ends_with", NameMatch::EndsWith)
362 .Case("contains", NameMatch::Contains)
363 .Case("regex", NameMatch::RegularExpression)
364 .Default(NameMatch::Ignore);
365 match_info.SetNameMatchType(name_match);
366 if (name_match == NameMatch::Ignore)
367 return SendErrorResponse(2);
368 } else if (key.equals("pid")) {
369 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
370 if (value.getAsInteger(0, pid))
371 return SendErrorResponse(2);
372 match_info.GetProcessInfo().SetProcessID(pid);
373 } else if (key.equals("parent_pid")) {
374 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
375 if (value.getAsInteger(0, pid))
376 return SendErrorResponse(2);
377 match_info.GetProcessInfo().SetParentProcessID(pid);
378 } else if (key.equals("uid")) {
379 uint32_t uid = UINT32_MAX;
380 if (value.getAsInteger(0, uid))
381 return SendErrorResponse(2);
382 match_info.GetProcessInfo().SetUserID(uid);
383 } else if (key.equals("gid")) {
384 uint32_t gid = UINT32_MAX;
385 if (value.getAsInteger(0, gid))
386 return SendErrorResponse(2);
387 match_info.GetProcessInfo().SetGroupID(gid);
388 } else if (key.equals("euid")) {
389 uint32_t uid = UINT32_MAX;
390 if (value.getAsInteger(0, uid))
391 return SendErrorResponse(2);
392 match_info.GetProcessInfo().SetEffectiveUserID(uid);
393 } else if (key.equals("egid")) {
394 uint32_t gid = UINT32_MAX;
395 if (value.getAsInteger(0, gid))
396 return SendErrorResponse(2);
397 match_info.GetProcessInfo().SetEffectiveGroupID(gid);
398 } else if (key.equals("all_users")) {
399 match_info.SetMatchAllUsers(
400 OptionArgParser::ToBoolean(value, false, &success));
401 } else if (key.equals("triple")) {
402 match_info.GetProcessInfo().GetArchitecture() =
403 HostInfo::GetAugmentedArchSpec(value);
409 return SendErrorResponse(2);
413 if (Host::FindProcesses(match_info, m_proc_infos)) {
414 // We found something, return the first item by calling the get subsequent
415 // process info packet handler...
416 return Handle_qsProcessInfo(packet);
418 return SendErrorResponse(3);
421 GDBRemoteCommunication::PacketResult
422 GDBRemoteCommunicationServerCommon::Handle_qsProcessInfo(
423 StringExtractorGDBRemote &packet) {
424 if (m_proc_infos_index < m_proc_infos.GetSize()) {
425 StreamString response;
426 CreateProcessInfoResponse(
427 m_proc_infos.GetProcessInfoAtIndex(m_proc_infos_index), response);
428 ++m_proc_infos_index;
429 return SendPacketNoLock(response.GetString());
431 return SendErrorResponse(4);
434 GDBRemoteCommunication::PacketResult
435 GDBRemoteCommunicationServerCommon::Handle_qUserName(
436 StringExtractorGDBRemote &packet) {
437 #if !defined(LLDB_DISABLE_POSIX)
438 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
440 log->Printf("GDBRemoteCommunicationServerCommon::%s begin", __FUNCTION__);
442 // Packet format: "qUserName:%i" where %i is the uid
443 packet.SetFilePos(::strlen("qUserName:"));
444 uint32_t uid = packet.GetU32(UINT32_MAX);
445 if (uid != UINT32_MAX) {
447 if (HostInfo::LookupUserName(uid, name)) {
448 StreamString response;
449 response.PutCStringAsRawHex8(name.c_str());
450 return SendPacketNoLock(response.GetString());
454 log->Printf("GDBRemoteCommunicationServerCommon::%s end", __FUNCTION__);
456 return SendErrorResponse(5);
459 GDBRemoteCommunication::PacketResult
460 GDBRemoteCommunicationServerCommon::Handle_qGroupName(
461 StringExtractorGDBRemote &packet) {
462 #if !defined(LLDB_DISABLE_POSIX)
463 // Packet format: "qGroupName:%i" where %i is the gid
464 packet.SetFilePos(::strlen("qGroupName:"));
465 uint32_t gid = packet.GetU32(UINT32_MAX);
466 if (gid != UINT32_MAX) {
468 if (HostInfo::LookupGroupName(gid, name)) {
469 StreamString response;
470 response.PutCStringAsRawHex8(name.c_str());
471 return SendPacketNoLock(response.GetString());
475 return SendErrorResponse(6);
478 GDBRemoteCommunication::PacketResult
479 GDBRemoteCommunicationServerCommon::Handle_qSpeedTest(
480 StringExtractorGDBRemote &packet) {
481 packet.SetFilePos(::strlen("qSpeedTest:"));
484 llvm::StringRef value;
485 bool success = packet.GetNameColonValue(key, value);
486 if (success && key.equals("response_size")) {
487 uint32_t response_size = 0;
488 if (!value.getAsInteger(0, response_size)) {
489 if (response_size == 0)
490 return SendOKResponse();
491 StreamString response;
492 uint32_t bytes_left = response_size;
493 response.PutCString("data:");
494 while (bytes_left > 0) {
495 if (bytes_left >= 26) {
496 response.PutCString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
499 response.Printf("%*.*s;", bytes_left, bytes_left,
500 "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
504 return SendPacketNoLock(response.GetString());
507 return SendErrorResponse(7);
510 GDBRemoteCommunication::PacketResult
511 GDBRemoteCommunicationServerCommon::Handle_vFile_Open(
512 StringExtractorGDBRemote &packet) {
513 packet.SetFilePos(::strlen("vFile:open:"));
515 packet.GetHexByteStringTerminatedBy(path, ',');
517 if (packet.GetChar() == ',') {
519 File::ConvertOpenOptionsForPOSIXOpen(packet.GetHexMaxU32(false, 0));
520 if (packet.GetChar() == ',') {
521 mode_t mode = packet.GetHexMaxU32(false, 0600);
523 const FileSpec path_spec{path, true};
524 int fd = ::open(path_spec.GetCString(), flags, mode);
525 const int save_errno = fd == -1 ? errno : 0;
526 StreamString response;
527 response.PutChar('F');
528 response.Printf("%i", fd);
530 response.Printf(",%i", save_errno);
531 return SendPacketNoLock(response.GetString());
535 return SendErrorResponse(18);
538 GDBRemoteCommunication::PacketResult
539 GDBRemoteCommunicationServerCommon::Handle_vFile_Close(
540 StringExtractorGDBRemote &packet) {
541 packet.SetFilePos(::strlen("vFile:close:"));
542 int fd = packet.GetS32(-1);
548 save_errno = err == -1 ? errno : 0;
552 StreamString response;
553 response.PutChar('F');
554 response.Printf("%i", err);
556 response.Printf(",%i", save_errno);
557 return SendPacketNoLock(response.GetString());
560 GDBRemoteCommunication::PacketResult
561 GDBRemoteCommunicationServerCommon::Handle_vFile_pRead(
562 StringExtractorGDBRemote &packet) {
564 // Not implemented on Windows
565 return SendUnimplementedResponse(
566 "GDBRemoteCommunicationServerCommon::Handle_vFile_pRead() unimplemented");
568 StreamGDBRemote response;
569 packet.SetFilePos(::strlen("vFile:pread:"));
570 int fd = packet.GetS32(-1);
571 if (packet.GetChar() == ',') {
572 uint64_t count = packet.GetU64(UINT64_MAX);
573 if (packet.GetChar() == ',') {
574 uint64_t offset = packet.GetU64(UINT32_MAX);
575 if (count == UINT64_MAX) {
576 response.Printf("F-1:%i", EINVAL);
577 return SendPacketNoLock(response.GetString());
580 std::string buffer(count, 0);
581 const ssize_t bytes_read = ::pread(fd, &buffer[0], buffer.size(), offset);
582 const int save_errno = bytes_read == -1 ? errno : 0;
583 response.PutChar('F');
584 response.Printf("%zi", bytes_read);
586 response.Printf(",%i", save_errno);
588 response.PutChar(';');
589 response.PutEscapedBytes(&buffer[0], bytes_read);
591 return SendPacketNoLock(response.GetString());
594 return SendErrorResponse(21);
599 GDBRemoteCommunication::PacketResult
600 GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite(
601 StringExtractorGDBRemote &packet) {
603 return SendUnimplementedResponse("GDBRemoteCommunicationServerCommon::Handle_"
604 "vFile_pWrite() unimplemented");
606 packet.SetFilePos(::strlen("vFile:pwrite:"));
608 StreamGDBRemote response;
609 response.PutChar('F');
611 int fd = packet.GetU32(UINT32_MAX);
612 if (packet.GetChar() == ',') {
613 off_t offset = packet.GetU64(UINT32_MAX);
614 if (packet.GetChar() == ',') {
616 if (packet.GetEscapedBinaryData(buffer)) {
617 const ssize_t bytes_written =
618 ::pwrite(fd, buffer.data(), buffer.size(), offset);
619 const int save_errno = bytes_written == -1 ? errno : 0;
620 response.Printf("%zi", bytes_written);
622 response.Printf(",%i", save_errno);
624 response.Printf("-1,%i", EINVAL);
626 return SendPacketNoLock(response.GetString());
629 return SendErrorResponse(27);
633 GDBRemoteCommunication::PacketResult
634 GDBRemoteCommunicationServerCommon::Handle_vFile_Size(
635 StringExtractorGDBRemote &packet) {
636 packet.SetFilePos(::strlen("vFile:size:"));
638 packet.GetHexByteString(path);
641 if (llvm::sys::fs::file_size(path, Size))
642 return SendErrorResponse(5);
643 StreamString response;
644 response.PutChar('F');
645 response.PutHex64(Size);
646 if (Size == UINT64_MAX) {
647 response.PutChar(',');
648 response.PutHex64(Size); // TODO: replace with Host::GetSyswideErrorCode()
650 return SendPacketNoLock(response.GetString());
652 return SendErrorResponse(22);
655 GDBRemoteCommunication::PacketResult
656 GDBRemoteCommunicationServerCommon::Handle_vFile_Mode(
657 StringExtractorGDBRemote &packet) {
658 packet.SetFilePos(::strlen("vFile:mode:"));
660 packet.GetHexByteString(path);
663 const uint32_t mode = File::GetPermissions(FileSpec{path, true}, error);
664 StreamString response;
665 response.Printf("F%u", mode);
666 if (mode == 0 || error.Fail())
667 response.Printf(",%i", (int)error.GetError());
668 return SendPacketNoLock(response.GetString());
670 return SendErrorResponse(23);
673 GDBRemoteCommunication::PacketResult
674 GDBRemoteCommunicationServerCommon::Handle_vFile_Exists(
675 StringExtractorGDBRemote &packet) {
676 packet.SetFilePos(::strlen("vFile:exists:"));
678 packet.GetHexByteString(path);
680 bool retcode = llvm::sys::fs::exists(path);
681 StreamString response;
682 response.PutChar('F');
683 response.PutChar(',');
685 response.PutChar('1');
687 response.PutChar('0');
688 return SendPacketNoLock(response.GetString());
690 return SendErrorResponse(24);
693 GDBRemoteCommunication::PacketResult
694 GDBRemoteCommunicationServerCommon::Handle_vFile_symlink(
695 StringExtractorGDBRemote &packet) {
696 packet.SetFilePos(::strlen("vFile:symlink:"));
697 std::string dst, src;
698 packet.GetHexByteStringTerminatedBy(dst, ',');
699 packet.GetChar(); // Skip ',' char
700 packet.GetHexByteString(src);
701 Status error = FileSystem::Symlink(FileSpec{src, true}, FileSpec{dst, false});
702 StreamString response;
703 response.Printf("F%u,%u", error.GetError(), error.GetError());
704 return SendPacketNoLock(response.GetString());
707 GDBRemoteCommunication::PacketResult
708 GDBRemoteCommunicationServerCommon::Handle_vFile_unlink(
709 StringExtractorGDBRemote &packet) {
710 packet.SetFilePos(::strlen("vFile:unlink:"));
712 packet.GetHexByteString(path);
713 Status error(llvm::sys::fs::remove(path));
714 StreamString response;
715 response.Printf("F%u,%u", error.GetError(), error.GetError());
716 return SendPacketNoLock(response.GetString());
719 GDBRemoteCommunication::PacketResult
720 GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell(
721 StringExtractorGDBRemote &packet) {
722 packet.SetFilePos(::strlen("qPlatform_shell:"));
724 std::string working_dir;
725 packet.GetHexByteStringTerminatedBy(path, ',');
727 if (packet.GetChar() == ',') {
728 // FIXME: add timeout to qPlatform_shell packet
729 // uint32_t timeout = packet.GetHexMaxU32(false, 32);
730 if (packet.GetChar() == ',')
731 packet.GetHexByteString(working_dir);
734 Status err = Host::RunShellCommand(
735 path.c_str(), FileSpec{working_dir, true}, &status, &signo, &output,
736 std::chrono::seconds(10));
737 StreamGDBRemote response;
739 response.PutCString("F,");
740 response.PutHex32(UINT32_MAX);
742 response.PutCString("F,");
743 response.PutHex32(status);
744 response.PutChar(',');
745 response.PutHex32(signo);
746 response.PutChar(',');
747 response.PutEscapedBytes(output.c_str(), output.size());
749 return SendPacketNoLock(response.GetString());
752 return SendErrorResponse(24);
755 GDBRemoteCommunication::PacketResult
756 GDBRemoteCommunicationServerCommon::Handle_vFile_Stat(
757 StringExtractorGDBRemote &packet) {
758 return SendUnimplementedResponse(
759 "GDBRemoteCommunicationServerCommon::Handle_vFile_Stat() unimplemented");
762 GDBRemoteCommunication::PacketResult
763 GDBRemoteCommunicationServerCommon::Handle_vFile_MD5(
764 StringExtractorGDBRemote &packet) {
765 packet.SetFilePos(::strlen("vFile:MD5:"));
767 packet.GetHexByteString(path);
769 StreamGDBRemote response;
770 auto Result = llvm::sys::fs::md5_contents(path);
772 response.PutCString("F,");
773 response.PutCString("x");
775 response.PutCString("F,");
776 response.PutHex64(Result->low());
777 response.PutHex64(Result->high());
779 return SendPacketNoLock(response.GetString());
781 return SendErrorResponse(25);
784 GDBRemoteCommunication::PacketResult
785 GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir(
786 StringExtractorGDBRemote &packet) {
787 packet.SetFilePos(::strlen("qPlatform_mkdir:"));
788 mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
789 if (packet.GetChar() == ',') {
791 packet.GetHexByteString(path);
792 Status error(llvm::sys::fs::create_directory(path, mode));
794 StreamGDBRemote response;
795 response.Printf("F%u", error.GetError());
797 return SendPacketNoLock(response.GetString());
799 return SendErrorResponse(20);
802 GDBRemoteCommunication::PacketResult
803 GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod(
804 StringExtractorGDBRemote &packet) {
805 packet.SetFilePos(::strlen("qPlatform_chmod:"));
808 static_cast<llvm::sys::fs::perms>(packet.GetHexMaxU32(false, UINT32_MAX));
809 if (packet.GetChar() == ',') {
811 packet.GetHexByteString(path);
812 Status error(llvm::sys::fs::setPermissions(path, perms));
814 StreamGDBRemote response;
815 response.Printf("F%u", error.GetError());
817 return SendPacketNoLock(response.GetString());
819 return SendErrorResponse(19);
822 GDBRemoteCommunication::PacketResult
823 GDBRemoteCommunicationServerCommon::Handle_qSupported(
824 StringExtractorGDBRemote &packet) {
825 StreamGDBRemote response;
827 // Features common to lldb-platform and llgs.
828 uint32_t max_packet_size = 128 * 1024; // 128KBytes is a reasonable max packet
829 // size--debugger can always use less
830 response.Printf("PacketSize=%x", max_packet_size);
832 response.PutCString(";QStartNoAckMode+");
833 response.PutCString(";QThreadSuffixSupported+");
834 response.PutCString(";QListThreadsInStopReply+");
835 response.PutCString(";qEcho+");
836 #if defined(__linux__) || defined(__NetBSD__)
837 response.PutCString(";QPassSignals+");
838 response.PutCString(";qXfer:auxv:read+");
841 return SendPacketNoLock(response.GetString());
844 GDBRemoteCommunication::PacketResult
845 GDBRemoteCommunicationServerCommon::Handle_QThreadSuffixSupported(
846 StringExtractorGDBRemote &packet) {
847 m_thread_suffix_supported = true;
848 return SendOKResponse();
851 GDBRemoteCommunication::PacketResult
852 GDBRemoteCommunicationServerCommon::Handle_QListThreadsInStopReply(
853 StringExtractorGDBRemote &packet) {
854 m_list_threads_in_stop_reply = true;
855 return SendOKResponse();
858 GDBRemoteCommunication::PacketResult
859 GDBRemoteCommunicationServerCommon::Handle_QSetDetachOnError(
860 StringExtractorGDBRemote &packet) {
861 packet.SetFilePos(::strlen("QSetDetachOnError:"));
862 if (packet.GetU32(0))
863 m_process_launch_info.GetFlags().Set(eLaunchFlagDetachOnError);
865 m_process_launch_info.GetFlags().Clear(eLaunchFlagDetachOnError);
866 return SendOKResponse();
869 GDBRemoteCommunication::PacketResult
870 GDBRemoteCommunicationServerCommon::Handle_QStartNoAckMode(
871 StringExtractorGDBRemote &packet) {
872 // Send response first before changing m_send_acks to we ack this packet
873 PacketResult packet_result = SendOKResponse();
875 return packet_result;
878 GDBRemoteCommunication::PacketResult
879 GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN(
880 StringExtractorGDBRemote &packet) {
881 packet.SetFilePos(::strlen("QSetSTDIN:"));
882 FileAction file_action;
884 packet.GetHexByteString(path);
885 const bool read = true;
886 const bool write = false;
887 if (file_action.Open(STDIN_FILENO, FileSpec{path, false}, read, write)) {
888 m_process_launch_info.AppendFileAction(file_action);
889 return SendOKResponse();
891 return SendErrorResponse(15);
894 GDBRemoteCommunication::PacketResult
895 GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT(
896 StringExtractorGDBRemote &packet) {
897 packet.SetFilePos(::strlen("QSetSTDOUT:"));
898 FileAction file_action;
900 packet.GetHexByteString(path);
901 const bool read = false;
902 const bool write = true;
903 if (file_action.Open(STDOUT_FILENO, FileSpec{path, false}, read, write)) {
904 m_process_launch_info.AppendFileAction(file_action);
905 return SendOKResponse();
907 return SendErrorResponse(16);
910 GDBRemoteCommunication::PacketResult
911 GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR(
912 StringExtractorGDBRemote &packet) {
913 packet.SetFilePos(::strlen("QSetSTDERR:"));
914 FileAction file_action;
916 packet.GetHexByteString(path);
917 const bool read = false;
918 const bool write = true;
919 if (file_action.Open(STDERR_FILENO, FileSpec{path, false}, read, write)) {
920 m_process_launch_info.AppendFileAction(file_action);
921 return SendOKResponse();
923 return SendErrorResponse(17);
926 GDBRemoteCommunication::PacketResult
927 GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess(
928 StringExtractorGDBRemote &packet) {
929 if (m_process_launch_error.Success())
930 return SendOKResponse();
931 StreamString response;
932 response.PutChar('E');
933 response.PutCString(m_process_launch_error.AsCString("<unknown error>"));
934 return SendPacketNoLock(response.GetString());
937 GDBRemoteCommunication::PacketResult
938 GDBRemoteCommunicationServerCommon::Handle_QEnvironment(
939 StringExtractorGDBRemote &packet) {
940 packet.SetFilePos(::strlen("QEnvironment:"));
941 const uint32_t bytes_left = packet.GetBytesLeft();
942 if (bytes_left > 0) {
943 m_process_launch_info.GetEnvironment().insert(packet.Peek());
944 return SendOKResponse();
946 return SendErrorResponse(12);
949 GDBRemoteCommunication::PacketResult
950 GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded(
951 StringExtractorGDBRemote &packet) {
952 packet.SetFilePos(::strlen("QEnvironmentHexEncoded:"));
953 const uint32_t bytes_left = packet.GetBytesLeft();
954 if (bytes_left > 0) {
956 packet.GetHexByteString(str);
957 m_process_launch_info.GetEnvironment().insert(str);
958 return SendOKResponse();
960 return SendErrorResponse(12);
963 GDBRemoteCommunication::PacketResult
964 GDBRemoteCommunicationServerCommon::Handle_QLaunchArch(
965 StringExtractorGDBRemote &packet) {
966 packet.SetFilePos(::strlen("QLaunchArch:"));
967 const uint32_t bytes_left = packet.GetBytesLeft();
968 if (bytes_left > 0) {
969 const char *arch_triple = packet.Peek();
970 m_process_launch_info.SetArchitecture(HostInfo::GetAugmentedArchSpec(arch_triple));
971 return SendOKResponse();
973 return SendErrorResponse(13);
976 GDBRemoteCommunication::PacketResult
977 GDBRemoteCommunicationServerCommon::Handle_A(StringExtractorGDBRemote &packet) {
978 // The 'A' packet is the most over designed packet ever here with redundant
979 // argument indexes, redundant argument lengths and needed hex encoded
980 // argument string values. Really all that is needed is a comma separated hex
981 // encoded argument value list, but we will stay true to the documented
982 // version of the 'A' packet here...
984 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
985 int actual_arg_index = 0;
987 packet.SetFilePos(1); // Skip the 'A'
989 while (success && packet.GetBytesLeft() > 0) {
990 // Decode the decimal argument string length. This length is the number of
991 // hex nibbles in the argument string value.
992 const uint32_t arg_len = packet.GetU32(UINT32_MAX);
993 if (arg_len == UINT32_MAX)
996 // Make sure the argument hex string length is followed by a comma
997 if (packet.GetChar() != ',')
1000 // Decode the argument index. We ignore this really because who would
1001 // really send down the arguments in a random order???
1002 const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
1003 if (arg_idx == UINT32_MAX)
1006 // Make sure the argument index is followed by a comma
1007 if (packet.GetChar() != ',')
1010 // Decode the argument string value from hex bytes back into a UTF8
1011 // string and make sure the length matches the one supplied in the
1014 if (packet.GetHexByteStringFixedLength(arg, arg_len) !=
1018 // If there are any bytes left
1019 if (packet.GetBytesLeft()) {
1020 if (packet.GetChar() != ',')
1026 m_process_launch_info.GetExecutableFile().SetFile(
1027 arg, false, FileSpec::Style::native);
1028 m_process_launch_info.GetArguments().AppendArgument(arg);
1030 log->Printf("LLGSPacketHandler::%s added arg %d: \"%s\"",
1031 __FUNCTION__, actual_arg_index, arg.c_str());
1042 m_process_launch_error = LaunchProcess();
1043 if (m_process_launch_error.Success())
1044 return SendOKResponse();
1045 LLDB_LOG(log, "failed to launch exe: {0}", m_process_launch_error);
1047 return SendErrorResponse(8);
1050 GDBRemoteCommunication::PacketResult
1051 GDBRemoteCommunicationServerCommon::Handle_qEcho(
1052 StringExtractorGDBRemote &packet) {
1053 // Just echo back the exact same packet for qEcho...
1054 return SendPacketNoLock(packet.GetStringRef());
1057 GDBRemoteCommunication::PacketResult
1058 GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
1059 StringExtractorGDBRemote &packet) {
1060 packet.SetFilePos(::strlen("qModuleInfo:"));
1062 std::string module_path;
1063 packet.GetHexByteStringTerminatedBy(module_path, ';');
1064 if (module_path.empty())
1065 return SendErrorResponse(1);
1067 if (packet.GetChar() != ';')
1068 return SendErrorResponse(2);
1071 packet.GetHexByteString(triple);
1073 ModuleSpec matched_module_spec = GetModuleInfo(module_path, triple);
1074 if (!matched_module_spec.GetFileSpec())
1075 return SendErrorResponse(3);
1077 const auto file_offset = matched_module_spec.GetObjectOffset();
1078 const auto file_size = matched_module_spec.GetObjectSize();
1079 const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1081 StreamGDBRemote response;
1083 if (uuid_str.empty()) {
1084 auto Result = llvm::sys::fs::md5_contents(matched_module_spec.GetFileSpec().GetPath());
1086 return SendErrorResponse(5);
1087 response.PutCString("md5:");
1088 response.PutCStringAsRawHex8(Result->digest().c_str());
1090 response.PutCString("uuid:");
1091 response.PutCStringAsRawHex8(uuid_str.c_str());
1093 response.PutChar(';');
1095 const auto &module_arch = matched_module_spec.GetArchitecture();
1096 response.PutCString("triple:");
1097 response.PutCStringAsRawHex8(module_arch.GetTriple().getTriple().c_str());
1098 response.PutChar(';');
1100 response.PutCString("file_path:");
1101 response.PutCStringAsRawHex8(matched_module_spec.GetFileSpec().GetCString());
1102 response.PutChar(';');
1103 response.PutCString("file_offset:");
1104 response.PutHex64(file_offset);
1105 response.PutChar(';');
1106 response.PutCString("file_size:");
1107 response.PutHex64(file_size);
1108 response.PutChar(';');
1110 return SendPacketNoLock(response.GetString());
1113 GDBRemoteCommunication::PacketResult
1114 GDBRemoteCommunicationServerCommon::Handle_jModulesInfo(
1115 StringExtractorGDBRemote &packet) {
1116 packet.SetFilePos(::strlen("jModulesInfo:"));
1118 StructuredData::ObjectSP object_sp = StructuredData::ParseJSON(packet.Peek());
1120 return SendErrorResponse(1);
1122 StructuredData::Array *packet_array = object_sp->GetAsArray();
1124 return SendErrorResponse(2);
1126 JSONArray::SP response_array_sp = std::make_shared<JSONArray>();
1127 for (size_t i = 0; i < packet_array->GetSize(); ++i) {
1128 StructuredData::Dictionary *query =
1129 packet_array->GetItemAtIndex(i)->GetAsDictionary();
1132 llvm::StringRef file, triple;
1133 if (!query->GetValueForKeyAsString("file", file) ||
1134 !query->GetValueForKeyAsString("triple", triple))
1137 ModuleSpec matched_module_spec = GetModuleInfo(file, triple);
1138 if (!matched_module_spec.GetFileSpec())
1141 const auto file_offset = matched_module_spec.GetObjectOffset();
1142 const auto file_size = matched_module_spec.GetObjectSize();
1143 const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1145 if (uuid_str.empty())
1148 JSONObject::SP response = std::make_shared<JSONObject>();
1149 response_array_sp->AppendObject(response);
1150 response->SetObject("uuid", std::make_shared<JSONString>(uuid_str));
1151 response->SetObject(
1153 std::make_shared<JSONString>(
1154 matched_module_spec.GetArchitecture().GetTriple().getTriple()));
1155 response->SetObject("file_path",
1156 std::make_shared<JSONString>(
1157 matched_module_spec.GetFileSpec().GetPath()));
1158 response->SetObject("file_offset",
1159 std::make_shared<JSONNumber>(file_offset));
1160 response->SetObject("file_size", std::make_shared<JSONNumber>(file_size));
1163 StreamString response;
1164 response_array_sp->Write(response);
1165 StreamGDBRemote escaped_response;
1166 escaped_response.PutEscapedBytes(response.GetString().data(),
1167 response.GetSize());
1168 return SendPacketNoLock(escaped_response.GetString());
1171 void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse(
1172 const ProcessInstanceInfo &proc_info, StreamString &response) {
1174 "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
1175 proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1176 proc_info.GetUserID(), proc_info.GetGroupID(),
1177 proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
1178 response.PutCString("name:");
1179 response.PutCStringAsRawHex8(proc_info.GetExecutableFile().GetCString());
1180 response.PutChar(';');
1181 const ArchSpec &proc_arch = proc_info.GetArchitecture();
1182 if (proc_arch.IsValid()) {
1183 const llvm::Triple &proc_triple = proc_arch.GetTriple();
1184 response.PutCString("triple:");
1185 response.PutCStringAsRawHex8(proc_triple.getTriple().c_str());
1186 response.PutChar(';');
1190 void GDBRemoteCommunicationServerCommon::
1191 CreateProcessInfoResponse_DebugServerStyle(
1192 const ProcessInstanceInfo &proc_info, StreamString &response) {
1193 response.Printf("pid:%" PRIx64 ";parent-pid:%" PRIx64
1194 ";real-uid:%x;real-gid:%x;effective-uid:%x;effective-gid:%x;",
1195 proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1196 proc_info.GetUserID(), proc_info.GetGroupID(),
1197 proc_info.GetEffectiveUserID(),
1198 proc_info.GetEffectiveGroupID());
1200 const ArchSpec &proc_arch = proc_info.GetArchitecture();
1201 if (proc_arch.IsValid()) {
1202 const llvm::Triple &proc_triple = proc_arch.GetTriple();
1203 #if defined(__APPLE__)
1204 // We'll send cputype/cpusubtype.
1205 const uint32_t cpu_type = proc_arch.GetMachOCPUType();
1207 response.Printf("cputype:%" PRIx32 ";", cpu_type);
1209 const uint32_t cpu_subtype = proc_arch.GetMachOCPUSubType();
1210 if (cpu_subtype != 0)
1211 response.Printf("cpusubtype:%" PRIx32 ";", cpu_subtype);
1213 const std::string vendor = proc_triple.getVendorName();
1214 if (!vendor.empty())
1215 response.Printf("vendor:%s;", vendor.c_str());
1217 // We'll send the triple.
1218 response.PutCString("triple:");
1219 response.PutCStringAsRawHex8(proc_triple.getTriple().c_str());
1220 response.PutChar(';');
1222 std::string ostype = proc_triple.getOSName();
1223 // Adjust so ostype reports ios for Apple/ARM and Apple/ARM64.
1224 if (proc_triple.getVendor() == llvm::Triple::Apple) {
1225 switch (proc_triple.getArch()) {
1226 case llvm::Triple::arm:
1227 case llvm::Triple::thumb:
1228 case llvm::Triple::aarch64:
1236 response.Printf("ostype:%s;", ostype.c_str());
1238 switch (proc_arch.GetByteOrder()) {
1239 case lldb::eByteOrderLittle:
1240 response.PutCString("endian:little;");
1242 case lldb::eByteOrderBig:
1243 response.PutCString("endian:big;");
1245 case lldb::eByteOrderPDP:
1246 response.PutCString("endian:pdp;");
1252 // In case of MIPS64, pointer size is depend on ELF ABI For N32 the pointer
1253 // size is 4 and for N64 it is 8
1254 std::string abi = proc_arch.GetTargetABI();
1256 response.Printf("elf_abi:%s;", abi.c_str());
1257 response.Printf("ptrsize:%d;", proc_arch.GetAddressByteSize());
1261 FileSpec GDBRemoteCommunicationServerCommon::FindModuleFile(
1262 const std::string &module_path, const ArchSpec &arch) {
1264 return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
1266 return FileSpec(module_path, true);
1271 GDBRemoteCommunicationServerCommon::GetModuleInfo(llvm::StringRef module_path,
1272 llvm::StringRef triple) {
1273 ArchSpec arch(triple);
1275 const FileSpec req_module_path_spec(module_path, true);
1276 const FileSpec module_path_spec =
1277 FindModuleFile(req_module_path_spec.GetPath(), arch);
1278 const ModuleSpec module_spec(module_path_spec, arch);
1280 ModuleSpecList module_specs;
1281 if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
1283 return ModuleSpec();
1285 ModuleSpec matched_module_spec;
1286 if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
1287 return ModuleSpec();
1289 return matched_module_spec;