Bug Summary

File:tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
Warning:line 3285, column 7
Value stored to 'error_string' is never read

Annotated Source Code

1//===-- ProcessGDBRemote.cpp ------------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Host/Config.h"
11
12// C Includes
13#include <errno(*__errno_location ()).h>
14#include <stdlib.h>
15#ifndef LLDB_DISABLE_POSIX
16#include <netinet/in.h>
17#include <sys/mman.h> // for mmap
18#include <sys/socket.h>
19#endif
20#include <sys/stat.h>
21#include <sys/types.h>
22#include <time.h>
23
24// C++ Includes
25#include <algorithm>
26#include <map>
27#include <mutex>
28#include <sstream>
29
30#include "lldb/Breakpoint/Watchpoint.h"
31#include "lldb/Core/ArchSpec.h"
32#include "lldb/Core/Debugger.h"
33#include "lldb/Core/Module.h"
34#include "lldb/Core/ModuleSpec.h"
35#include "lldb/Core/PluginManager.h"
36#include "lldb/Core/State.h"
37#include "lldb/Core/StreamFile.h"
38#include "lldb/Core/Timer.h"
39#include "lldb/Core/Value.h"
40#include "lldb/DataFormatters/FormatManager.h"
41#include "lldb/Host/ConnectionFileDescriptor.h"
42#include "lldb/Host/FileSystem.h"
43#include "lldb/Host/HostThread.h"
44#include "lldb/Host/PseudoTerminal.h"
45#include "lldb/Host/StringConvert.h"
46#include "lldb/Host/Symbols.h"
47#include "lldb/Host/ThreadLauncher.h"
48#include "lldb/Host/XML.h"
49#include "lldb/Interpreter/Args.h"
50#include "lldb/Interpreter/CommandInterpreter.h"
51#include "lldb/Interpreter/CommandObject.h"
52#include "lldb/Interpreter/CommandObjectMultiword.h"
53#include "lldb/Interpreter/CommandReturnObject.h"
54#include "lldb/Interpreter/OptionGroupBoolean.h"
55#include "lldb/Interpreter/OptionGroupUInt64.h"
56#include "lldb/Interpreter/OptionValueProperties.h"
57#include "lldb/Interpreter/Options.h"
58#include "lldb/Interpreter/Property.h"
59#include "lldb/Symbol/ObjectFile.h"
60#include "lldb/Target/ABI.h"
61#include "lldb/Target/DynamicLoader.h"
62#include "lldb/Target/SystemRuntime.h"
63#include "lldb/Target/Target.h"
64#include "lldb/Target/TargetList.h"
65#include "lldb/Target/ThreadPlanCallFunction.h"
66#include "lldb/Utility/CleanUp.h"
67#include "lldb/Utility/FileSpec.h"
68#include "lldb/Utility/StreamString.h"
69
70// Project includes
71#include "GDBRemoteRegisterContext.h"
72#include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
73#include "Plugins/Process/Utility/GDBRemoteSignals.h"
74#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
75#include "Plugins/Process/Utility/StopInfoMachException.h"
76#include "ProcessGDBRemote.h"
77#include "ProcessGDBRemoteLog.h"
78#include "ThreadGDBRemote.h"
79#include "Utility/StringExtractorGDBRemote.h"
80#include "lldb/Host/Host.h"
81
82#include "llvm/ADT/StringSwitch.h"
83#include "llvm/Support/Threading.h"
84#include "llvm/Support/raw_ostream.h"
85
86#define DEBUGSERVER_BASENAME"debugserver" "debugserver"
87using namespace lldb;
88using namespace lldb_private;
89using namespace lldb_private::process_gdb_remote;
90
91namespace lldb {
92// Provide a function that can easily dump the packet history if we know a
93// ProcessGDBRemote * value (which we can get from logs or from debugging).
94// We need the function in the lldb namespace so it makes it into the final
95// executable since the LLDB shared library only exports stuff in the lldb
96// namespace. This allows you to attach with a debugger and call this
97// function and get the packet history dumped to a file.
98void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
99 StreamFile strm;
100 Status error(strm.GetFile().Open(path, File::eOpenOptionWrite |
101 File::eOpenOptionCanCreate));
102 if (error.Success())
103 ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(strm);
104}
105}
106
107namespace {
108
109static PropertyDefinition g_properties[] = {
110 {"packet-timeout", OptionValue::eTypeUInt64, true, 1, NULL__null, NULL__null,
111 "Specify the default packet timeout in seconds."},
112 {"target-definition-file", OptionValue::eTypeFileSpec, true, 0, NULL__null, NULL__null,
113 "The file that provides the description for remote target registers."},
114 {NULL__null, OptionValue::eTypeInvalid, false, 0, NULL__null, NULL__null, NULL__null}};
115
116enum { ePropertyPacketTimeout, ePropertyTargetDefinitionFile };
117
118class PluginProperties : public Properties {
119public:
120 static ConstString GetSettingName() {
121 return ProcessGDBRemote::GetPluginNameStatic();
122 }
123
124 PluginProperties() : Properties() {
125 m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
126 m_collection_sp->Initialize(g_properties);
127 }
128
129 virtual ~PluginProperties() {}
130
131 uint64_t GetPacketTimeout() {
132 const uint32_t idx = ePropertyPacketTimeout;
133 return m_collection_sp->GetPropertyAtIndexAsUInt64(
134 NULL__null, idx, g_properties[idx].default_uint_value);
135 }
136
137 bool SetPacketTimeout(uint64_t timeout) {
138 const uint32_t idx = ePropertyPacketTimeout;
139 return m_collection_sp->SetPropertyAtIndexAsUInt64(NULL__null, idx, timeout);
140 }
141
142 FileSpec GetTargetDefinitionFile() const {
143 const uint32_t idx = ePropertyTargetDefinitionFile;
144 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL__null, idx);
145 }
146};
147
148typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP;
149
150static const ProcessKDPPropertiesSP &GetGlobalPluginProperties() {
151 static ProcessKDPPropertiesSP g_settings_sp;
152 if (!g_settings_sp)
153 g_settings_sp.reset(new PluginProperties());
154 return g_settings_sp;
155}
156
157} // anonymous namespace end
158
159// TODO Randomly assigning a port is unsafe. We should get an unused
160// ephemeral port from the kernel and make sure we reserve it before passing
161// it to debugserver.
162
163#if defined(__APPLE__)
164#define LOW_PORT(1024u) (IPPORT_RESERVED)
165#define HIGH_PORT(49151u) (IPPORT_HIFIRSTAUTO)
166#else
167#define LOW_PORT(1024u) (1024u)
168#define HIGH_PORT(49151u) (49151u)
169#endif
170
171#if defined(__APPLE__) && \
172 (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
173static bool rand_initialized = false;
174
175static inline uint16_t get_random_port() {
176 if (!rand_initialized) {
177 time_t seed = time(NULL__null);
178
179 rand_initialized = true;
180 srand(seed);
181 }
182 return (rand() % (HIGH_PORT(49151u) - LOW_PORT(1024u))) + LOW_PORT(1024u);
183}
184#endif
185
186ConstString ProcessGDBRemote::GetPluginNameStatic() {
187 static ConstString g_name("gdb-remote");
188 return g_name;
189}
190
191const char *ProcessGDBRemote::GetPluginDescriptionStatic() {
192 return "GDB Remote protocol based debugging plug-in.";
193}
194
195void ProcessGDBRemote::Terminate() {
196 PluginManager::UnregisterPlugin(ProcessGDBRemote::CreateInstance);
197}
198
199lldb::ProcessSP
200ProcessGDBRemote::CreateInstance(lldb::TargetSP target_sp,
201 ListenerSP listener_sp,
202 const FileSpec *crash_file_path) {
203 lldb::ProcessSP process_sp;
204 if (crash_file_path == NULL__null)
205 process_sp.reset(new ProcessGDBRemote(target_sp, listener_sp));
206 return process_sp;
207}
208
209bool ProcessGDBRemote::CanDebug(lldb::TargetSP target_sp,
210 bool plugin_specified_by_name) {
211 if (plugin_specified_by_name)
212 return true;
213
214 // For now we are just making sure the file exists for a given module
215 Module *exe_module = target_sp->GetExecutableModulePointer();
216 if (exe_module) {
217 ObjectFile *exe_objfile = exe_module->GetObjectFile();
218 // We can't debug core files...
219 switch (exe_objfile->GetType()) {
220 case ObjectFile::eTypeInvalid:
221 case ObjectFile::eTypeCoreFile:
222 case ObjectFile::eTypeDebugInfo:
223 case ObjectFile::eTypeObjectFile:
224 case ObjectFile::eTypeSharedLibrary:
225 case ObjectFile::eTypeStubLibrary:
226 case ObjectFile::eTypeJIT:
227 return false;
228 case ObjectFile::eTypeExecutable:
229 case ObjectFile::eTypeDynamicLinker:
230 case ObjectFile::eTypeUnknown:
231 break;
232 }
233 return exe_module->GetFileSpec().Exists();
234 }
235 // However, if there is no executable module, we return true since we might be
236 // preparing to attach.
237 return true;
238}
239
240//----------------------------------------------------------------------
241// ProcessGDBRemote constructor
242//----------------------------------------------------------------------
243ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp,
244 ListenerSP listener_sp)
245 : Process(target_sp, listener_sp), m_flags(0), m_gdb_comm(),
246 m_debugserver_pid(LLDB_INVALID_PROCESS_ID0), m_last_stop_packet_mutex(),
247 m_register_info(),
248 m_async_broadcaster(NULL__null, "lldb.process.gdb-remote.async-broadcaster"),
249 m_async_listener_sp(
250 Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
251 m_async_thread_state_mutex(), m_thread_ids(), m_thread_pcs(),
252 m_jstopinfo_sp(), m_jthreadsinfo_sp(), m_continue_c_tids(),
253 m_continue_C_tids(), m_continue_s_tids(), m_continue_S_tids(),
254 m_max_memory_size(0), m_remote_stub_max_memory_size(0),
255 m_addr_to_mmap_size(), m_thread_create_bp_sp(),
256 m_waiting_for_attach(false), m_destroy_tried_resuming(false),
257 m_command_sp(), m_breakpoint_pc_offset(0),
258 m_initial_tid(LLDB_INVALID_THREAD_ID0) {
259 m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit,
260 "async thread should exit");
261 m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue,
262 "async thread continue");
263 m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadDidExit,
264 "async thread did exit");
265
266 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_ASYNC(1u << 11)));
267
268 const uint32_t async_event_mask =
269 eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
270
271 if (m_async_listener_sp->StartListeningForEvents(
272 &m_async_broadcaster, async_event_mask) != async_event_mask) {
273 if (log)
274 log->Printf("ProcessGDBRemote::%s failed to listen for "
275 "m_async_broadcaster events",
276 __FUNCTION__);
277 }
278
279 const uint32_t gdb_event_mask =
280 Communication::eBroadcastBitReadThreadDidExit |
281 GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify;
282 if (m_async_listener_sp->StartListeningForEvents(
283 &m_gdb_comm, gdb_event_mask) != gdb_event_mask) {
284 if (log)
285 log->Printf("ProcessGDBRemote::%s failed to listen for m_gdb_comm 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}
294
295//----------------------------------------------------------------------
296// Destructor
297//----------------------------------------------------------------------
298ProcessGDBRemote::~ProcessGDBRemote() {
299 // m_mach_process.UnregisterNotificationCallbacks (this);
300 Clear();
301 // We need to call finalize on the process before destroying ourselves
302 // to make sure all of the broadcaster cleanup goes as planned. If we
303 // destruct this class, then Process::~Process() might have problems
304 // trying to fully destroy the broadcaster.
305 Finalize();
306
307 // The general Finalize is going to try to destroy the process and that SHOULD
308 // shut down the async thread. However, if we don't kill it it will get
309 // stranded and
310 // its connection will go away so when it wakes up it will crash. So kill it
311 // for sure here.
312 StopAsyncThread();
313 KillDebugserverProcess();
314}
315
316//----------------------------------------------------------------------
317// PluginInterface
318//----------------------------------------------------------------------
319ConstString ProcessGDBRemote::GetPluginName() { return GetPluginNameStatic(); }
320
321uint32_t ProcessGDBRemote::GetPluginVersion() { return 1; }
322
323bool ProcessGDBRemote::ParsePythonTargetDefinition(
324 const FileSpec &target_definition_fspec) {
325 ScriptInterpreter *interpreter =
326 GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
327 Status error;
328 StructuredData::ObjectSP module_object_sp(
329 interpreter->LoadPluginModule(target_definition_fspec, error));
330 if (module_object_sp) {
331 StructuredData::DictionarySP target_definition_sp(
332 interpreter->GetDynamicSettings(module_object_sp, &GetTarget(),
333 "gdb-server-target-definition", error));
334
335 if (target_definition_sp) {
336 StructuredData::ObjectSP target_object(
337 target_definition_sp->GetValueForKey("host-info"));
338 if (target_object) {
339 if (auto host_info_dict = target_object->GetAsDictionary()) {
340 StructuredData::ObjectSP triple_value =
341 host_info_dict->GetValueForKey("triple");
342 if (auto triple_string_value = triple_value->GetAsString()) {
343 std::string triple_string = triple_string_value->GetValue();
344 ArchSpec host_arch(triple_string.c_str());
345 if (!host_arch.IsCompatibleMatch(GetTarget().GetArchitecture())) {
346 GetTarget().SetArchitecture(host_arch);
347 }
348 }
349 }
350 }
351 m_breakpoint_pc_offset = 0;
352 StructuredData::ObjectSP breakpoint_pc_offset_value =
353 target_definition_sp->GetValueForKey("breakpoint-pc-offset");
354 if (breakpoint_pc_offset_value) {
355 if (auto breakpoint_pc_int_value =
356 breakpoint_pc_offset_value->GetAsInteger())
357 m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue();
358 }
359
360 if (m_register_info.SetRegisterInfo(*target_definition_sp,
361 GetTarget().GetArchitecture()) > 0) {
362 return true;
363 }
364 }
365 }
366 return false;
367}
368
369// If the remote stub didn't give us eh_frame or DWARF register numbers for a
370// register,
371// see if the ABI can provide them.
372// DWARF and eh_frame register numbers are defined as a part of the ABI.
373static void AugmentRegisterInfoViaABI(RegisterInfo &reg_info,
374 ConstString reg_name, ABISP abi_sp) {
375 if (reg_info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM(4294967295U) ||
376 reg_info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM(4294967295U)) {
377 if (abi_sp) {
378 RegisterInfo abi_reg_info;
379 if (abi_sp->GetRegisterInfoByName(reg_name, abi_reg_info)) {
380 if (reg_info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM(4294967295U) &&
381 abi_reg_info.kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM(4294967295U)) {
382 reg_info.kinds[eRegisterKindEHFrame] =
383 abi_reg_info.kinds[eRegisterKindEHFrame];
384 }
385 if (reg_info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM(4294967295U) &&
386 abi_reg_info.kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM(4294967295U)) {
387 reg_info.kinds[eRegisterKindDWARF] =
388 abi_reg_info.kinds[eRegisterKindDWARF];
389 }
390 if (reg_info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM(4294967295U) &&
391 abi_reg_info.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM(4294967295U)) {
392 reg_info.kinds[eRegisterKindGeneric] =
393 abi_reg_info.kinds[eRegisterKindGeneric];
394 }
395 }
396 }
397 }
398}
399
400static size_t SplitCommaSeparatedRegisterNumberString(
401 const llvm::StringRef &comma_separated_regiter_numbers,
402 std::vector<uint32_t> &regnums, int base) {
403 regnums.clear();
404 std::pair<llvm::StringRef, llvm::StringRef> value_pair;
405 value_pair.second = comma_separated_regiter_numbers;
406 do {
407 value_pair = value_pair.second.split(',');
408 if (!value_pair.first.empty()) {
409 uint32_t reg = StringConvert::ToUInt32(value_pair.first.str().c_str(),
410 LLDB_INVALID_REGNUM(4294967295U), base);
411 if (reg != LLDB_INVALID_REGNUM(4294967295U))
412 regnums.push_back(reg);
413 }
414 } while (!value_pair.second.empty());
415 return regnums.size();
416}
417
418void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
419 if (!force && m_register_info.GetNumRegisters() > 0)
420 return;
421
422 m_register_info.Clear();
423
424 // Check if qHostInfo specified a specific packet timeout for this connection.
425 // If so then lets update our setting so the user knows what the timeout is
426 // and can see it.
427 const auto host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
428 if (host_packet_timeout > std::chrono::seconds(0)) {
429 GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout.count());
430 }
431
432 // Register info search order:
433 // 1 - Use the target definition python file if one is specified.
434 // 2 - If the target definition doesn't have any of the info from the
435 // target.xml (registers) then proceed to read the target.xml.
436 // 3 - Fall back on the qRegisterInfo packets.
437
438 FileSpec target_definition_fspec =
439 GetGlobalPluginProperties()->GetTargetDefinitionFile();
440 if (!target_definition_fspec.Exists()) {
441 // If the filename doesn't exist, it may be a ~ not having been expanded -
442 // try to resolve it.
443 target_definition_fspec.ResolvePath();
444 }
445 if (target_definition_fspec) {
446 // See if we can get register definitions from a python file
447 if (ParsePythonTargetDefinition(target_definition_fspec)) {
448 return;
449 } else {
450 StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
451 stream_sp->Printf("ERROR: target description file %s failed to parse.\n",
452 target_definition_fspec.GetPath().c_str());
453 }
454 }
455
456 const ArchSpec &target_arch = GetTarget().GetArchitecture();
457 const ArchSpec &remote_host_arch = m_gdb_comm.GetHostArchitecture();
458 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
459
460 // Use the process' architecture instead of the host arch, if available
461 ArchSpec arch_to_use;
462 if (remote_process_arch.IsValid())
463 arch_to_use = remote_process_arch;
464 else
465 arch_to_use = remote_host_arch;
466
467 if (!arch_to_use.IsValid())
468 arch_to_use = target_arch;
469
470 if (GetGDBServerRegisterInfo(arch_to_use))
471 return;
472
473 char packet[128];
474 uint32_t reg_offset = 0;
475 uint32_t reg_num = 0;
476 for (StringExtractorGDBRemote::ResponseType response_type =
477 StringExtractorGDBRemote::eResponse;
478 response_type == StringExtractorGDBRemote::eResponse; ++reg_num) {
479 const int packet_len =
480 ::snprintf(packet, sizeof(packet), "qRegisterInfo%x", reg_num);
481 assert(packet_len < (int)sizeof(packet))((packet_len < (int)sizeof(packet)) ? static_cast<void>
(0) : __assert_fail ("packet_len < (int)sizeof(packet)", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 481, __PRETTY_FUNCTION__))
;
482 UNUSED_IF_ASSERT_DISABLED(packet_len)((void)(packet_len));
483 StringExtractorGDBRemote response;
484 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response, false) ==
485 GDBRemoteCommunication::PacketResult::Success) {
486 response_type = response.GetResponseType();
487 if (response_type == StringExtractorGDBRemote::eResponse) {
488 llvm::StringRef name;
489 llvm::StringRef value;
490 ConstString reg_name;
491 ConstString alt_name;
492 ConstString set_name;
493 std::vector<uint32_t> value_regs;
494 std::vector<uint32_t> invalidate_regs;
495 std::vector<uint8_t> dwarf_opcode_bytes;
496 RegisterInfo reg_info = {
497 NULL__null, // Name
498 NULL__null, // Alt name
499 0, // byte size
500 reg_offset, // offset
501 eEncodingUint, // encoding
502 eFormatHex, // format
503 {
504 LLDB_INVALID_REGNUM(4294967295U), // eh_frame reg num
505 LLDB_INVALID_REGNUM(4294967295U), // DWARF reg num
506 LLDB_INVALID_REGNUM(4294967295U), // generic reg num
507 reg_num, // process plugin reg num
508 reg_num // native register number
509 },
510 NULL__null,
511 NULL__null,
512 NULL__null, // Dwarf expression opcode bytes pointer
513 0 // Dwarf expression opcode bytes length
514 };
515
516 while (response.GetNameColonValue(name, value)) {
517 if (name.equals("name")) {
518 reg_name.SetString(value);
519 } else if (name.equals("alt-name")) {
520 alt_name.SetString(value);
521 } else if (name.equals("bitsize")) {
522 value.getAsInteger(0, reg_info.byte_size);
523 reg_info.byte_size /= CHAR_BIT8;
524 } else if (name.equals("offset")) {
525 if (value.getAsInteger(0, reg_offset))
526 reg_offset = UINT32_MAX(4294967295U);
527 } else if (name.equals("encoding")) {
528 const Encoding encoding = Args::StringToEncoding(value);
529 if (encoding != eEncodingInvalid)
530 reg_info.encoding = encoding;
531 } else if (name.equals("format")) {
532 Format format = eFormatInvalid;
533 if (Args::StringToFormat(value.str().c_str(), format, NULL__null)
534 .Success())
535 reg_info.format = format;
536 else {
537 reg_info.format =
538 llvm::StringSwitch<Format>(value)
539 .Case("binary", eFormatBinary)
540 .Case("decimal", eFormatDecimal)
541 .Case("hex", eFormatHex)
542 .Case("float", eFormatFloat)
543 .Case("vector-sint8", eFormatVectorOfSInt8)
544 .Case("vector-uint8", eFormatVectorOfUInt8)
545 .Case("vector-sint16", eFormatVectorOfSInt16)
546 .Case("vector-uint16", eFormatVectorOfUInt16)
547 .Case("vector-sint32", eFormatVectorOfSInt32)
548 .Case("vector-uint32", eFormatVectorOfUInt32)
549 .Case("vector-float32", eFormatVectorOfFloat32)
550 .Case("vector-uint64", eFormatVectorOfUInt64)
551 .Case("vector-uint128", eFormatVectorOfUInt128)
552 .Default(eFormatInvalid);
553 }
554 } else if (name.equals("set")) {
555 set_name.SetString(value);
556 } else if (name.equals("gcc") || name.equals("ehframe")) {
557 if (value.getAsInteger(0, reg_info.kinds[eRegisterKindEHFrame]))
558 reg_info.kinds[eRegisterKindEHFrame] = LLDB_INVALID_REGNUM(4294967295U);
559 } else if (name.equals("dwarf")) {
560 if (value.getAsInteger(0, reg_info.kinds[eRegisterKindDWARF]))
561 reg_info.kinds[eRegisterKindDWARF] = LLDB_INVALID_REGNUM(4294967295U);
562 } else if (name.equals("generic")) {
563 reg_info.kinds[eRegisterKindGeneric] =
564 Args::StringToGenericRegister(value);
565 } else if (name.equals("container-regs")) {
566 SplitCommaSeparatedRegisterNumberString(value, value_regs, 16);
567 } else if (name.equals("invalidate-regs")) {
568 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 16);
569 } else if (name.equals("dynamic_size_dwarf_expr_bytes")) {
570 size_t dwarf_opcode_len = value.size() / 2;
571 assert(dwarf_opcode_len > 0)((dwarf_opcode_len > 0) ? static_cast<void> (0) : __assert_fail
("dwarf_opcode_len > 0", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 571, __PRETTY_FUNCTION__))
;
572
573 dwarf_opcode_bytes.resize(dwarf_opcode_len);
574 reg_info.dynamic_size_dwarf_len = dwarf_opcode_len;
575
576 StringExtractor opcode_extractor(value);
577 uint32_t ret_val =
578 opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
579 assert(dwarf_opcode_len == ret_val)((dwarf_opcode_len == ret_val) ? static_cast<void> (0) :
__assert_fail ("dwarf_opcode_len == ret_val", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 579, __PRETTY_FUNCTION__))
;
580 UNUSED_IF_ASSERT_DISABLED(ret_val)((void)(ret_val));
581 reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data();
582 }
583 }
584
585 reg_info.byte_offset = reg_offset;
586 assert(reg_info.byte_size != 0)((reg_info.byte_size != 0) ? static_cast<void> (0) : __assert_fail
("reg_info.byte_size != 0", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 586, __PRETTY_FUNCTION__))
;
587 reg_offset += reg_info.byte_size;
588 if (!value_regs.empty()) {
589 value_regs.push_back(LLDB_INVALID_REGNUM(4294967295U));
590 reg_info.value_regs = value_regs.data();
591 }
592 if (!invalidate_regs.empty()) {
593 invalidate_regs.push_back(LLDB_INVALID_REGNUM(4294967295U));
594 reg_info.invalidate_regs = invalidate_regs.data();
595 }
596
597 // We have to make a temporary ABI here, and not use the GetABI because
598 // this code
599 // gets called in DidAttach, when the target architecture (and
600 // consequently the ABI we'll get from
601 // the process) may be wrong.
602 ABISP abi_to_use = ABI::FindPlugin(arch_to_use);
603
604 AugmentRegisterInfoViaABI(reg_info, reg_name, abi_to_use);
605
606 m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name);
607 } else {
608 break; // ensure exit before reg_num is incremented
609 }
610 } else {
611 break;
612 }
613 }
614
615 if (m_register_info.GetNumRegisters() > 0) {
616 m_register_info.Finalize(GetTarget().GetArchitecture());
617 return;
618 }
619
620 // We didn't get anything if the accumulated reg_num is zero. See if we are
621 // debugging ARM and fill with a hard coded register set until we can get an
622 // updated debugserver down on the devices.
623 // On the other hand, if the accumulated reg_num is positive, see if we can
624 // add composite registers to the existing primordial ones.
625 bool from_scratch = (m_register_info.GetNumRegisters() == 0);
626
627 if (!target_arch.IsValid()) {
628 if (arch_to_use.IsValid() &&
629 (arch_to_use.GetMachine() == llvm::Triple::arm ||
630 arch_to_use.GetMachine() == llvm::Triple::thumb) &&
631 arch_to_use.GetTriple().getVendor() == llvm::Triple::Apple)
632 m_register_info.HardcodeARMRegisters(from_scratch);
633 } else if (target_arch.GetMachine() == llvm::Triple::arm ||
634 target_arch.GetMachine() == llvm::Triple::thumb) {
635 m_register_info.HardcodeARMRegisters(from_scratch);
636 }
637
638 // At this point, we can finalize our register info.
639 m_register_info.Finalize(GetTarget().GetArchitecture());
640}
641
642Status ProcessGDBRemote::WillLaunch(Module *module) {
643 return WillLaunchOrAttach();
644}
645
646Status ProcessGDBRemote::WillAttachToProcessWithID(lldb::pid_t pid) {
647 return WillLaunchOrAttach();
648}
649
650Status ProcessGDBRemote::WillAttachToProcessWithName(const char *process_name,
651 bool wait_for_launch) {
652 return WillLaunchOrAttach();
653}
654
655Status ProcessGDBRemote::DoConnectRemote(Stream *strm,
656 llvm::StringRef remote_url) {
657 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
658 Status error(WillLaunchOrAttach());
659
660 if (error.Fail())
661 return error;
662
663 error = ConnectToDebugserver(remote_url);
664
665 if (error.Fail())
666 return error;
667 StartAsyncThread();
668
669 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
670 if (pid == LLDB_INVALID_PROCESS_ID0) {
671 // We don't have a valid process ID, so note that we are connected
672 // and could now request to launch or attach, or get remote process
673 // listings...
674 SetPrivateState(eStateConnected);
675 } else {
676 // We have a valid process
677 SetID(pid);
678 GetThreadList();
679 StringExtractorGDBRemote response;
680 if (m_gdb_comm.GetStopReply(response)) {
681 SetLastStopPacket(response);
682
683 // '?' Packets must be handled differently in non-stop mode
684 if (GetTarget().GetNonStopModeEnabled())
685 HandleStopReplySequence();
686
687 Target &target = GetTarget();
688 if (!target.GetArchitecture().IsValid()) {
689 if (m_gdb_comm.GetProcessArchitecture().IsValid()) {
690 target.SetArchitecture(m_gdb_comm.GetProcessArchitecture());
691 } else {
692 target.SetArchitecture(m_gdb_comm.GetHostArchitecture());
693 }
694 }
695
696 const StateType state = SetThreadStopInfo(response);
697 if (state != eStateInvalid) {
698 SetPrivateState(state);
699 } else
700 error.SetErrorStringWithFormat(
701 "Process %" PRIu64"l" "u" " was reported after connecting to "
702 "'%s', but state was not stopped: %s",
703 pid, remote_url.str().c_str(), StateAsCString(state));
704 } else
705 error.SetErrorStringWithFormat("Process %" PRIu64"l" "u"
706 " was reported after connecting to '%s', "
707 "but no stop reply packet was received",
708 pid, remote_url.str().c_str());
709 }
710
711 if (log)
712 log->Printf("ProcessGDBRemote::%s pid %" PRIu64"l" "u"
713 ": normalizing target architecture initial triple: %s "
714 "(GetTarget().GetArchitecture().IsValid() %s, "
715 "m_gdb_comm.GetHostArchitecture().IsValid(): %s)",
716 __FUNCTION__, GetID(),
717 GetTarget().GetArchitecture().GetTriple().getTriple().c_str(),
718 GetTarget().GetArchitecture().IsValid() ? "true" : "false",
719 m_gdb_comm.GetHostArchitecture().IsValid() ? "true" : "false");
720
721 if (error.Success() && !GetTarget().GetArchitecture().IsValid() &&
722 m_gdb_comm.GetHostArchitecture().IsValid()) {
723 // Prefer the *process'* architecture over that of the *host*, if available.
724 if (m_gdb_comm.GetProcessArchitecture().IsValid())
725 GetTarget().SetArchitecture(m_gdb_comm.GetProcessArchitecture());
726 else
727 GetTarget().SetArchitecture(m_gdb_comm.GetHostArchitecture());
728 }
729
730 if (log)
731 log->Printf("ProcessGDBRemote::%s pid %" PRIu64"l" "u"
732 ": normalized target architecture triple: %s",
733 __FUNCTION__, GetID(),
734 GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
735
736 if (error.Success()) {
737 PlatformSP platform_sp = GetTarget().GetPlatform();
738 if (platform_sp && platform_sp->IsConnected())
739 SetUnixSignals(platform_sp->GetUnixSignals());
740 else
741 SetUnixSignals(UnixSignals::Create(GetTarget().GetArchitecture()));
742 }
743
744 return error;
745}
746
747Status ProcessGDBRemote::WillLaunchOrAttach() {
748 Status error;
749 m_stdio_communication.Clear();
750 return error;
751}
752
753//----------------------------------------------------------------------
754// Process Control
755//----------------------------------------------------------------------
756Status ProcessGDBRemote::DoLaunch(Module *exe_module,
757 ProcessLaunchInfo &launch_info) {
758 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
759 Status error;
760
761 if (log)
762 log->Printf("ProcessGDBRemote::%s() entered", __FUNCTION__);
763
764 uint32_t launch_flags = launch_info.GetFlags().Get();
765 FileSpec stdin_file_spec{};
766 FileSpec stdout_file_spec{};
767 FileSpec stderr_file_spec{};
768 FileSpec working_dir = launch_info.GetWorkingDirectory();
769
770 const FileAction *file_action;
771 file_action = launch_info.GetFileActionForFD(STDIN_FILENO0);
772 if (file_action) {
773 if (file_action->GetAction() == FileAction::eFileActionOpen)
774 stdin_file_spec = file_action->GetFileSpec();
775 }
776 file_action = launch_info.GetFileActionForFD(STDOUT_FILENO1);
777 if (file_action) {
778 if (file_action->GetAction() == FileAction::eFileActionOpen)
779 stdout_file_spec = file_action->GetFileSpec();
780 }
781 file_action = launch_info.GetFileActionForFD(STDERR_FILENO2);
782 if (file_action) {
783 if (file_action->GetAction() == FileAction::eFileActionOpen)
784 stderr_file_spec = file_action->GetFileSpec();
785 }
786
787 if (log) {
788 if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
789 log->Printf("ProcessGDBRemote::%s provided with STDIO paths via "
790 "launch_info: stdin=%s, stdout=%s, stderr=%s",
791 __FUNCTION__,
792 stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
793 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
794 stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
795 else
796 log->Printf("ProcessGDBRemote::%s no STDIO paths given via launch_info",
797 __FUNCTION__);
798 }
799
800 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
801 if (stdin_file_spec || disable_stdio) {
802 // the inferior will be reading stdin from the specified file
803 // or stdio is completely disabled
804 m_stdin_forward = false;
805 } else {
806 m_stdin_forward = true;
807 }
808
809 // ::LogSetBitMask (GDBR_LOG_DEFAULT);
810 // ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE |
811 // LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
812 // LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
813 // ::LogSetLogFile ("/dev/stdout");
814
815 ObjectFile *object_file = exe_module->GetObjectFile();
816 if (object_file) {
817 error = EstablishConnectionIfNeeded(launch_info);
818 if (error.Success()) {
819 lldb_utility::PseudoTerminal pty;
820 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
821
822 PlatformSP platform_sp(GetTarget().GetPlatform());
823 if (disable_stdio) {
824 // set to /dev/null unless redirected to a file above
825 if (!stdin_file_spec)
826 stdin_file_spec.SetFile(FileSystem::DEV_NULL, false);
827 if (!stdout_file_spec)
828 stdout_file_spec.SetFile(FileSystem::DEV_NULL, false);
829 if (!stderr_file_spec)
830 stderr_file_spec.SetFile(FileSystem::DEV_NULL, false);
831 } else if (platform_sp && platform_sp->IsHost()) {
832 // If the debugserver is local and we aren't disabling STDIO, lets use
833 // a pseudo terminal to instead of relying on the 'O' packets for stdio
834 // since 'O' packets can really slow down debugging if the inferior
835 // does a lot of output.
836 if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
837 pty.OpenFirstAvailableMaster(O_RDWR02 | O_NOCTTY0400, NULL__null, 0)) {
838 FileSpec slave_name{pty.GetSlaveName(NULL__null, 0), false};
839
840 if (!stdin_file_spec)
841 stdin_file_spec = slave_name;
842
843 if (!stdout_file_spec)
844 stdout_file_spec = slave_name;
845
846 if (!stderr_file_spec)
847 stderr_file_spec = slave_name;
848 }
849 if (log)
850 log->Printf(
851 "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
852 "(IsHost() is true) using slave: stdin=%s, stdout=%s, stderr=%s",
853 __FUNCTION__,
854 stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
855 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
856 stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
857 }
858
859 if (log)
860 log->Printf("ProcessGDBRemote::%s final STDIO paths after all "
861 "adjustments: stdin=%s, stdout=%s, stderr=%s",
862 __FUNCTION__,
863 stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
864 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
865 stderr_file_spec ? stderr_file_spec.GetCString()
866 : "<null>");
867
868 if (stdin_file_spec)
869 m_gdb_comm.SetSTDIN(stdin_file_spec);
870 if (stdout_file_spec)
871 m_gdb_comm.SetSTDOUT(stdout_file_spec);
872 if (stderr_file_spec)
873 m_gdb_comm.SetSTDERR(stderr_file_spec);
874
875 m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
876 m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
877
878 m_gdb_comm.SendLaunchArchPacket(
879 GetTarget().GetArchitecture().GetArchitectureName());
880
881 const char *launch_event_data = launch_info.GetLaunchEventData();
882 if (launch_event_data != NULL__null && *launch_event_data != '\0')
883 m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
884
885 if (working_dir) {
886 m_gdb_comm.SetWorkingDir(working_dir);
887 }
888
889 // Send the environment and the program + arguments after we connect
890 const Args &environment = launch_info.GetEnvironmentEntries();
891 if (environment.GetArgumentCount()) {
892 size_t num_environment_entries = environment.GetArgumentCount();
893 for (size_t i = 0; i < num_environment_entries; ++i) {
894 const char *env_entry = environment.GetArgumentAtIndex(i);
895 if (env_entry == NULL__null ||
896 m_gdb_comm.SendEnvironmentPacket(env_entry) != 0)
897 break;
898 }
899 }
900
901 {
902 // Scope for the scoped timeout object
903 GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
904 std::chrono::seconds(10));
905
906 int arg_packet_err = m_gdb_comm.SendArgumentsPacket(launch_info);
907 if (arg_packet_err == 0) {
908 std::string error_str;
909 if (m_gdb_comm.GetLaunchSuccess(error_str)) {
910 SetID(m_gdb_comm.GetCurrentProcessID());
911 } else {
912 error.SetErrorString(error_str.c_str());
913 }
914 } else {
915 error.SetErrorStringWithFormat("'A' packet returned an error: %i",
916 arg_packet_err);
917 }
918 }
919
920 if (GetID() == LLDB_INVALID_PROCESS_ID0) {
921 if (log)
922 log->Printf("failed to connect to debugserver: %s",
923 error.AsCString());
924 KillDebugserverProcess();
925 return error;
926 }
927
928 StringExtractorGDBRemote response;
929 if (m_gdb_comm.GetStopReply(response)) {
930 SetLastStopPacket(response);
931 // '?' Packets must be handled differently in non-stop mode
932 if (GetTarget().GetNonStopModeEnabled())
933 HandleStopReplySequence();
934
935 const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
936
937 if (process_arch.IsValid()) {
938 GetTarget().MergeArchitecture(process_arch);
939 } else {
940 const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
941 if (host_arch.IsValid())
942 GetTarget().MergeArchitecture(host_arch);
943 }
944
945 SetPrivateState(SetThreadStopInfo(response));
946
947 if (!disable_stdio) {
948 if (pty.GetMasterFileDescriptor() !=
949 lldb_utility::PseudoTerminal::invalid_fd)
950 SetSTDIOFileDescriptor(pty.ReleaseMasterFileDescriptor());
951 }
952 }
953 } else {
954 if (log)
955 log->Printf("failed to connect to debugserver: %s", error.AsCString());
956 }
957 } else {
958 // Set our user ID to an invalid process ID.
959 SetID(LLDB_INVALID_PROCESS_ID0);
960 error.SetErrorStringWithFormat(
961 "failed to get object file from '%s' for arch %s",
962 exe_module->GetFileSpec().GetFilename().AsCString(),
963 exe_module->GetArchitecture().GetArchitectureName());
964 }
965 return error;
966}
967
968Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
969 Status error;
970 // Only connect if we have a valid connect URL
971 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
972
973 if (!connect_url.empty()) {
974 if (log)
975 log->Printf("ProcessGDBRemote::%s Connecting to %s", __FUNCTION__,
976 connect_url.str().c_str());
977 std::unique_ptr<ConnectionFileDescriptor> conn_ap(
978 new ConnectionFileDescriptor());
979 if (conn_ap.get()) {
980 const uint32_t max_retry_count = 50;
981 uint32_t retry_count = 0;
982 while (!m_gdb_comm.IsConnected()) {
983 if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess) {
984 m_gdb_comm.SetConnection(conn_ap.release());
985 break;
986 } else if (error.WasInterrupted()) {
987 // If we were interrupted, don't keep retrying.
988 break;
989 }
990
991 retry_count++;
992
993 if (retry_count >= max_retry_count)
994 break;
995
996 usleep(100000);
997 }
998 }
999 }
1000
1001 if (!m_gdb_comm.IsConnected()) {
1002 if (error.Success())
1003 error.SetErrorString("not connected to remote gdb server");
1004 return error;
1005 }
1006
1007 // Start the communications read thread so all incoming data can be
1008 // parsed into packets and queued as they arrive.
1009 if (GetTarget().GetNonStopModeEnabled())
1010 m_gdb_comm.StartReadThread();
1011
1012 // We always seem to be able to open a connection to a local port
1013 // so we need to make sure we can then send data to it. If we can't
1014 // then we aren't actually connected to anything, so try and do the
1015 // handshake with the remote GDB server and make sure that goes
1016 // alright.
1017 if (!m_gdb_comm.HandshakeWithServer(&error)) {
1018 m_gdb_comm.Disconnect();
1019 if (error.Success())
1020 error.SetErrorString("not connected to remote gdb server");
1021 return error;
1022 }
1023
1024 // Send $QNonStop:1 packet on startup if required
1025 if (GetTarget().GetNonStopModeEnabled())
1026 GetTarget().SetNonStopModeEnabled(m_gdb_comm.SetNonStopMode(true));
1027
1028 m_gdb_comm.GetEchoSupported();
1029 m_gdb_comm.GetThreadSuffixSupported();
1030 m_gdb_comm.GetListThreadsInStopReplySupported();
1031 m_gdb_comm.GetHostInfo();
1032 m_gdb_comm.GetVContSupported('c');
1033 m_gdb_comm.GetVAttachOrWaitSupported();
1034
1035 // Ask the remote server for the default thread id
1036 if (GetTarget().GetNonStopModeEnabled())
1037 m_gdb_comm.GetDefaultThreadId(m_initial_tid);
1038
1039 size_t num_cmds = GetExtraStartupCommands().GetArgumentCount();
1040 for (size_t idx = 0; idx < num_cmds; idx++) {
1041 StringExtractorGDBRemote response;
1042 m_gdb_comm.SendPacketAndWaitForResponse(
1043 GetExtraStartupCommands().GetArgumentAtIndex(idx), response, false);
1044 }
1045 return error;
1046}
1047
1048void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
1049 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
1050 if (log)
1051 log->Printf("ProcessGDBRemote::%s()", __FUNCTION__);
1052 if (GetID() != LLDB_INVALID_PROCESS_ID0) {
1053 BuildDynamicRegisterInfo(false);
1054
1055 // See if the GDB server supports the qHostInfo information
1056
1057 // See if the GDB server supports the qProcessInfo packet, if so
1058 // prefer that over the Host information as it will be more specific
1059 // to our process.
1060
1061 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
1062 if (remote_process_arch.IsValid()) {
1063 process_arch = remote_process_arch;
1064 if (log)
1065 log->Printf("ProcessGDBRemote::%s gdb-remote had process architecture, "
1066 "using %s %s",
1067 __FUNCTION__, process_arch.GetArchitectureName()
1068 ? process_arch.GetArchitectureName()
1069 : "<null>",
1070 process_arch.GetTriple().getTriple().c_str()
1071 ? process_arch.GetTriple().getTriple().c_str()
1072 : "<null>");
1073 } else {
1074 process_arch = m_gdb_comm.GetHostArchitecture();
1075 if (log)
1076 log->Printf("ProcessGDBRemote::%s gdb-remote did not have process "
1077 "architecture, using gdb-remote host architecture %s %s",
1078 __FUNCTION__, process_arch.GetArchitectureName()
1079 ? process_arch.GetArchitectureName()
1080 : "<null>",
1081 process_arch.GetTriple().getTriple().c_str()
1082 ? process_arch.GetTriple().getTriple().c_str()
1083 : "<null>");
1084 }
1085
1086 if (process_arch.IsValid()) {
1087 const ArchSpec &target_arch = GetTarget().GetArchitecture();
1088 if (target_arch.IsValid()) {
1089 if (log)
1090 log->Printf(
1091 "ProcessGDBRemote::%s analyzing target arch, currently %s %s",
1092 __FUNCTION__, target_arch.GetArchitectureName()
1093 ? target_arch.GetArchitectureName()
1094 : "<null>",
1095 target_arch.GetTriple().getTriple().c_str()
1096 ? target_arch.GetTriple().getTriple().c_str()
1097 : "<null>");
1098
1099 // If the remote host is ARM and we have apple as the vendor, then
1100 // ARM executables and shared libraries can have mixed ARM
1101 // architectures.
1102 // You can have an armv6 executable, and if the host is armv7, then the
1103 // system will load the best possible architecture for all shared
1104 // libraries
1105 // it has, so we really need to take the remote host architecture as our
1106 // defacto architecture in this case.
1107
1108 if ((process_arch.GetMachine() == llvm::Triple::arm ||
1109 process_arch.GetMachine() == llvm::Triple::thumb) &&
1110 process_arch.GetTriple().getVendor() == llvm::Triple::Apple) {
1111 GetTarget().SetArchitecture(process_arch);
1112 if (log)
1113 log->Printf("ProcessGDBRemote::%s remote process is ARM/Apple, "
1114 "setting target arch to %s %s",
1115 __FUNCTION__, process_arch.GetArchitectureName()
1116 ? process_arch.GetArchitectureName()
1117 : "<null>",
1118 process_arch.GetTriple().getTriple().c_str()
1119 ? process_arch.GetTriple().getTriple().c_str()
1120 : "<null>");
1121 } else {
1122 // Fill in what is missing in the triple
1123 const llvm::Triple &remote_triple = process_arch.GetTriple();
1124 llvm::Triple new_target_triple = target_arch.GetTriple();
1125 if (new_target_triple.getVendorName().size() == 0) {
1126 new_target_triple.setVendor(remote_triple.getVendor());
1127
1128 if (new_target_triple.getOSName().size() == 0) {
1129 new_target_triple.setOS(remote_triple.getOS());
1130
1131 if (new_target_triple.getEnvironmentName().size() == 0)
1132 new_target_triple.setEnvironment(
1133 remote_triple.getEnvironment());
1134 }
1135
1136 ArchSpec new_target_arch = target_arch;
1137 new_target_arch.SetTriple(new_target_triple);
1138 GetTarget().SetArchitecture(new_target_arch);
1139 }
1140 }
1141
1142 if (log)
1143 log->Printf("ProcessGDBRemote::%s final target arch after "
1144 "adjustments for remote architecture: %s %s",
1145 __FUNCTION__, target_arch.GetArchitectureName()
1146 ? target_arch.GetArchitectureName()
1147 : "<null>",
1148 target_arch.GetTriple().getTriple().c_str()
1149 ? target_arch.GetTriple().getTriple().c_str()
1150 : "<null>");
1151 } else {
1152 // The target doesn't have a valid architecture yet, set it from
1153 // the architecture we got from the remote GDB server
1154 GetTarget().SetArchitecture(process_arch);
1155 }
1156 }
1157
1158 // Find out which StructuredDataPlugins are supported by the
1159 // debug monitor. These plugins transmit data over async $J packets.
1160 auto supported_packets_array =
1161 m_gdb_comm.GetSupportedStructuredDataPlugins();
1162 if (supported_packets_array)
1163 MapSupportedStructuredDataPlugins(*supported_packets_array);
1164 }
1165}
1166
1167void ProcessGDBRemote::DidLaunch() {
1168 ArchSpec process_arch;
1169 DidLaunchOrAttach(process_arch);
1170}
1171
1172Status ProcessGDBRemote::DoAttachToProcessWithID(
1173 lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info) {
1174 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
1175 Status error;
1176
1177 if (log)
1178 log->Printf("ProcessGDBRemote::%s()", __FUNCTION__);
1179
1180 // Clear out and clean up from any current state
1181 Clear();
1182 if (attach_pid != LLDB_INVALID_PROCESS_ID0) {
1183 error = EstablishConnectionIfNeeded(attach_info);
1184 if (error.Success()) {
1185 m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
1186
1187 char packet[64];
1188 const int packet_len =
1189 ::snprintf(packet, sizeof(packet), "vAttach;%" PRIx64"l" "x", attach_pid);
1190 SetID(attach_pid);
1191 m_async_broadcaster.BroadcastEvent(
1192 eBroadcastBitAsyncContinue, new EventDataBytes(packet, packet_len));
1193 } else
1194 SetExitStatus(-1, error.AsCString());
1195 }
1196
1197 return error;
1198}
1199
1200Status ProcessGDBRemote::DoAttachToProcessWithName(
1201 const char *process_name, const ProcessAttachInfo &attach_info) {
1202 Status error;
1203 // Clear out and clean up from any current state
1204 Clear();
1205
1206 if (process_name && process_name[0]) {
1207 error = EstablishConnectionIfNeeded(attach_info);
1208 if (error.Success()) {
1209 StreamString packet;
1210
1211 m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
1212
1213 if (attach_info.GetWaitForLaunch()) {
1214 if (!m_gdb_comm.GetVAttachOrWaitSupported()) {
1215 packet.PutCString("vAttachWait");
1216 } else {
1217 if (attach_info.GetIgnoreExisting())
1218 packet.PutCString("vAttachWait");
1219 else
1220 packet.PutCString("vAttachOrWait");
1221 }
1222 } else
1223 packet.PutCString("vAttachName");
1224 packet.PutChar(';');
1225 packet.PutBytesAsRawHex8(process_name, strlen(process_name),
1226 endian::InlHostByteOrder(),
1227 endian::InlHostByteOrder());
1228
1229 m_async_broadcaster.BroadcastEvent(
1230 eBroadcastBitAsyncContinue,
1231 new EventDataBytes(packet.GetString().data(), packet.GetSize()));
1232
1233 } else
1234 SetExitStatus(-1, error.AsCString());
1235 }
1236 return error;
1237}
1238
1239lldb::user_id_t ProcessGDBRemote::StartTrace(const TraceOptions &options,
1240 Status &error) {
1241 return m_gdb_comm.SendStartTracePacket(options, error);
1242}
1243
1244Status ProcessGDBRemote::StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) {
1245 return m_gdb_comm.SendStopTracePacket(uid, thread_id);
1246}
1247
1248Status ProcessGDBRemote::GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
1249 llvm::MutableArrayRef<uint8_t> &buffer,
1250 size_t offset) {
1251 return m_gdb_comm.SendGetDataPacket(uid, thread_id, buffer, offset);
1252}
1253
1254Status ProcessGDBRemote::GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
1255 llvm::MutableArrayRef<uint8_t> &buffer,
1256 size_t offset) {
1257 return m_gdb_comm.SendGetMetaDataPacket(uid, thread_id, buffer, offset);
1258}
1259
1260Status ProcessGDBRemote::GetTraceConfig(lldb::user_id_t uid,
1261 TraceOptions &options) {
1262 return m_gdb_comm.SendGetTraceConfigPacket(uid, options);
1263}
1264
1265void ProcessGDBRemote::DidExit() {
1266 // When we exit, disconnect from the GDB server communications
1267 m_gdb_comm.Disconnect();
1268}
1269
1270void ProcessGDBRemote::DidAttach(ArchSpec &process_arch) {
1271 // If you can figure out what the architecture is, fill it in here.
1272 process_arch.Clear();
1273 DidLaunchOrAttach(process_arch);
1274}
1275
1276Status ProcessGDBRemote::WillResume() {
1277 m_continue_c_tids.clear();
1278 m_continue_C_tids.clear();
1279 m_continue_s_tids.clear();
1280 m_continue_S_tids.clear();
1281 m_jstopinfo_sp.reset();
1282 m_jthreadsinfo_sp.reset();
1283 return Status();
1284}
1285
1286Status ProcessGDBRemote::DoResume() {
1287 Status error;
1288 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
1289 if (log)
1290 log->Printf("ProcessGDBRemote::Resume()");
1291
1292 ListenerSP listener_sp(
1293 Listener::MakeListener("gdb-remote.resume-packet-sent"));
1294 if (listener_sp->StartListeningForEvents(
1295 &m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent)) {
1296 listener_sp->StartListeningForEvents(
1297 &m_async_broadcaster,
1298 ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit);
1299
1300 const size_t num_threads = GetThreadList().GetSize();
1301
1302 StreamString continue_packet;
1303 bool continue_packet_error = false;
1304 if (m_gdb_comm.HasAnyVContSupport()) {
1305 if (!GetTarget().GetNonStopModeEnabled() &&
1306 (m_continue_c_tids.size() == num_threads ||
1307 (m_continue_c_tids.empty() && m_continue_C_tids.empty() &&
1308 m_continue_s_tids.empty() && m_continue_S_tids.empty()))) {
1309 // All threads are continuing, just send a "c" packet
1310 continue_packet.PutCString("c");
1311 } else {
1312 continue_packet.PutCString("vCont");
1313
1314 if (!m_continue_c_tids.empty()) {
1315 if (m_gdb_comm.GetVContSupported('c')) {
1316 for (tid_collection::const_iterator
1317 t_pos = m_continue_c_tids.begin(),
1318 t_end = m_continue_c_tids.end();
1319 t_pos != t_end; ++t_pos)
1320 continue_packet.Printf(";c:%4.4" PRIx64"l" "x", *t_pos);
1321 } else
1322 continue_packet_error = true;
1323 }
1324
1325 if (!continue_packet_error && !m_continue_C_tids.empty()) {
1326 if (m_gdb_comm.GetVContSupported('C')) {
1327 for (tid_sig_collection::const_iterator
1328 s_pos = m_continue_C_tids.begin(),
1329 s_end = m_continue_C_tids.end();
1330 s_pos != s_end; ++s_pos)
1331 continue_packet.Printf(";C%2.2x:%4.4" PRIx64"l" "x", s_pos->second,
1332 s_pos->first);
1333 } else
1334 continue_packet_error = true;
1335 }
1336
1337 if (!continue_packet_error && !m_continue_s_tids.empty()) {
1338 if (m_gdb_comm.GetVContSupported('s')) {
1339 for (tid_collection::const_iterator
1340 t_pos = m_continue_s_tids.begin(),
1341 t_end = m_continue_s_tids.end();
1342 t_pos != t_end; ++t_pos)
1343 continue_packet.Printf(";s:%4.4" PRIx64"l" "x", *t_pos);
1344 } else
1345 continue_packet_error = true;
1346 }
1347
1348 if (!continue_packet_error && !m_continue_S_tids.empty()) {
1349 if (m_gdb_comm.GetVContSupported('S')) {
1350 for (tid_sig_collection::const_iterator
1351 s_pos = m_continue_S_tids.begin(),
1352 s_end = m_continue_S_tids.end();
1353 s_pos != s_end; ++s_pos)
1354 continue_packet.Printf(";S%2.2x:%4.4" PRIx64"l" "x", s_pos->second,
1355 s_pos->first);
1356 } else
1357 continue_packet_error = true;
1358 }
1359
1360 if (continue_packet_error)
1361 continue_packet.Clear();
1362 }
1363 } else
1364 continue_packet_error = true;
1365
1366 if (continue_packet_error) {
1367 // Either no vCont support, or we tried to use part of the vCont
1368 // packet that wasn't supported by the remote GDB server.
1369 // We need to try and make a simple packet that can do our continue
1370 const size_t num_continue_c_tids = m_continue_c_tids.size();
1371 const size_t num_continue_C_tids = m_continue_C_tids.size();
1372 const size_t num_continue_s_tids = m_continue_s_tids.size();
1373 const size_t num_continue_S_tids = m_continue_S_tids.size();
1374 if (num_continue_c_tids > 0) {
1375 if (num_continue_c_tids == num_threads) {
1376 // All threads are resuming...
1377 m_gdb_comm.SetCurrentThreadForRun(-1);
1378 continue_packet.PutChar('c');
1379 continue_packet_error = false;
1380 } else if (num_continue_c_tids == 1 && num_continue_C_tids == 0 &&
1381 num_continue_s_tids == 0 && num_continue_S_tids == 0) {
1382 // Only one thread is continuing
1383 m_gdb_comm.SetCurrentThreadForRun(m_continue_c_tids.front());
1384 continue_packet.PutChar('c');
1385 continue_packet_error = false;
1386 }
1387 }
1388
1389 if (continue_packet_error && num_continue_C_tids > 0) {
1390 if ((num_continue_C_tids + num_continue_c_tids) == num_threads &&
1391 num_continue_C_tids > 0 && num_continue_s_tids == 0 &&
1392 num_continue_S_tids == 0) {
1393 const int continue_signo = m_continue_C_tids.front().second;
1394 // Only one thread is continuing
1395 if (num_continue_C_tids > 1) {
1396 // More that one thread with a signal, yet we don't have
1397 // vCont support and we are being asked to resume each
1398 // thread with a signal, we need to make sure they are
1399 // all the same signal, or we can't issue the continue
1400 // accurately with the current support...
1401 if (num_continue_C_tids > 1) {
1402 continue_packet_error = false;
1403 for (size_t i = 1; i < m_continue_C_tids.size(); ++i) {
1404 if (m_continue_C_tids[i].second != continue_signo)
1405 continue_packet_error = true;
1406 }
1407 }
1408 if (!continue_packet_error)
1409 m_gdb_comm.SetCurrentThreadForRun(-1);
1410 } else {
1411 // Set the continue thread ID
1412 continue_packet_error = false;
1413 m_gdb_comm.SetCurrentThreadForRun(m_continue_C_tids.front().first);
1414 }
1415 if (!continue_packet_error) {
1416 // Add threads continuing with the same signo...
1417 continue_packet.Printf("C%2.2x", continue_signo);
1418 }
1419 }
1420 }
1421
1422 if (continue_packet_error && num_continue_s_tids > 0) {
1423 if (num_continue_s_tids == num_threads) {
1424 // All threads are resuming...
1425 m_gdb_comm.SetCurrentThreadForRun(-1);
1426
1427 // If in Non-Stop-Mode use vCont when stepping
1428 if (GetTarget().GetNonStopModeEnabled()) {
1429 if (m_gdb_comm.GetVContSupported('s'))
1430 continue_packet.PutCString("vCont;s");
1431 else
1432 continue_packet.PutChar('s');
1433 } else
1434 continue_packet.PutChar('s');
1435
1436 continue_packet_error = false;
1437 } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1438 num_continue_s_tids == 1 && num_continue_S_tids == 0) {
1439 // Only one thread is stepping
1440 m_gdb_comm.SetCurrentThreadForRun(m_continue_s_tids.front());
1441 continue_packet.PutChar('s');
1442 continue_packet_error = false;
1443 }
1444 }
1445
1446 if (!continue_packet_error && num_continue_S_tids > 0) {
1447 if (num_continue_S_tids == num_threads) {
1448 const int step_signo = m_continue_S_tids.front().second;
1449 // Are all threads trying to step with the same signal?
1450 continue_packet_error = false;
1451 if (num_continue_S_tids > 1) {
1452 for (size_t i = 1; i < num_threads; ++i) {
1453 if (m_continue_S_tids[i].second != step_signo)
1454 continue_packet_error = true;
1455 }
1456 }
1457 if (!continue_packet_error) {
1458 // Add threads stepping with the same signo...
1459 m_gdb_comm.SetCurrentThreadForRun(-1);
1460 continue_packet.Printf("S%2.2x", step_signo);
1461 }
1462 } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1463 num_continue_s_tids == 0 && num_continue_S_tids == 1) {
1464 // Only one thread is stepping with signal
1465 m_gdb_comm.SetCurrentThreadForRun(m_continue_S_tids.front().first);
1466 continue_packet.Printf("S%2.2x", m_continue_S_tids.front().second);
1467 continue_packet_error = false;
1468 }
1469 }
1470 }
1471
1472 if (continue_packet_error) {
1473 error.SetErrorString("can't make continue packet for this resume");
1474 } else {
1475 EventSP event_sp;
1476 if (!m_async_thread.IsJoinable()) {
1477 error.SetErrorString("Trying to resume but the async thread is dead.");
1478 if (log)
1479 log->Printf("ProcessGDBRemote::DoResume: Trying to resume but the "
1480 "async thread is dead.");
1481 return error;
1482 }
1483
1484 m_async_broadcaster.BroadcastEvent(
1485 eBroadcastBitAsyncContinue,
1486 new EventDataBytes(continue_packet.GetString().data(),
1487 continue_packet.GetSize()));
1488
1489 if (listener_sp->GetEvent(event_sp, std::chrono::seconds(5)) == false) {
1490 error.SetErrorString("Resume timed out.");
1491 if (log)
1492 log->Printf("ProcessGDBRemote::DoResume: Resume timed out.");
1493 } else if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
1494 error.SetErrorString("Broadcast continue, but the async thread was "
1495 "killed before we got an ack back.");
1496 if (log)
1497 log->Printf("ProcessGDBRemote::DoResume: Broadcast continue, but the "
1498 "async thread was killed before we got an ack back.");
1499 return error;
1500 }
1501 }
1502 }
1503
1504 return error;
1505}
1506
1507void ProcessGDBRemote::HandleStopReplySequence() {
1508 while (true) {
1509 // Send vStopped
1510 StringExtractorGDBRemote response;
1511 m_gdb_comm.SendPacketAndWaitForResponse("vStopped", response, false);
1512
1513 // OK represents end of signal list
1514 if (response.IsOKResponse())
1515 break;
1516
1517 // If not OK or a normal packet we have a problem
1518 if (!response.IsNormalResponse())
1519 break;
1520
1521 SetLastStopPacket(response);
1522 }
1523}
1524
1525void ProcessGDBRemote::ClearThreadIDList() {
1526 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1527 m_thread_ids.clear();
1528 m_thread_pcs.clear();
1529}
1530
1531size_t
1532ProcessGDBRemote::UpdateThreadIDsFromStopReplyThreadsValue(std::string &value) {
1533 m_thread_ids.clear();
1534 m_thread_pcs.clear();
1535 size_t comma_pos;
1536 lldb::tid_t tid;
1537 while ((comma_pos = value.find(',')) != std::string::npos) {
1538 value[comma_pos] = '\0';
1539 // thread in big endian hex
1540 tid = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_THREAD_ID0, 16);
1541 if (tid != LLDB_INVALID_THREAD_ID0)
1542 m_thread_ids.push_back(tid);
1543 value.erase(0, comma_pos + 1);
1544 }
1545 tid = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_THREAD_ID0, 16);
1546 if (tid != LLDB_INVALID_THREAD_ID0)
1547 m_thread_ids.push_back(tid);
1548 return m_thread_ids.size();
1549}
1550
1551size_t
1552ProcessGDBRemote::UpdateThreadPCsFromStopReplyThreadsValue(std::string &value) {
1553 m_thread_pcs.clear();
1554 size_t comma_pos;
1555 lldb::addr_t pc;
1556 while ((comma_pos = value.find(',')) != std::string::npos) {
1557 value[comma_pos] = '\0';
1558 pc = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 16);
1559 if (pc != LLDB_INVALID_ADDRESS(18446744073709551615UL))
1560 m_thread_pcs.push_back(pc);
1561 value.erase(0, comma_pos + 1);
1562 }
1563 pc = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 16);
1564 if (pc != LLDB_INVALID_THREAD_ID0)
1565 m_thread_pcs.push_back(pc);
1566 return m_thread_pcs.size();
1567}
1568
1569bool ProcessGDBRemote::UpdateThreadIDList() {
1570 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1571
1572 if (m_jthreadsinfo_sp) {
1573 // If we have the JSON threads info, we can get the thread list from that
1574 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
1575 if (thread_infos && thread_infos->GetSize() > 0) {
1576 m_thread_ids.clear();
1577 m_thread_pcs.clear();
1578 thread_infos->ForEach([this](StructuredData::Object *object) -> bool {
1579 StructuredData::Dictionary *thread_dict = object->GetAsDictionary();
1580 if (thread_dict) {
1581 // Set the thread stop info from the JSON dictionary
1582 SetThreadStopInfo(thread_dict);
1583 lldb::tid_t tid = LLDB_INVALID_THREAD_ID0;
1584 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>("tid", tid))
1585 m_thread_ids.push_back(tid);
1586 }
1587 return true; // Keep iterating through all thread_info objects
1588 });
1589 }
1590 if (!m_thread_ids.empty())
1591 return true;
1592 } else {
1593 // See if we can get the thread IDs from the current stop reply packets
1594 // that might contain a "threads" key/value pair
1595
1596 // Lock the thread stack while we access it
1597 // Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
1598 std::unique_lock<std::recursive_mutex> stop_stack_lock(
1599 m_last_stop_packet_mutex, std::defer_lock);
1600 if (stop_stack_lock.try_lock()) {
1601 // Get the number of stop packets on the stack
1602 int nItems = m_stop_packet_stack.size();
1603 // Iterate over them
1604 for (int i = 0; i < nItems; i++) {
1605 // Get the thread stop info
1606 StringExtractorGDBRemote &stop_info = m_stop_packet_stack[i];
1607 const std::string &stop_info_str = stop_info.GetStringRef();
1608
1609 m_thread_pcs.clear();
1610 const size_t thread_pcs_pos = stop_info_str.find(";thread-pcs:");
1611 if (thread_pcs_pos != std::string::npos) {
1612 const size_t start = thread_pcs_pos + strlen(";thread-pcs:");
1613 const size_t end = stop_info_str.find(';', start);
1614 if (end != std::string::npos) {
1615 std::string value = stop_info_str.substr(start, end - start);
1616 UpdateThreadPCsFromStopReplyThreadsValue(value);
1617 }
1618 }
1619
1620 const size_t threads_pos = stop_info_str.find(";threads:");
1621 if (threads_pos != std::string::npos) {
1622 const size_t start = threads_pos + strlen(";threads:");
1623 const size_t end = stop_info_str.find(';', start);
1624 if (end != std::string::npos) {
1625 std::string value = stop_info_str.substr(start, end - start);
1626 if (UpdateThreadIDsFromStopReplyThreadsValue(value))
1627 return true;
1628 }
1629 }
1630 }
1631 }
1632 }
1633
1634 bool sequence_mutex_unavailable = false;
1635 m_gdb_comm.GetCurrentThreadIDs(m_thread_ids, sequence_mutex_unavailable);
1636 if (sequence_mutex_unavailable) {
1637 return false; // We just didn't get the list
1638 }
1639 return true;
1640}
1641
1642bool ProcessGDBRemote::UpdateThreadList(ThreadList &old_thread_list,
1643 ThreadList &new_thread_list) {
1644 // locker will keep a mutex locked until it goes out of scope
1645 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_THREAD(1u << 2)));
1646 LLDB_LOGV(log, "pid = {0}", GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "pid = {0}", GetID()); } while (0)
;
1647
1648 size_t num_thread_ids = m_thread_ids.size();
1649 // The "m_thread_ids" thread ID list should always be updated after each stop
1650 // reply packet, but in case it isn't, update it here.
1651 if (num_thread_ids == 0) {
1652 if (!UpdateThreadIDList())
1653 return false;
1654 num_thread_ids = m_thread_ids.size();
1655 }
1656
1657 ThreadList old_thread_list_copy(old_thread_list);
1658 if (num_thread_ids > 0) {
1659 for (size_t i = 0; i < num_thread_ids; ++i) {
1660 tid_t tid = m_thread_ids[i];
1661 ThreadSP thread_sp(
1662 old_thread_list_copy.RemoveThreadByProtocolID(tid, false));
1663 if (!thread_sp) {
1664 thread_sp.reset(new ThreadGDBRemote(*this, tid));
1665 LLDB_LOGV(log, "Making new thread: {0} for thread ID: {1:x}.",do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Making new thread: {0} for thread ID: {1:x}."
, thread_sp.get(), thread_sp->GetID()); } while (0)
1666 thread_sp.get(), thread_sp->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Making new thread: {0} for thread ID: {1:x}."
, thread_sp.get(), thread_sp->GetID()); } while (0)
;
1667 } else {
1668 LLDB_LOGV(log, "Found old thread: {0} for thread ID: {1:x}.",do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Found old thread: {0} for thread ID: {1:x}."
, thread_sp.get(), thread_sp->GetID()); } while (0)
1669 thread_sp.get(), thread_sp->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
&& log_private->GetVerbose()) log_private->Format
("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Found old thread: {0} for thread ID: {1:x}."
, thread_sp.get(), thread_sp->GetID()); } while (0)
;
1670 }
1671
1672 SetThreadPc(thread_sp, i);
1673 new_thread_list.AddThreadSortedByIndexID(thread_sp);
1674 }
1675 }
1676
1677 // Whatever that is left in old_thread_list_copy are not
1678 // present in new_thread_list. Remove non-existent threads from internal id
1679 // table.
1680 size_t old_num_thread_ids = old_thread_list_copy.GetSize(false);
1681 for (size_t i = 0; i < old_num_thread_ids; i++) {
1682 ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
1683 if (old_thread_sp) {
1684 lldb::tid_t old_thread_id = old_thread_sp->GetProtocolID();
1685 m_thread_id_to_index_id_map.erase(old_thread_id);
1686 }
1687 }
1688
1689 return true;
1690}
1691
1692void ProcessGDBRemote::SetThreadPc(const ThreadSP &thread_sp, uint64_t index) {
1693 if (m_thread_ids.size() == m_thread_pcs.size() && thread_sp.get() &&
1694 GetByteOrder() != eByteOrderInvalid) {
1695 ThreadGDBRemote *gdb_thread =
1696 static_cast<ThreadGDBRemote *>(thread_sp.get());
1697 RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
1698 if (reg_ctx_sp) {
1699 uint32_t pc_regnum = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1700 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC0);
1701 if (pc_regnum != LLDB_INVALID_REGNUM(4294967295U)) {
1702 gdb_thread->PrivateSetRegisterValue(pc_regnum, m_thread_pcs[index]);
1703 }
1704 }
1705 }
1706}
1707
1708bool ProcessGDBRemote::GetThreadStopInfoFromJSON(
1709 ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp) {
1710 // See if we got thread stop infos for all threads via the "jThreadsInfo"
1711 // packet
1712 if (thread_infos_sp) {
1713 StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray();
1714 if (thread_infos) {
1715 lldb::tid_t tid;
1716 const size_t n = thread_infos->GetSize();
1717 for (size_t i = 0; i < n; ++i) {
1718 StructuredData::Dictionary *thread_dict =
1719 thread_infos->GetItemAtIndex(i)->GetAsDictionary();
1720 if (thread_dict) {
1721 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>(
1722 "tid", tid, LLDB_INVALID_THREAD_ID0)) {
1723 if (tid == thread->GetID())
1724 return (bool)SetThreadStopInfo(thread_dict);
1725 }
1726 }
1727 }
1728 }
1729 }
1730 return false;
1731}
1732
1733bool ProcessGDBRemote::CalculateThreadStopInfo(ThreadGDBRemote *thread) {
1734 // See if we got thread stop infos for all threads via the "jThreadsInfo"
1735 // packet
1736 if (GetThreadStopInfoFromJSON(thread, m_jthreadsinfo_sp))
1737 return true;
1738
1739 // See if we got thread stop info for any threads valid stop info reasons
1740 // threads
1741 // via the "jstopinfo" packet stop reply packet key/value pair?
1742 if (m_jstopinfo_sp) {
1743 // If we have "jstopinfo" then we have stop descriptions for all threads
1744 // that have stop reasons, and if there is no entry for a thread, then
1745 // it has no stop reason.
1746 thread->GetRegisterContext()->InvalidateIfNeeded(true);
1747 if (!GetThreadStopInfoFromJSON(thread, m_jstopinfo_sp)) {
1748 thread->SetStopInfo(StopInfoSP());
1749 }
1750 return true;
1751 }
1752
1753 // Fall back to using the qThreadStopInfo packet
1754 StringExtractorGDBRemote stop_packet;
1755 if (GetGDBRemote().GetThreadStopInfo(thread->GetProtocolID(), stop_packet))
1756 return SetThreadStopInfo(stop_packet) == eStateStopped;
1757 return false;
1758}
1759
1760ThreadSP ProcessGDBRemote::SetThreadStopInfo(
1761 lldb::tid_t tid, ExpeditedRegisterMap &expedited_register_map,
1762 uint8_t signo, const std::string &thread_name, const std::string &reason,
1763 const std::string &description, uint32_t exc_type,
1764 const std::vector<addr_t> &exc_data, addr_t thread_dispatch_qaddr,
1765 bool queue_vars_valid, // Set to true if queue_name, queue_kind and
1766 // queue_serial are valid
1767 LazyBool associated_with_dispatch_queue, addr_t dispatch_queue_t,
1768 std::string &queue_name, QueueKind queue_kind, uint64_t queue_serial) {
1769 ThreadSP thread_sp;
1770 if (tid != LLDB_INVALID_THREAD_ID0) {
1771 // Scope for "locker" below
1772 {
1773 // m_thread_list_real does have its own mutex, but we need to
1774 // hold onto the mutex between the call to
1775 // m_thread_list_real.FindThreadByID(...)
1776 // and the m_thread_list_real.AddThread(...) so it doesn't change on us
1777 std::lock_guard<std::recursive_mutex> guard(
1778 m_thread_list_real.GetMutex());
1779 thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
1780
1781 if (!thread_sp) {
1782 // Create the thread if we need to
1783 thread_sp.reset(new ThreadGDBRemote(*this, tid));
1784 m_thread_list_real.AddThread(thread_sp);
1785 }
1786 }
1787
1788 if (thread_sp) {
1789 ThreadGDBRemote *gdb_thread =
1790 static_cast<ThreadGDBRemote *>(thread_sp.get());
1791 gdb_thread->GetRegisterContext()->InvalidateIfNeeded(true);
1792
1793 auto iter = std::find(m_thread_ids.begin(), m_thread_ids.end(), tid);
1794 if (iter != m_thread_ids.end()) {
1795 SetThreadPc(thread_sp, iter - m_thread_ids.begin());
1796 }
1797
1798 for (const auto &pair : expedited_register_map) {
1799 StringExtractor reg_value_extractor;
1800 reg_value_extractor.GetStringRef() = pair.second;
1801 DataBufferSP buffer_sp(new DataBufferHeap(
1802 reg_value_extractor.GetStringRef().size() / 2, 0));
1803 reg_value_extractor.GetHexBytes(buffer_sp->GetData(), '\xcc');
1804 gdb_thread->PrivateSetRegisterValue(pair.first, buffer_sp->GetData());
1805 }
1806
1807 thread_sp->SetName(thread_name.empty() ? NULL__null : thread_name.c_str());
1808
1809 gdb_thread->SetThreadDispatchQAddr(thread_dispatch_qaddr);
1810 // Check if the GDB server was able to provide the queue name, kind and
1811 // serial number
1812 if (queue_vars_valid)
1813 gdb_thread->SetQueueInfo(std::move(queue_name), queue_kind,
1814 queue_serial, dispatch_queue_t,
1815 associated_with_dispatch_queue);
1816 else
1817 gdb_thread->ClearQueueInfo();
1818
1819 gdb_thread->SetAssociatedWithLibdispatchQueue(
1820 associated_with_dispatch_queue);
1821
1822 if (dispatch_queue_t != LLDB_INVALID_ADDRESS(18446744073709551615UL))
1823 gdb_thread->SetQueueLibdispatchQueueAddress(dispatch_queue_t);
1824
1825 // Make sure we update our thread stop reason just once
1826 if (!thread_sp->StopInfoIsUpToDate()) {
1827 thread_sp->SetStopInfo(StopInfoSP());
1828 // If there's a memory thread backed by this thread, we need to use it
1829 // to calcualte StopInfo.
1830 ThreadSP memory_thread_sp =
1831 m_thread_list.FindThreadByProtocolID(thread_sp->GetProtocolID());
1832 if (memory_thread_sp)
1833 thread_sp = memory_thread_sp;
1834
1835 if (exc_type != 0) {
1836 const size_t exc_data_size = exc_data.size();
1837
1838 thread_sp->SetStopInfo(
1839 StopInfoMachException::CreateStopReasonWithMachException(
1840 *thread_sp, exc_type, exc_data_size,
1841 exc_data_size >= 1 ? exc_data[0] : 0,
1842 exc_data_size >= 2 ? exc_data[1] : 0,
1843 exc_data_size >= 3 ? exc_data[2] : 0));
1844 } else {
1845 bool handled = false;
1846 bool did_exec = false;
1847 if (!reason.empty()) {
1848 if (reason.compare("trace") == 0) {
1849 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1850 lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
1851 ->GetBreakpointSiteList()
1852 .FindByAddress(pc);
1853
1854 // If the current pc is a breakpoint site then the StopInfo should
1855 // be set to Breakpoint
1856 // Otherwise, it will be set to Trace.
1857 if (bp_site_sp &&
1858 bp_site_sp->ValidForThisThread(thread_sp.get())) {
1859 thread_sp->SetStopInfo(
1860 StopInfo::CreateStopReasonWithBreakpointSiteID(
1861 *thread_sp, bp_site_sp->GetID()));
1862 } else
1863 thread_sp->SetStopInfo(
1864 StopInfo::CreateStopReasonToTrace(*thread_sp));
1865 handled = true;
1866 } else if (reason.compare("breakpoint") == 0) {
1867 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1868 lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
1869 ->GetBreakpointSiteList()
1870 .FindByAddress(pc);
1871 if (bp_site_sp) {
1872 // If the breakpoint is for this thread, then we'll report the
1873 // hit, but if it is for another thread,
1874 // we can just report no reason. We don't need to worry about
1875 // stepping over the breakpoint here, that
1876 // will be taken care of when the thread resumes and notices
1877 // that there's a breakpoint under the pc.
1878 handled = true;
1879 if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
1880 thread_sp->SetStopInfo(
1881 StopInfo::CreateStopReasonWithBreakpointSiteID(
1882 *thread_sp, bp_site_sp->GetID()));
1883 } else {
1884 StopInfoSP invalid_stop_info_sp;
1885 thread_sp->SetStopInfo(invalid_stop_info_sp);
1886 }
1887 }
1888 } else if (reason.compare("trap") == 0) {
1889 // Let the trap just use the standard signal stop reason below...
1890 } else if (reason.compare("watchpoint") == 0) {
1891 StringExtractor desc_extractor(description.c_str());
1892 addr_t wp_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS(18446744073709551615UL));
1893 uint32_t wp_index = desc_extractor.GetU32(LLDB_INVALID_INDEX32(4294967295U));
1894 addr_t wp_hit_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS(18446744073709551615UL));
1895 watch_id_t watch_id = LLDB_INVALID_WATCH_ID0;
1896 if (wp_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
1897 WatchpointSP wp_sp;
1898 ArchSpec::Core core = GetTarget().GetArchitecture().GetCore();
1899 if ((core >= ArchSpec::kCore_mips_first &&
1900 core <= ArchSpec::kCore_mips_last) ||
1901 (core >= ArchSpec::eCore_arm_generic &&
1902 core <= ArchSpec::eCore_arm_aarch64))
1903 wp_sp = GetTarget().GetWatchpointList().FindByAddress(
1904 wp_hit_addr);
1905 if (!wp_sp)
1906 wp_sp =
1907 GetTarget().GetWatchpointList().FindByAddress(wp_addr);
1908 if (wp_sp) {
1909 wp_sp->SetHardwareIndex(wp_index);
1910 watch_id = wp_sp->GetID();
1911 }
1912 }
1913 if (watch_id == LLDB_INVALID_WATCH_ID0) {
1914 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(
1915 GDBR_LOG_WATCHPOINTS(1u << 8)));
1916 if (log)
1917 log->Printf("failed to find watchpoint");
1918 }
1919 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithWatchpointID(
1920 *thread_sp, watch_id, wp_hit_addr));
1921 handled = true;
1922 } else if (reason.compare("exception") == 0) {
1923 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
1924 *thread_sp, description.c_str()));
1925 handled = true;
1926 } else if (reason.compare("exec") == 0) {
1927 did_exec = true;
1928 thread_sp->SetStopInfo(
1929 StopInfo::CreateStopReasonWithExec(*thread_sp));
1930 handled = true;
1931 }
1932 } else if (!signo) {
1933 addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1934 lldb::BreakpointSiteSP bp_site_sp =
1935 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
1936 pc);
1937
1938 // If the current pc is a breakpoint site then the StopInfo should
1939 // be set to Breakpoint
1940 // even though the remote stub did not set it as such. This can
1941 // happen when
1942 // the thread is involuntarily interrupted (e.g. due to stops on
1943 // other
1944 // threads) just as it is about to execute the breakpoint
1945 // instruction.
1946 if (bp_site_sp && bp_site_sp->ValidForThisThread(thread_sp.get())) {
1947 thread_sp->SetStopInfo(
1948 StopInfo::CreateStopReasonWithBreakpointSiteID(
1949 *thread_sp, bp_site_sp->GetID()));
1950 handled = true;
1951 }
1952 }
1953
1954 if (!handled && signo && did_exec == false) {
1955 if (signo == SIGTRAP5) {
1956 // Currently we are going to assume SIGTRAP means we are either
1957 // hitting a breakpoint or hardware single stepping.
1958 handled = true;
1959 addr_t pc = thread_sp->GetRegisterContext()->GetPC() +
1960 m_breakpoint_pc_offset;
1961 lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
1962 ->GetBreakpointSiteList()
1963 .FindByAddress(pc);
1964
1965 if (bp_site_sp) {
1966 // If the breakpoint is for this thread, then we'll report the
1967 // hit, but if it is for another thread,
1968 // we can just report no reason. We don't need to worry about
1969 // stepping over the breakpoint here, that
1970 // will be taken care of when the thread resumes and notices
1971 // that there's a breakpoint under the pc.
1972 if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
1973 if (m_breakpoint_pc_offset != 0)
1974 thread_sp->GetRegisterContext()->SetPC(pc);
1975 thread_sp->SetStopInfo(
1976 StopInfo::CreateStopReasonWithBreakpointSiteID(
1977 *thread_sp, bp_site_sp->GetID()));
1978 } else {
1979 StopInfoSP invalid_stop_info_sp;
1980 thread_sp->SetStopInfo(invalid_stop_info_sp);
1981 }
1982 } else {
1983 // If we were stepping then assume the stop was the result of
1984 // the trace. If we were
1985 // not stepping then report the SIGTRAP.
1986 // FIXME: We are still missing the case where we single step
1987 // over a trap instruction.
1988 if (thread_sp->GetTemporaryResumeState() == eStateStepping)
1989 thread_sp->SetStopInfo(
1990 StopInfo::CreateStopReasonToTrace(*thread_sp));
1991 else
1992 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1993 *thread_sp, signo, description.c_str()));
1994 }
1995 }
1996 if (!handled)
1997 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1998 *thread_sp, signo, description.c_str()));
1999 }
2000
2001 if (!description.empty()) {
2002 lldb::StopInfoSP stop_info_sp(thread_sp->GetStopInfo());
2003 if (stop_info_sp) {
2004 const char *stop_info_desc = stop_info_sp->GetDescription();
2005 if (!stop_info_desc || !stop_info_desc[0])
2006 stop_info_sp->SetDescription(description.c_str());
2007 } else {
2008 thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
2009 *thread_sp, description.c_str()));
2010 }
2011 }
2012 }
2013 }
2014 }
2015 }
2016 return thread_sp;
2017}
2018
2019lldb::ThreadSP
2020ProcessGDBRemote::SetThreadStopInfo(StructuredData::Dictionary *thread_dict) {
2021 static ConstString g_key_tid("tid");
2022 static ConstString g_key_name("name");
2023 static ConstString g_key_reason("reason");
2024 static ConstString g_key_metype("metype");
2025 static ConstString g_key_medata("medata");
2026 static ConstString g_key_qaddr("qaddr");
2027 static ConstString g_key_dispatch_queue_t("dispatch_queue_t");
2028 static ConstString g_key_associated_with_dispatch_queue(
2029 "associated_with_dispatch_queue");
2030 static ConstString g_key_queue_name("qname");
2031 static ConstString g_key_queue_kind("qkind");
2032 static ConstString g_key_queue_serial_number("qserialnum");
2033 static ConstString g_key_registers("registers");
2034 static ConstString g_key_memory("memory");
2035 static ConstString g_key_address("address");
2036 static ConstString g_key_bytes("bytes");
2037 static ConstString g_key_description("description");
2038 static ConstString g_key_signal("signal");
2039
2040 // Stop with signal and thread info
2041 lldb::tid_t tid = LLDB_INVALID_THREAD_ID0;
2042 uint8_t signo = 0;
2043 std::string value;
2044 std::string thread_name;
2045 std::string reason;
2046 std::string description;
2047 uint32_t exc_type = 0;
2048 std::vector<addr_t> exc_data;
2049 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2050 ExpeditedRegisterMap expedited_register_map;
2051 bool queue_vars_valid = false;
2052 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2053 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2054 std::string queue_name;
2055 QueueKind queue_kind = eQueueKindUnknown;
2056 uint64_t queue_serial_number = 0;
2057 // Iterate through all of the thread dictionary key/value pairs from the
2058 // structured data dictionary
2059
2060 thread_dict->ForEach([this, &tid, &expedited_register_map, &thread_name,
2061 &signo, &reason, &description, &exc_type, &exc_data,
2062 &thread_dispatch_qaddr, &queue_vars_valid,
2063 &associated_with_dispatch_queue, &dispatch_queue_t,
2064 &queue_name, &queue_kind, &queue_serial_number](
2065 ConstString key,
2066 StructuredData::Object *object) -> bool {
2067 if (key == g_key_tid) {
2068 // thread in big endian hex
2069 tid = object->GetIntegerValue(LLDB_INVALID_THREAD_ID0);
2070 } else if (key == g_key_metype) {
2071 // exception type in big endian hex
2072 exc_type = object->GetIntegerValue(0);
2073 } else if (key == g_key_medata) {
2074 // exception data in big endian hex
2075 StructuredData::Array *array = object->GetAsArray();
2076 if (array) {
2077 array->ForEach([&exc_data](StructuredData::Object *object) -> bool {
2078 exc_data.push_back(object->GetIntegerValue());
2079 return true; // Keep iterating through all array items
2080 });
2081 }
2082 } else if (key == g_key_name) {
2083 thread_name = object->GetStringValue();
2084 } else if (key == g_key_qaddr) {
2085 thread_dispatch_qaddr = object->GetIntegerValue(LLDB_INVALID_ADDRESS(18446744073709551615UL));
2086 } else if (key == g_key_queue_name) {
2087 queue_vars_valid = true;
2088 queue_name = object->GetStringValue();
2089 } else if (key == g_key_queue_kind) {
2090 std::string queue_kind_str = object->GetStringValue();
2091 if (queue_kind_str == "serial") {
2092 queue_vars_valid = true;
2093 queue_kind = eQueueKindSerial;
2094 } else if (queue_kind_str == "concurrent") {
2095 queue_vars_valid = true;
2096 queue_kind = eQueueKindConcurrent;
2097 }
2098 } else if (key == g_key_queue_serial_number) {
2099 queue_serial_number = object->GetIntegerValue(0);
2100 if (queue_serial_number != 0)
2101 queue_vars_valid = true;
2102 } else if (key == g_key_dispatch_queue_t) {
2103 dispatch_queue_t = object->GetIntegerValue(0);
2104 if (dispatch_queue_t != 0 && dispatch_queue_t != LLDB_INVALID_ADDRESS(18446744073709551615UL))
2105 queue_vars_valid = true;
2106 } else if (key == g_key_associated_with_dispatch_queue) {
2107 queue_vars_valid = true;
2108 bool associated = object->GetBooleanValue();
2109 if (associated)
2110 associated_with_dispatch_queue = eLazyBoolYes;
2111 else
2112 associated_with_dispatch_queue = eLazyBoolNo;
2113 } else if (key == g_key_reason) {
2114 reason = object->GetStringValue();
2115 } else if (key == g_key_description) {
2116 description = object->GetStringValue();
2117 } else if (key == g_key_registers) {
2118 StructuredData::Dictionary *registers_dict = object->GetAsDictionary();
2119
2120 if (registers_dict) {
2121 registers_dict->ForEach(
2122 [&expedited_register_map](ConstString key,
2123 StructuredData::Object *object) -> bool {
2124 const uint32_t reg =
2125 StringConvert::ToUInt32(key.GetCString(), UINT32_MAX(4294967295U), 10);
2126 if (reg != UINT32_MAX(4294967295U))
2127 expedited_register_map[reg] = object->GetStringValue();
2128 return true; // Keep iterating through all array items
2129 });
2130 }
2131 } else if (key == g_key_memory) {
2132 StructuredData::Array *array = object->GetAsArray();
2133 if (array) {
2134 array->ForEach([this](StructuredData::Object *object) -> bool {
2135 StructuredData::Dictionary *mem_cache_dict =
2136 object->GetAsDictionary();
2137 if (mem_cache_dict) {
2138 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2139 if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>(
2140 "address", mem_cache_addr)) {
2141 if (mem_cache_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
2142 llvm::StringRef str;
2143 if (mem_cache_dict->GetValueForKeyAsString("bytes", str)) {
2144 StringExtractor bytes(str);
2145 bytes.SetFilePos(0);
2146
2147 const size_t byte_size = bytes.GetStringRef().size() / 2;
2148 DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
2149 const size_t bytes_copied =
2150 bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
2151 if (bytes_copied == byte_size)
2152 m_memory_cache.AddL1CacheData(mem_cache_addr,
2153 data_buffer_sp);
2154 }
2155 }
2156 }
2157 }
2158 return true; // Keep iterating through all array items
2159 });
2160 }
2161
2162 } else if (key == g_key_signal)
2163 signo = object->GetIntegerValue(LLDB_INVALID_SIGNAL_NUMBER(2147483647));
2164 return true; // Keep iterating through all dictionary key/value pairs
2165 });
2166
2167 return SetThreadStopInfo(tid, expedited_register_map, signo, thread_name,
2168 reason, description, exc_type, exc_data,
2169 thread_dispatch_qaddr, queue_vars_valid,
2170 associated_with_dispatch_queue, dispatch_queue_t,
2171 queue_name, queue_kind, queue_serial_number);
2172}
2173
2174StateType ProcessGDBRemote::SetThreadStopInfo(StringExtractor &stop_packet) {
2175 stop_packet.SetFilePos(0);
2176 const char stop_type = stop_packet.GetChar();
2177 switch (stop_type) {
2178 case 'T':
2179 case 'S': {
2180 // This is a bit of a hack, but is is required. If we did exec, we
2181 // need to clear our thread lists and also know to rebuild our dynamic
2182 // register info before we lookup and threads and populate the expedited
2183 // register values so we need to know this right away so we can cleanup
2184 // and update our registers.
2185 const uint32_t stop_id = GetStopID();
2186 if (stop_id == 0) {
2187 // Our first stop, make sure we have a process ID, and also make
2188 // sure we know about our registers
2189 if (GetID() == LLDB_INVALID_PROCESS_ID0) {
2190 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
2191 if (pid != LLDB_INVALID_PROCESS_ID0)
2192 SetID(pid);
2193 }
2194 BuildDynamicRegisterInfo(true);
2195 }
2196 // Stop with signal and thread info
2197 lldb::tid_t tid = LLDB_INVALID_THREAD_ID0;
2198 const uint8_t signo = stop_packet.GetHexU8();
2199 llvm::StringRef key;
2200 llvm::StringRef value;
2201 std::string thread_name;
2202 std::string reason;
2203 std::string description;
2204 uint32_t exc_type = 0;
2205 std::vector<addr_t> exc_data;
2206 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2207 bool queue_vars_valid =
2208 false; // says if locals below that start with "queue_" are valid
2209 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2210 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2211 std::string queue_name;
2212 QueueKind queue_kind = eQueueKindUnknown;
2213 uint64_t queue_serial_number = 0;
2214 ExpeditedRegisterMap expedited_register_map;
2215 while (stop_packet.GetNameColonValue(key, value)) {
2216 if (key.compare("metype") == 0) {
2217 // exception type in big endian hex
2218 value.getAsInteger(16, exc_type);
2219 } else if (key.compare("medata") == 0) {
2220 // exception data in big endian hex
2221 uint64_t x;
2222 value.getAsInteger(16, x);
2223 exc_data.push_back(x);
2224 } else if (key.compare("thread") == 0) {
2225 // thread in big endian hex
2226 if (value.getAsInteger(16, tid))
2227 tid = LLDB_INVALID_THREAD_ID0;
2228 } else if (key.compare("threads") == 0) {
2229 std::lock_guard<std::recursive_mutex> guard(
2230 m_thread_list_real.GetMutex());
2231
2232 m_thread_ids.clear();
2233 // A comma separated list of all threads in the current
2234 // process that includes the thread for this stop reply
2235 // packet
2236 lldb::tid_t tid;
2237 while (!value.empty()) {
2238 llvm::StringRef tid_str;
2239 std::tie(tid_str, value) = value.split(',');
2240 if (tid_str.getAsInteger(16, tid))
2241 tid = LLDB_INVALID_THREAD_ID0;
2242 m_thread_ids.push_back(tid);
2243 }
2244 } else if (key.compare("thread-pcs") == 0) {
2245 m_thread_pcs.clear();
2246 // A comma separated list of all threads in the current
2247 // process that includes the thread for this stop reply
2248 // packet
2249 lldb::addr_t pc;
2250 while (!value.empty()) {
2251 llvm::StringRef pc_str;
2252 std::tie(pc_str, value) = value.split(',');
2253 if (pc_str.getAsInteger(16, pc))
2254 pc = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2255 m_thread_pcs.push_back(pc);
2256 }
2257 } else if (key.compare("jstopinfo") == 0) {
2258 StringExtractor json_extractor(value);
2259 std::string json;
2260 // Now convert the HEX bytes into a string value
2261 json_extractor.GetHexByteString(json);
2262
2263 // This JSON contains thread IDs and thread stop info for all threads.
2264 // It doesn't contain expedited registers, memory or queue info.
2265 m_jstopinfo_sp = StructuredData::ParseJSON(json);
2266 } else if (key.compare("hexname") == 0) {
2267 StringExtractor name_extractor(value);
2268 std::string name;
2269 // Now convert the HEX bytes into a string value
2270 name_extractor.GetHexByteString(thread_name);
2271 } else if (key.compare("name") == 0) {
2272 thread_name = value;
2273 } else if (key.compare("qaddr") == 0) {
2274 value.getAsInteger(16, thread_dispatch_qaddr);
2275 } else if (key.compare("dispatch_queue_t") == 0) {
2276 queue_vars_valid = true;
2277 value.getAsInteger(16, dispatch_queue_t);
2278 } else if (key.compare("qname") == 0) {
2279 queue_vars_valid = true;
2280 StringExtractor name_extractor(value);
2281 // Now convert the HEX bytes into a string value
2282 name_extractor.GetHexByteString(queue_name);
2283 } else if (key.compare("qkind") == 0) {
2284 queue_kind = llvm::StringSwitch<QueueKind>(value)
2285 .Case("serial", eQueueKindSerial)
2286 .Case("concurrent", eQueueKindConcurrent)
2287 .Default(eQueueKindUnknown);
2288 queue_vars_valid = queue_kind != eQueueKindUnknown;
2289 } else if (key.compare("qserialnum") == 0) {
2290 if (!value.getAsInteger(0, queue_serial_number))
2291 queue_vars_valid = true;
2292 } else if (key.compare("reason") == 0) {
2293 reason = value;
2294 } else if (key.compare("description") == 0) {
2295 StringExtractor desc_extractor(value);
2296 // Now convert the HEX bytes into a string value
2297 desc_extractor.GetHexByteString(description);
2298 } else if (key.compare("memory") == 0) {
2299 // Expedited memory. GDB servers can choose to send back expedited
2300 // memory
2301 // that can populate the L1 memory cache in the process so that things
2302 // like
2303 // the frame pointer backchain can be expedited. This will help stack
2304 // backtracing be more efficient by not having to send as many memory
2305 // read
2306 // requests down the remote GDB server.
2307
2308 // Key/value pair format: memory:<addr>=<bytes>;
2309 // <addr> is a number whose base will be interpreted by the prefix:
2310 // "0x[0-9a-fA-F]+" for hex
2311 // "0[0-7]+" for octal
2312 // "[1-9]+" for decimal
2313 // <bytes> is native endian ASCII hex bytes just like the register
2314 // values
2315 llvm::StringRef addr_str, bytes_str;
2316 std::tie(addr_str, bytes_str) = value.split('=');
2317 if (!addr_str.empty() && !bytes_str.empty()) {
2318 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2319 if (!addr_str.getAsInteger(0, mem_cache_addr)) {
2320 StringExtractor bytes(bytes_str);
2321 const size_t byte_size = bytes.GetBytesLeft() / 2;
2322 DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
2323 const size_t bytes_copied =
2324 bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
2325 if (bytes_copied == byte_size)
2326 m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp);
2327 }
2328 }
2329 } else if (key.compare("watch") == 0 || key.compare("rwatch") == 0 ||
2330 key.compare("awatch") == 0) {
2331 // Support standard GDB remote stop reply packet 'TAAwatch:addr'
2332 lldb::addr_t wp_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2333 value.getAsInteger(16, wp_addr);
2334
2335 WatchpointSP wp_sp =
2336 GetTarget().GetWatchpointList().FindByAddress(wp_addr);
2337 uint32_t wp_index = LLDB_INVALID_INDEX32(4294967295U);
2338
2339 if (wp_sp)
2340 wp_index = wp_sp->GetHardwareIndex();
2341
2342 reason = "watchpoint";
2343 StreamString ostr;
2344 ostr.Printf("%" PRIu64"l" "u" " %" PRIu32"u", wp_addr, wp_index);
2345 description = ostr.GetString();
2346 } else if (key.compare("library") == 0) {
2347 LoadModules();
2348 } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
2349 uint32_t reg = UINT32_MAX(4294967295U);
2350 if (!key.getAsInteger(16, reg))
2351 expedited_register_map[reg] = std::move(value);
2352 }
2353 }
2354
2355 if (tid == LLDB_INVALID_THREAD_ID0) {
2356 // A thread id may be invalid if the response is old style 'S' packet
2357 // which does not provide the
2358 // thread information. So update the thread list and choose the first one.
2359 UpdateThreadIDList();
2360
2361 if (!m_thread_ids.empty()) {
2362 tid = m_thread_ids.front();
2363 }
2364 }
2365
2366 ThreadSP thread_sp = SetThreadStopInfo(
2367 tid, expedited_register_map, signo, thread_name, reason, description,
2368 exc_type, exc_data, thread_dispatch_qaddr, queue_vars_valid,
2369 associated_with_dispatch_queue, dispatch_queue_t, queue_name,
2370 queue_kind, queue_serial_number);
2371
2372 return eStateStopped;
2373 } break;
2374
2375 case 'W':
2376 case 'X':
2377 // process exited
2378 return eStateExited;
2379
2380 default:
2381 break;
2382 }
2383 return eStateInvalid;
2384}
2385
2386void ProcessGDBRemote::RefreshStateAfterStop() {
2387 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
2388
2389 m_thread_ids.clear();
2390 m_thread_pcs.clear();
2391 // Set the thread stop info. It might have a "threads" key whose value is
2392 // a list of all thread IDs in the current process, so m_thread_ids might
2393 // get set.
2394
2395 // Scope for the lock
2396 {
2397 // Lock the thread stack while we access it
2398 std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
2399 // Get the number of stop packets on the stack
2400 int nItems = m_stop_packet_stack.size();
2401 // Iterate over them
2402 for (int i = 0; i < nItems; i++) {
2403 // Get the thread stop info
2404 StringExtractorGDBRemote stop_info = m_stop_packet_stack[i];
2405 // Process thread stop info
2406 SetThreadStopInfo(stop_info);
2407 }
2408 // Clear the thread stop stack
2409 m_stop_packet_stack.clear();
2410 }
2411
2412 // Check to see if SetThreadStopInfo() filled in m_thread_ids?
2413 if (m_thread_ids.empty()) {
2414 // No, we need to fetch the thread list manually
2415 UpdateThreadIDList();
2416 }
2417
2418 // If we have queried for a default thread id
2419 if (m_initial_tid != LLDB_INVALID_THREAD_ID0) {
2420 m_thread_list.SetSelectedThreadByID(m_initial_tid);
2421 m_initial_tid = LLDB_INVALID_THREAD_ID0;
2422 }
2423
2424 // Let all threads recover from stopping and do any clean up based
2425 // on the previous thread state (if any).
2426 m_thread_list_real.RefreshStateAfterStop();
2427}
2428
2429Status ProcessGDBRemote::DoHalt(bool &caused_stop) {
2430 Status error;
2431
2432 if (m_public_state.GetValue() == eStateAttaching) {
2433 // We are being asked to halt during an attach. We need to just close
2434 // our file handle and debugserver will go away, and we can be done...
2435 m_gdb_comm.Disconnect();
2436 } else
2437 caused_stop = m_gdb_comm.Interrupt();
2438 return error;
2439}
2440
2441Status ProcessGDBRemote::DoDetach(bool keep_stopped) {
2442 Status error;
2443 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
2444 if (log)
2445 log->Printf("ProcessGDBRemote::DoDetach(keep_stopped: %i)", keep_stopped);
2446
2447 error = m_gdb_comm.Detach(keep_stopped);
2448 if (log) {
2449 if (error.Success())
2450 log->PutCString(
2451 "ProcessGDBRemote::DoDetach() detach packet sent successfully");
2452 else
2453 log->Printf("ProcessGDBRemote::DoDetach() detach packet send failed: %s",
2454 error.AsCString() ? error.AsCString() : "<unknown error>");
2455 }
2456
2457 if (!error.Success())
2458 return error;
2459
2460 // Sleep for one second to let the process get all detached...
2461 StopAsyncThread();
2462
2463 SetPrivateState(eStateDetached);
2464 ResumePrivateStateThread();
2465
2466 // KillDebugserverProcess ();
2467 return error;
2468}
2469
2470Status ProcessGDBRemote::DoDestroy() {
2471 Status error;
2472 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
2473 if (log)
2474 log->Printf("ProcessGDBRemote::DoDestroy()");
2475
2476 // There is a bug in older iOS debugservers where they don't shut down the
2477 // process
2478 // they are debugging properly. If the process is sitting at a breakpoint or
2479 // an exception,
2480 // this can cause problems with restarting. So we check to see if any of our
2481 // threads are stopped
2482 // at a breakpoint, and if so we remove all the breakpoints, resume the
2483 // process, and THEN
2484 // destroy it again.
2485 //
2486 // Note, we don't have a good way to test the version of debugserver, but I
2487 // happen to know that
2488 // the set of all the iOS debugservers which don't support
2489 // GetThreadSuffixSupported() and that of
2490 // the debugservers with this bug are equal. There really should be a better
2491 // way to test this!
2492 //
2493 // We also use m_destroy_tried_resuming to make sure we only do this once, if
2494 // we resume and then halt and
2495 // get called here to destroy again and we're still at a breakpoint or
2496 // exception, then we should
2497 // just do the straight-forward kill.
2498 //
2499 // And of course, if we weren't able to stop the process by the time we get
2500 // here, it isn't
2501 // necessary (or helpful) to do any of this.
2502
2503 if (!m_gdb_comm.GetThreadSuffixSupported() &&
2504 m_public_state.GetValue() != eStateRunning) {
2505 PlatformSP platform_sp = GetTarget().GetPlatform();
2506
2507 // FIXME: These should be ConstStrings so we aren't doing strcmp'ing.
2508 if (platform_sp && platform_sp->GetName() &&
2509 platform_sp->GetName() == PlatformRemoteiOS::GetPluginNameStatic()) {
2510 if (m_destroy_tried_resuming) {
2511 if (log)
2512 log->PutCString("ProcessGDBRemote::DoDestroy() - Tried resuming to "
2513 "destroy once already, not doing it again.");
2514 } else {
2515 // At present, the plans are discarded and the breakpoints disabled
2516 // Process::Destroy,
2517 // but we really need it to happen here and it doesn't matter if we do
2518 // it twice.
2519 m_thread_list.DiscardThreadPlans();
2520 DisableAllBreakpointSites();
2521
2522 bool stop_looks_like_crash = false;
2523 ThreadList &threads = GetThreadList();
2524
2525 {
2526 std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
2527
2528 size_t num_threads = threads.GetSize();
2529 for (size_t i = 0; i < num_threads; i++) {
2530 ThreadSP thread_sp = threads.GetThreadAtIndex(i);
2531 StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo();
2532 StopReason reason = eStopReasonInvalid;
2533 if (stop_info_sp)
2534 reason = stop_info_sp->GetStopReason();
2535 if (reason == eStopReasonBreakpoint ||
2536 reason == eStopReasonException) {
2537 if (log)
2538 log->Printf(
2539 "ProcessGDBRemote::DoDestroy() - thread: 0x%4.4" PRIx64"l" "x"
2540 " stopped with reason: %s.",
2541 thread_sp->GetProtocolID(), stop_info_sp->GetDescription());
2542 stop_looks_like_crash = true;
2543 break;
2544 }
2545 }
2546 }
2547
2548 if (stop_looks_like_crash) {
2549 if (log)
2550 log->PutCString("ProcessGDBRemote::DoDestroy() - Stopped at a "
2551 "breakpoint, continue and then kill.");
2552 m_destroy_tried_resuming = true;
2553
2554 // If we are going to run again before killing, it would be good to
2555 // suspend all the threads
2556 // before resuming so they won't get into more trouble. Sadly, for
2557 // the threads stopped with
2558 // the breakpoint or exception, the exception doesn't get cleared if
2559 // it is suspended, so we do
2560 // have to run the risk of letting those threads proceed a bit.
2561
2562 {
2563 std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
2564
2565 size_t num_threads = threads.GetSize();
2566 for (size_t i = 0; i < num_threads; i++) {
2567 ThreadSP thread_sp = threads.GetThreadAtIndex(i);
2568 StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo();
2569 StopReason reason = eStopReasonInvalid;
2570 if (stop_info_sp)
2571 reason = stop_info_sp->GetStopReason();
2572 if (reason != eStopReasonBreakpoint &&
2573 reason != eStopReasonException) {
2574 if (log)
2575 log->Printf("ProcessGDBRemote::DoDestroy() - Suspending "
2576 "thread: 0x%4.4" PRIx64"l" "x" " before running.",
2577 thread_sp->GetProtocolID());
2578 thread_sp->SetResumeState(eStateSuspended);
2579 }
2580 }
2581 }
2582 Resume();
2583 return Destroy(false);
2584 }
2585 }
2586 }
2587 }
2588
2589 // Interrupt if our inferior is running...
2590 int exit_status = SIGABRT6;
2591 std::string exit_string;
2592
2593 if (m_gdb_comm.IsConnected()) {
2594 if (m_public_state.GetValue() != eStateAttaching) {
2595 StringExtractorGDBRemote response;
2596 bool send_async = true;
2597 GDBRemoteCommunication::ScopedTimeout(m_gdb_comm,
2598 std::chrono::seconds(3));
2599
2600 if (m_gdb_comm.SendPacketAndWaitForResponse("k", response, send_async) ==
2601 GDBRemoteCommunication::PacketResult::Success) {
2602 char packet_cmd = response.GetChar(0);
2603
2604 if (packet_cmd == 'W' || packet_cmd == 'X') {
2605#if defined(__APPLE__)
2606 // For Native processes on Mac OS X, we launch through the Host
2607 // Platform, then hand the process off
2608 // to debugserver, which becomes the parent process through
2609 // "PT_ATTACH". Then when we go to kill
2610 // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then we
2611 // call waitpid which returns
2612 // with no error and the correct status. But amusingly enough that
2613 // doesn't seem to actually reap
2614 // the process, but instead it is left around as a Zombie. Probably
2615 // the kernel is in the process of
2616 // switching ownership back to lldb which was the original parent, and
2617 // gets confused in the handoff.
2618 // Anyway, so call waitpid here to finally reap it.
2619 PlatformSP platform_sp(GetTarget().GetPlatform());
2620 if (platform_sp && platform_sp->IsHost()) {
2621 int status;
2622 ::pid_t reap_pid;
2623 reap_pid = waitpid(GetID(), &status, WNOHANG1);
2624 if (log)
2625 log->Printf("Reaped pid: %d, status: %d.\n", reap_pid, status);
2626 }
2627#endif
2628 SetLastStopPacket(response);
2629 ClearThreadIDList();
2630 exit_status = response.GetHexU8();
2631 } else {
2632 if (log)
2633 log->Printf("ProcessGDBRemote::DoDestroy - got unexpected response "
2634 "to k packet: %s",
2635 response.GetStringRef().c_str());
2636 exit_string.assign("got unexpected response to k packet: ");
2637 exit_string.append(response.GetStringRef());
2638 }
2639 } else {
2640 if (log)
2641 log->Printf("ProcessGDBRemote::DoDestroy - failed to send k packet");
2642 exit_string.assign("failed to send the k packet");
2643 }
2644 } else {
2645 if (log)
2646 log->Printf("ProcessGDBRemote::DoDestroy - killed or interrupted while "
2647 "attaching");
2648 exit_string.assign("killed or interrupted while attaching.");
2649 }
2650 } else {
2651 // If we missed setting the exit status on the way out, do it here.
2652 // NB set exit status can be called multiple times, the first one sets the
2653 // status.
2654 exit_string.assign("destroying when not connected to debugserver");
2655 }
2656
2657 SetExitStatus(exit_status, exit_string.c_str());
2658
2659 StopAsyncThread();
2660 KillDebugserverProcess();
2661 return error;
2662}
2663
2664void ProcessGDBRemote::SetLastStopPacket(
2665 const StringExtractorGDBRemote &response) {
2666 const bool did_exec =
2667 response.GetStringRef().find(";reason:exec;") != std::string::npos;
2668 if (did_exec) {
2669 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
2670 if (log)
2671 log->Printf("ProcessGDBRemote::SetLastStopPacket () - detected exec");
2672
2673 m_thread_list_real.Clear();
2674 m_thread_list.Clear();
2675 BuildDynamicRegisterInfo(true);
2676 m_gdb_comm.ResetDiscoverableSettings(did_exec);
2677 }
2678
2679 // Scope the lock
2680 {
2681 // Lock the thread stack while we access it
2682 std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
2683
2684 // We are are not using non-stop mode, there can only be one last stop
2685 // reply packet, so clear the list.
2686 if (GetTarget().GetNonStopModeEnabled() == false)
2687 m_stop_packet_stack.clear();
2688
2689 // Add this stop packet to the stop packet stack
2690 // This stack will get popped and examined when we switch to the
2691 // Stopped state
2692 m_stop_packet_stack.push_back(response);
2693 }
2694}
2695
2696void ProcessGDBRemote::SetUnixSignals(const UnixSignalsSP &signals_sp) {
2697 Process::SetUnixSignals(std::make_shared<GDBRemoteSignals>(signals_sp));
2698}
2699
2700//------------------------------------------------------------------
2701// Process Queries
2702//------------------------------------------------------------------
2703
2704bool ProcessGDBRemote::IsAlive() {
2705 return m_gdb_comm.IsConnected() && Process::IsAlive();
2706}
2707
2708addr_t ProcessGDBRemote::GetImageInfoAddress() {
2709 // request the link map address via the $qShlibInfoAddr packet
2710 lldb::addr_t addr = m_gdb_comm.GetShlibInfoAddr();
2711
2712 // the loaded module list can also provides a link map address
2713 if (addr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
2714 LoadedModuleInfoList list;
2715 if (GetLoadedModuleList(list).Success())
2716 addr = list.m_link_map;
2717 }
2718
2719 return addr;
2720}
2721
2722void ProcessGDBRemote::WillPublicStop() {
2723 // See if the GDB remote client supports the JSON threads info.
2724 // If so, we gather stop info for all threads, expedited registers,
2725 // expedited memory, runtime queue information (iOS and MacOSX only),
2726 // and more. Expediting memory will help stack backtracing be much
2727 // faster. Expediting registers will make sure we don't have to read
2728 // the thread registers for GPRs.
2729 m_jthreadsinfo_sp = m_gdb_comm.GetThreadsInfo();
2730
2731 if (m_jthreadsinfo_sp) {
2732 // Now set the stop info for each thread and also expedite any registers
2733 // and memory that was in the jThreadsInfo response.
2734 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
2735 if (thread_infos) {
2736 const size_t n = thread_infos->GetSize();
2737 for (size_t i = 0; i < n; ++i) {
2738 StructuredData::Dictionary *thread_dict =
2739 thread_infos->GetItemAtIndex(i)->GetAsDictionary();
2740 if (thread_dict)
2741 SetThreadStopInfo(thread_dict);
2742 }
2743 }
2744 }
2745}
2746
2747//------------------------------------------------------------------
2748// Process Memory
2749//------------------------------------------------------------------
2750size_t ProcessGDBRemote::DoReadMemory(addr_t addr, void *buf, size_t size,
2751 Status &error) {
2752 GetMaxMemorySize();
2753 bool binary_memory_read = m_gdb_comm.GetxPacketSupported();
2754 // M and m packets take 2 bytes for 1 byte of memory
2755 size_t max_memory_size =
2756 binary_memory_read ? m_max_memory_size : m_max_memory_size / 2;
2757 if (size > max_memory_size) {
2758 // Keep memory read sizes down to a sane limit. This function will be
2759 // called multiple times in order to complete the task by
2760 // lldb_private::Process so it is ok to do this.
2761 size = max_memory_size;
2762 }
2763
2764 char packet[64];
2765 int packet_len;
2766 packet_len = ::snprintf(packet, sizeof(packet), "%c%" PRIx64"l" "x" ",%" PRIx64"l" "x",
2767 binary_memory_read ? 'x' : 'm', (uint64_t)addr,
2768 (uint64_t)size);
2769 assert(packet_len + 1 < (int)sizeof(packet))((packet_len + 1 < (int)sizeof(packet)) ? static_cast<void
> (0) : __assert_fail ("packet_len + 1 < (int)sizeof(packet)"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 2769, __PRETTY_FUNCTION__))
;
2770 UNUSED_IF_ASSERT_DISABLED(packet_len)((void)(packet_len));
2771 StringExtractorGDBRemote response;
2772 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response, true) ==
2773 GDBRemoteCommunication::PacketResult::Success) {
2774 if (response.IsNormalResponse()) {
2775 error.Clear();
2776 if (binary_memory_read) {
2777 // The lower level GDBRemoteCommunication packet receive layer has
2778 // already de-quoted any
2779 // 0x7d character escaping that was present in the packet
2780
2781 size_t data_received_size = response.GetBytesLeft();
2782 if (data_received_size > size) {
2783 // Don't write past the end of BUF if the remote debug server gave us
2784 // too
2785 // much data for some reason.
2786 data_received_size = size;
2787 }
2788 memcpy(buf, response.GetStringRef().data(), data_received_size);
2789 return data_received_size;
2790 } else {
2791 return response.GetHexBytes(
2792 llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, size), '\xdd');
2793 }
2794 } else if (response.IsErrorResponse())
2795 error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64"l" "x", addr);
2796 else if (response.IsUnsupportedResponse())
2797 error.SetErrorStringWithFormat(
2798 "GDB server does not support reading memory");
2799 else
2800 error.SetErrorStringWithFormat(
2801 "unexpected response to GDB server memory read packet '%s': '%s'",
2802 packet, response.GetStringRef().c_str());
2803 } else {
2804 error.SetErrorStringWithFormat("failed to send packet: '%s'", packet);
2805 }
2806 return 0;
2807}
2808
2809size_t ProcessGDBRemote::DoWriteMemory(addr_t addr, const void *buf,
2810 size_t size, Status &error) {
2811 GetMaxMemorySize();
2812 // M and m packets take 2 bytes for 1 byte of memory
2813 size_t max_memory_size = m_max_memory_size / 2;
2814 if (size > max_memory_size) {
2815 // Keep memory read sizes down to a sane limit. This function will be
2816 // called multiple times in order to complete the task by
2817 // lldb_private::Process so it is ok to do this.
2818 size = max_memory_size;
2819 }
2820
2821 StreamString packet;
2822 packet.Printf("M%" PRIx64"l" "x" ",%" PRIx64"l" "x" ":", addr, (uint64_t)size);
2823 packet.PutBytesAsRawHex8(buf, size, endian::InlHostByteOrder(),
2824 endian::InlHostByteOrder());
2825 StringExtractorGDBRemote response;
2826 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
2827 true) ==
2828 GDBRemoteCommunication::PacketResult::Success) {
2829 if (response.IsOKResponse()) {
2830 error.Clear();
2831 return size;
2832 } else if (response.IsErrorResponse())
2833 error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64"l" "x",
2834 addr);
2835 else if (response.IsUnsupportedResponse())
2836 error.SetErrorStringWithFormat(
2837 "GDB server does not support writing memory");
2838 else
2839 error.SetErrorStringWithFormat(
2840 "unexpected response to GDB server memory write packet '%s': '%s'",
2841 packet.GetData(), response.GetStringRef().c_str());
2842 } else {
2843 error.SetErrorStringWithFormat("failed to send packet: '%s'",
2844 packet.GetData());
2845 }
2846 return 0;
2847}
2848
2849lldb::addr_t ProcessGDBRemote::DoAllocateMemory(size_t size,
2850 uint32_t permissions,
2851 Status &error) {
2852 Log *log(
2853 GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
2854 addr_t allocated_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2855
2856 if (m_gdb_comm.SupportsAllocDeallocMemory() != eLazyBoolNo) {
2857 allocated_addr = m_gdb_comm.AllocateMemory(size, permissions);
2858 if (allocated_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL) ||
2859 m_gdb_comm.SupportsAllocDeallocMemory() == eLazyBoolYes)
2860 return allocated_addr;
2861 }
2862
2863 if (m_gdb_comm.SupportsAllocDeallocMemory() == eLazyBoolNo) {
2864 // Call mmap() to create memory in the inferior..
2865 unsigned prot = 0;
2866 if (permissions & lldb::ePermissionsReadable)
2867 prot |= eMmapProtRead;
2868 if (permissions & lldb::ePermissionsWritable)
2869 prot |= eMmapProtWrite;
2870 if (permissions & lldb::ePermissionsExecutable)
2871 prot |= eMmapProtExec;
2872
2873 if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
2874 eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0))
2875 m_addr_to_mmap_size[allocated_addr] = size;
2876 else {
2877 allocated_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
2878 if (log)
2879 log->Printf("ProcessGDBRemote::%s no direct stub support for memory "
2880 "allocation, and InferiorCallMmap also failed - is stub "
2881 "missing register context save/restore capability?",
2882 __FUNCTION__);
2883 }
2884 }
2885
2886 if (allocated_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL))
2887 error.SetErrorStringWithFormat(
2888 "unable to allocate %" PRIu64"l" "u" " bytes of memory with permissions %s",
2889 (uint64_t)size, GetPermissionsAsCString(permissions));
2890 else
2891 error.Clear();
2892 return allocated_addr;
2893}
2894
2895Status ProcessGDBRemote::GetMemoryRegionInfo(addr_t load_addr,
2896 MemoryRegionInfo &region_info) {
2897
2898 Status error(m_gdb_comm.GetMemoryRegionInfo(load_addr, region_info));
2899 return error;
2900}
2901
2902Status ProcessGDBRemote::GetWatchpointSupportInfo(uint32_t &num) {
2903
2904 Status error(m_gdb_comm.GetWatchpointSupportInfo(num));
2905 return error;
2906}
2907
2908Status ProcessGDBRemote::GetWatchpointSupportInfo(uint32_t &num, bool &after) {
2909 Status error(m_gdb_comm.GetWatchpointSupportInfo(
2910 num, after, GetTarget().GetArchitecture()));
2911 return error;
2912}
2913
2914Status ProcessGDBRemote::DoDeallocateMemory(lldb::addr_t addr) {
2915 Status error;
2916 LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();
2917
2918 switch (supported) {
2919 case eLazyBoolCalculate:
2920 // We should never be deallocating memory without allocating memory
2921 // first so we should never get eLazyBoolCalculate
2922 error.SetErrorString(
2923 "tried to deallocate memory without ever allocating memory");
2924 break;
2925
2926 case eLazyBoolYes:
2927 if (!m_gdb_comm.DeallocateMemory(addr))
2928 error.SetErrorStringWithFormat(
2929 "unable to deallocate memory at 0x%" PRIx64"l" "x", addr);
2930 break;
2931
2932 case eLazyBoolNo:
2933 // Call munmap() to deallocate memory in the inferior..
2934 {
2935 MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
2936 if (pos != m_addr_to_mmap_size.end() &&
2937 InferiorCallMunmap(this, addr, pos->second))
2938 m_addr_to_mmap_size.erase(pos);
2939 else
2940 error.SetErrorStringWithFormat(
2941 "unable to deallocate memory at 0x%" PRIx64"l" "x", addr);
2942 }
2943 break;
2944 }
2945
2946 return error;
2947}
2948
2949//------------------------------------------------------------------
2950// Process STDIO
2951//------------------------------------------------------------------
2952size_t ProcessGDBRemote::PutSTDIN(const char *src, size_t src_len,
2953 Status &error) {
2954 if (m_stdio_communication.IsConnected()) {
2955 ConnectionStatus status;
2956 m_stdio_communication.Write(src, src_len, status, NULL__null);
2957 } else if (m_stdin_forward) {
2958 m_gdb_comm.SendStdinNotification(src, src_len);
2959 }
2960 return 0;
2961}
2962
2963Status ProcessGDBRemote::EnableBreakpointSite(BreakpointSite *bp_site) {
2964 Status error;
2965 assert(bp_site != NULL)((bp_site != __null) ? static_cast<void> (0) : __assert_fail
("bp_site != NULL", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 2965, __PRETTY_FUNCTION__))
;
2966
2967 // Get logging info
2968 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS(1u << 7)));
2969 user_id_t site_id = bp_site->GetID();
2970
2971 // Get the breakpoint address
2972 const addr_t addr = bp_site->GetLoadAddress();
2973
2974 // Log that a breakpoint was requested
2975 if (log)
2976 log->Printf("ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64"l" "u"
2977 ") address = 0x%" PRIx64"l" "x",
2978 site_id, (uint64_t)addr);
2979
2980 // Breakpoint already exists and is enabled
2981 if (bp_site->IsEnabled()) {
2982 if (log)
2983 log->Printf("ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64"l" "u"
2984 ") address = 0x%" PRIx64"l" "x" " -- SUCCESS (already enabled)",
2985 site_id, (uint64_t)addr);
2986 return error;
2987 }
2988
2989 // Get the software breakpoint trap opcode size
2990 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
2991
2992 // SupportsGDBStoppointPacket() simply checks a boolean, indicating if this
2993 // breakpoint type
2994 // is supported by the remote stub. These are set to true by default, and
2995 // later set to false
2996 // only after we receive an unimplemented response when sending a breakpoint
2997 // packet. This means
2998 // initially that unless we were specifically instructed to use a hardware
2999 // breakpoint, LLDB will
3000 // attempt to set a software breakpoint. HardwareRequired() also queries a
3001 // boolean variable which
3002 // indicates if the user specifically asked for hardware breakpoints. If true
3003 // then we will
3004 // skip over software breakpoints.
3005 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware) &&
3006 (!bp_site->HardwareRequired())) {
3007 // Try to send off a software breakpoint packet ($Z0)
3008 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3009 eBreakpointSoftware, true, addr, bp_op_size);
3010 if (error_no == 0) {
3011 // The breakpoint was placed successfully
3012 bp_site->SetEnabled(true);
3013 bp_site->SetType(BreakpointSite::eExternal);
3014 return error;
3015 }
3016
3017 // SendGDBStoppointTypePacket() will return an error if it was unable to set
3018 // this
3019 // breakpoint. We need to differentiate between a error specific to placing
3020 // this breakpoint
3021 // or if we have learned that this breakpoint type is unsupported. To do
3022 // this, we
3023 // must test the support boolean for this breakpoint type to see if it now
3024 // indicates that
3025 // this breakpoint type is unsupported. If they are still supported then we
3026 // should return
3027 // with the error code. If they are now unsupported, then we would like to
3028 // fall through
3029 // and try another form of breakpoint.
3030 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware)) {
3031 if (error_no != UINT8_MAX(255))
3032 error.SetErrorStringWithFormat(
3033 "error: %d sending the breakpoint request", errno(*__errno_location ()));
3034 else
3035 error.SetErrorString("error sending the breakpoint request");
3036 return error;
3037 }
3038
3039 // We reach here when software breakpoints have been found to be
3040 // unsupported. For future
3041 // calls to set a breakpoint, we will not attempt to set a breakpoint with a
3042 // type that is
3043 // known not to be supported.
3044 if (log)
3045 log->Printf("Software breakpoints are unsupported");
3046
3047 // So we will fall through and try a hardware breakpoint
3048 }
3049
3050 // The process of setting a hardware breakpoint is much the same as above. We
3051 // check the
3052 // supported boolean for this breakpoint type, and if it is thought to be
3053 // supported then we
3054 // will try to set this breakpoint with a hardware breakpoint.
3055 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointHardware)) {
3056 // Try to send off a hardware breakpoint packet ($Z1)
3057 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3058 eBreakpointHardware, true, addr, bp_op_size);
3059 if (error_no == 0) {
3060 // The breakpoint was placed successfully
3061 bp_site->SetEnabled(true);
3062 bp_site->SetType(BreakpointSite::eHardware);
3063 return error;
3064 }
3065
3066 // Check if the error was something other then an unsupported breakpoint
3067 // type
3068 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointHardware)) {
3069 // Unable to set this hardware breakpoint
3070 if (error_no != UINT8_MAX(255))
3071 error.SetErrorStringWithFormat(
3072 "error: %d sending the hardware breakpoint request "
3073 "(hardware breakpoint resources might be exhausted or unavailable)",
3074 error_no);
3075 else
3076 error.SetErrorString("error sending the hardware breakpoint request "
3077 "(hardware breakpoint resources "
3078 "might be exhausted or unavailable)");
3079 return error;
3080 }
3081
3082 // We will reach here when the stub gives an unsupported response to a
3083 // hardware breakpoint
3084 if (log)
3085 log->Printf("Hardware breakpoints are unsupported");
3086
3087 // Finally we will falling through to a #trap style breakpoint
3088 }
3089
3090 // Don't fall through when hardware breakpoints were specifically requested
3091 if (bp_site->HardwareRequired()) {
3092 error.SetErrorString("hardware breakpoints are not supported");
3093 return error;
3094 }
3095
3096 // As a last resort we want to place a manual breakpoint. An instruction
3097 // is placed into the process memory using memory write packets.
3098 return EnableSoftwareBreakpoint(bp_site);
3099}
3100
3101Status ProcessGDBRemote::DisableBreakpointSite(BreakpointSite *bp_site) {
3102 Status error;
3103 assert(bp_site != NULL)((bp_site != __null) ? static_cast<void> (0) : __assert_fail
("bp_site != NULL", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 3103, __PRETTY_FUNCTION__))
;
3104 addr_t addr = bp_site->GetLoadAddress();
3105 user_id_t site_id = bp_site->GetID();
3106 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS(1u << 7)));
3107 if (log)
3108 log->Printf("ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64"l" "u"
3109 ") addr = 0x%8.8" PRIx64"l" "x",
3110 site_id, (uint64_t)addr);
3111
3112 if (bp_site->IsEnabled()) {
3113 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
3114
3115 BreakpointSite::Type bp_type = bp_site->GetType();
3116 switch (bp_type) {
3117 case BreakpointSite::eSoftware:
3118 error = DisableSoftwareBreakpoint(bp_site);
3119 break;
3120
3121 case BreakpointSite::eHardware:
3122 if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointHardware, false,
3123 addr, bp_op_size))
3124 error.SetErrorToGenericError();
3125 break;
3126
3127 case BreakpointSite::eExternal: {
3128 GDBStoppointType stoppoint_type;
3129 if (bp_site->IsHardware())
3130 stoppoint_type = eBreakpointHardware;
3131 else
3132 stoppoint_type = eBreakpointSoftware;
3133
3134 if (m_gdb_comm.SendGDBStoppointTypePacket(stoppoint_type, false, addr,
3135 bp_op_size))
3136 error.SetErrorToGenericError();
3137 } break;
3138 }
3139 if (error.Success())
3140 bp_site->SetEnabled(false);
3141 } else {
3142 if (log)
3143 log->Printf("ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64"l" "u"
3144 ") addr = 0x%8.8" PRIx64"l" "x" " -- SUCCESS (already disabled)",
3145 site_id, (uint64_t)addr);
3146 return error;
3147 }
3148
3149 if (error.Success())
3150 error.SetErrorToGenericError();
3151 return error;
3152}
3153
3154// Pre-requisite: wp != NULL.
3155static GDBStoppointType GetGDBStoppointType(Watchpoint *wp) {
3156 assert(wp)((wp) ? static_cast<void> (0) : __assert_fail ("wp", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 3156, __PRETTY_FUNCTION__))
;
3157 bool watch_read = wp->WatchpointRead();
3158 bool watch_write = wp->WatchpointWrite();
3159
3160 // watch_read and watch_write cannot both be false.
3161 assert(watch_read || watch_write)((watch_read || watch_write) ? static_cast<void> (0) : __assert_fail
("watch_read || watch_write", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 3161, __PRETTY_FUNCTION__))
;
3162 if (watch_read && watch_write)
3163 return eWatchpointReadWrite;
3164 else if (watch_read)
3165 return eWatchpointRead;
3166 else // Must be watch_write, then.
3167 return eWatchpointWrite;
3168}
3169
3170Status ProcessGDBRemote::EnableWatchpoint(Watchpoint *wp, bool notify) {
3171 Status error;
3172 if (wp) {
3173 user_id_t watchID = wp->GetID();
3174 addr_t addr = wp->GetLoadAddress();
3175 Log *log(
3176 ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS(1u << 8)));
3177 if (log)
3178 log->Printf("ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64"l" "u" ")",
3179 watchID);
3180 if (wp->IsEnabled()) {
3181 if (log)
3182 log->Printf("ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64"l" "u"
3183 ") addr = 0x%8.8" PRIx64"l" "x" ": watchpoint already enabled.",
3184 watchID, (uint64_t)addr);
3185 return error;
3186 }
3187
3188 GDBStoppointType type = GetGDBStoppointType(wp);
3189 // Pass down an appropriate z/Z packet...
3190 if (m_gdb_comm.SupportsGDBStoppointPacket(type)) {
3191 if (m_gdb_comm.SendGDBStoppointTypePacket(type, true, addr,
3192 wp->GetByteSize()) == 0) {
3193 wp->SetEnabled(true, notify);
3194 return error;
3195 } else
3196 error.SetErrorString("sending gdb watchpoint packet failed");
3197 } else
3198 error.SetErrorString("watchpoints not supported");
3199 } else {
3200 error.SetErrorString("Watchpoint argument was NULL.");
3201 }
3202 if (error.Success())
3203 error.SetErrorToGenericError();
3204 return error;
3205}
3206
3207Status ProcessGDBRemote::DisableWatchpoint(Watchpoint *wp, bool notify) {
3208 Status error;
3209 if (wp) {
3210 user_id_t watchID = wp->GetID();
3211
3212 Log *log(
3213 ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS(1u << 8)));
3214
3215 addr_t addr = wp->GetLoadAddress();
3216
3217 if (log)
3218 log->Printf("ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64"l" "u"
3219 ") addr = 0x%8.8" PRIx64"l" "x",
3220 watchID, (uint64_t)addr);
3221
3222 if (!wp->IsEnabled()) {
3223 if (log)
3224 log->Printf("ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64"l" "u"
3225 ") addr = 0x%8.8" PRIx64"l" "x" " -- SUCCESS (already disabled)",
3226 watchID, (uint64_t)addr);
3227 // See also 'class WatchpointSentry' within StopInfo.cpp.
3228 // This disabling attempt might come from the user-supplied actions, we'll
3229 // route it in order for
3230 // the watchpoint object to intelligently process this action.
3231 wp->SetEnabled(false, notify);
3232 return error;
3233 }
3234
3235 if (wp->IsHardware()) {
3236 GDBStoppointType type = GetGDBStoppointType(wp);
3237 // Pass down an appropriate z/Z packet...
3238 if (m_gdb_comm.SendGDBStoppointTypePacket(type, false, addr,
3239 wp->GetByteSize()) == 0) {
3240 wp->SetEnabled(false, notify);
3241 return error;
3242 } else
3243 error.SetErrorString("sending gdb watchpoint packet failed");
3244 }
3245 // TODO: clear software watchpoints if we implement them
3246 } else {
3247 error.SetErrorString("Watchpoint argument was NULL.");
3248 }
3249 if (error.Success())
3250 error.SetErrorToGenericError();
3251 return error;
3252}
3253
3254void ProcessGDBRemote::Clear() {
3255 m_flags = 0;
3256 m_thread_list_real.Clear();
3257 m_thread_list.Clear();
3258}
3259
3260Status ProcessGDBRemote::DoSignal(int signo) {
3261 Status error;
3262 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3263 if (log)
3264 log->Printf("ProcessGDBRemote::DoSignal (signal = %d)", signo);
3265
3266 if (!m_gdb_comm.SendAsyncSignal(signo))
3267 error.SetErrorStringWithFormat("failed to send signal %i", signo);
3268 return error;
3269}
3270
3271Status
3272ProcessGDBRemote::EstablishConnectionIfNeeded(const ProcessInfo &process_info) {
3273 // Make sure we aren't already connected?
3274 if (m_gdb_comm.IsConnected())
3275 return Status();
3276
3277 PlatformSP platform_sp(GetTarget().GetPlatform());
3278 if (platform_sp && !platform_sp->IsHost())
3279 return Status("Lost debug server connection");
3280
3281 auto error = LaunchAndConnectToDebugserver(process_info);
3282 if (error.Fail()) {
3283 const char *error_string = error.AsCString();
3284 if (error_string == nullptr)
3285 error_string = "unable to launch " DEBUGSERVER_BASENAME"debugserver";
Value stored to 'error_string' is never read
3286 }
3287 return error;
3288}
3289#if defined(__APPLE__)
3290#define USE_SOCKETPAIR_FOR_LOCAL_CONNECTION 1
3291#endif
3292
3293#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3294static bool SetCloexecFlag(int fd) {
3295#if defined(FD_CLOEXEC1)
3296 int flags = ::fcntl(fd, F_GETFD1);
3297 if (flags == -1)
3298 return false;
3299 return (::fcntl(fd, F_SETFD2, flags | FD_CLOEXEC1) == 0);
3300#else
3301 return false;
3302#endif
3303}
3304#endif
3305
3306Status ProcessGDBRemote::LaunchAndConnectToDebugserver(
3307 const ProcessInfo &process_info) {
3308 using namespace std::placeholders; // For _1, _2, etc.
3309
3310 Status error;
3311 if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID0) {
3312 // If we locate debugserver, keep that located version around
3313 static FileSpec g_debugserver_file_spec;
3314
3315 ProcessLaunchInfo debugserver_launch_info;
3316 // Make debugserver run in its own session so signals generated by
3317 // special terminal key sequences (^C) don't affect debugserver.
3318 debugserver_launch_info.SetLaunchInSeparateProcessGroup(true);
3319
3320 const std::weak_ptr<ProcessGDBRemote> this_wp =
3321 std::static_pointer_cast<ProcessGDBRemote>(shared_from_this());
3322 debugserver_launch_info.SetMonitorProcessCallback(
3323 std::bind(MonitorDebugserverProcess, this_wp, _1, _2, _3, _4), false);
3324 debugserver_launch_info.SetUserID(process_info.GetUserID());
3325
3326 int communication_fd = -1;
3327#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3328 // Auto close the sockets we might open up unless everything goes OK. This
3329 // helps us not leak file descriptors when things go wrong.
3330 lldb_utility::CleanUp<int, int> our_socket(-1, -1, close);
3331 lldb_utility::CleanUp<int, int> gdb_socket(-1, -1, close);
3332
3333 // Use a socketpair on Apple for now until other platforms can verify it
3334 // works and is fast enough
3335 {
3336 int sockets[2]; /* the pair of socket descriptors */
3337 if (socketpair(AF_UNIX1, SOCK_STREAMSOCK_STREAM, 0, sockets) == -1) {
3338 error.SetErrorToErrno();
3339 return error;
3340 }
3341
3342 our_socket.set(sockets[0]);
3343 gdb_socket.set(sockets[1]);
3344 }
3345
3346 // Don't let any child processes inherit our communication socket
3347 SetCloexecFlag(our_socket.get());
3348 communication_fd = gdb_socket.get();
3349#endif
3350
3351 error = m_gdb_comm.StartDebugserverProcess(
3352 nullptr, GetTarget().GetPlatform().get(), debugserver_launch_info,
3353 nullptr, nullptr, communication_fd);
3354
3355 if (error.Success())
3356 m_debugserver_pid = debugserver_launch_info.GetProcessID();
3357 else
3358 m_debugserver_pid = LLDB_INVALID_PROCESS_ID0;
3359
3360 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID0) {
3361#ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3362 // Our process spawned correctly, we can now set our connection to use our
3363 // end of the socket pair
3364 m_gdb_comm.SetConnection(
3365 new ConnectionFileDescriptor(our_socket.release(), true));
3366#endif
3367 StartAsyncThread();
3368 }
3369
3370 if (error.Fail()) {
3371 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3372
3373 if (log)
3374 log->Printf("failed to start debugserver process: %s",
3375 error.AsCString());
3376 return error;
3377 }
3378
3379 if (m_gdb_comm.IsConnected()) {
3380 // Finish the connection process by doing the handshake without connecting
3381 // (send NULL URL)
3382 ConnectToDebugserver("");
3383 } else {
3384 error.SetErrorString("connection failed");
3385 }
3386 }
3387 return error;
3388}
3389
3390bool ProcessGDBRemote::MonitorDebugserverProcess(
3391 std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid,
3392 bool exited, // True if the process did exit
3393 int signo, // Zero for no signal
3394 int exit_status // Exit value of process if signal is zero
3395 ) {
3396 // "debugserver_pid" argument passed in is the process ID for
3397 // debugserver that we are tracking...
3398 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3399 const bool handled = true;
3400
3401 if (log)
3402 log->Printf("ProcessGDBRemote::%s(process_wp, pid=%" PRIu64"l" "u"
3403 ", signo=%i (0x%x), exit_status=%i)",
3404 __FUNCTION__, debugserver_pid, signo, signo, exit_status);
3405
3406 std::shared_ptr<ProcessGDBRemote> process_sp = process_wp.lock();
3407 if (log)
3408 log->Printf("ProcessGDBRemote::%s(process = %p)", __FUNCTION__,
3409 static_cast<void *>(process_sp.get()));
3410 if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
3411 return handled;
3412
3413 // Sleep for a half a second to make sure our inferior process has
3414 // time to set its exit status before we set it incorrectly when
3415 // both the debugserver and the inferior process shut down.
3416 usleep(500000);
3417 // If our process hasn't yet exited, debugserver might have died.
3418 // If the process did exit, then we are reaping it.
3419 const StateType state = process_sp->GetState();
3420
3421 if (state != eStateInvalid && state != eStateUnloaded &&
3422 state != eStateExited && state != eStateDetached) {
3423 char error_str[1024];
3424 if (signo) {
3425 const char *signal_cstr =
3426 process_sp->GetUnixSignals()->GetSignalAsCString(signo);
3427 if (signal_cstr)
3428 ::snprintf(error_str, sizeof(error_str),
3429 DEBUGSERVER_BASENAME"debugserver" " died with signal %s", signal_cstr);
3430 else
3431 ::snprintf(error_str, sizeof(error_str),
3432 DEBUGSERVER_BASENAME"debugserver" " died with signal %i", signo);
3433 } else {
3434 ::snprintf(error_str, sizeof(error_str),
3435 DEBUGSERVER_BASENAME"debugserver" " died with an exit status of 0x%8.8x",
3436 exit_status);
3437 }
3438
3439 process_sp->SetExitStatus(-1, error_str);
3440 }
3441 // Debugserver has exited we need to let our ProcessGDBRemote
3442 // know that it no longer has a debugserver instance
3443 process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID0;
3444 return handled;
3445}
3446
3447void ProcessGDBRemote::KillDebugserverProcess() {
3448 m_gdb_comm.Disconnect();
3449 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID0) {
3450 Host::Kill(m_debugserver_pid, SIGINT2);
3451 m_debugserver_pid = LLDB_INVALID_PROCESS_ID0;
3452 }
3453}
3454
3455void ProcessGDBRemote::Initialize() {
3456 static llvm::once_flag g_once_flag;
3457
3458 llvm::call_once(g_once_flag, []() {
3459 PluginManager::RegisterPlugin(GetPluginNameStatic(),
3460 GetPluginDescriptionStatic(), CreateInstance,
3461 DebuggerInitialize);
3462 });
3463}
3464
3465void ProcessGDBRemote::DebuggerInitialize(Debugger &debugger) {
3466 if (!PluginManager::GetSettingForProcessPlugin(
3467 debugger, PluginProperties::GetSettingName())) {
3468 const bool is_global_setting = true;
3469 PluginManager::CreateSettingForProcessPlugin(
3470 debugger, GetGlobalPluginProperties()->GetValueProperties(),
3471 ConstString("Properties for the gdb-remote process plug-in."),
3472 is_global_setting);
3473 }
3474}
3475
3476bool ProcessGDBRemote::StartAsyncThread() {
3477 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3478
3479 if (log)
3480 log->Printf("ProcessGDBRemote::%s ()", __FUNCTION__);
3481
3482 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3483 if (!m_async_thread.IsJoinable()) {
3484 // Create a thread that watches our internal state and controls which
3485 // events make it to clients (into the DCProcess event queue).
3486
3487 m_async_thread =
3488 ThreadLauncher::LaunchThread("<lldb.process.gdb-remote.async>",
3489 ProcessGDBRemote::AsyncThread, this, NULL__null);
3490 } else if (log)
3491 log->Printf("ProcessGDBRemote::%s () - Called when Async thread was "
3492 "already running.",
3493 __FUNCTION__);
3494
3495 return m_async_thread.IsJoinable();
3496}
3497
3498void ProcessGDBRemote::StopAsyncThread() {
3499 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3500
3501 if (log)
3502 log->Printf("ProcessGDBRemote::%s ()", __FUNCTION__);
3503
3504 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3505 if (m_async_thread.IsJoinable()) {
3506 m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncThreadShouldExit);
3507
3508 // This will shut down the async thread.
3509 m_gdb_comm.Disconnect(); // Disconnect from the debug server.
3510
3511 // Stop the stdio thread
3512 m_async_thread.Join(nullptr);
3513 m_async_thread.Reset();
3514 } else if (log)
3515 log->Printf(
3516 "ProcessGDBRemote::%s () - Called when Async thread was not running.",
3517 __FUNCTION__);
3518}
3519
3520bool ProcessGDBRemote::HandleNotifyPacket(StringExtractorGDBRemote &packet) {
3521 // get the packet at a string
3522 const std::string &pkt = packet.GetStringRef();
3523 // skip %stop:
3524 StringExtractorGDBRemote stop_info(pkt.c_str() + 5);
3525
3526 // pass as a thread stop info packet
3527 SetLastStopPacket(stop_info);
3528
3529 // check for more stop reasons
3530 HandleStopReplySequence();
3531
3532 // if the process is stopped then we need to fake a resume
3533 // so that we can stop properly with the new break. This
3534 // is possible due to SetPrivateState() broadcasting the
3535 // state change as a side effect.
3536 if (GetPrivateState() == lldb::StateType::eStateStopped) {
3537 SetPrivateState(lldb::StateType::eStateRunning);
3538 }
3539
3540 // since we have some stopped packets we can halt the process
3541 SetPrivateState(lldb::StateType::eStateStopped);
3542
3543 return true;
3544}
3545
3546thread_result_t ProcessGDBRemote::AsyncThread(void *arg) {
3547 ProcessGDBRemote *process = (ProcessGDBRemote *)arg;
3548
3549 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3550 if (log)
3551 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3552 ") thread starting...",
3553 __FUNCTION__, arg, process->GetID());
3554
3555 EventSP event_sp;
3556 bool done = false;
3557 while (!done) {
3558 if (log)
3559 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3560 ") listener.WaitForEvent (NULL, event_sp)...",
3561 __FUNCTION__, arg, process->GetID());
3562 if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
3563 const uint32_t event_type = event_sp->GetType();
3564 if (event_sp->BroadcasterIs(&process->m_async_broadcaster)) {
3565 if (log)
3566 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3567 ") Got an event of type: %d...",
3568 __FUNCTION__, arg, process->GetID(), event_type);
3569
3570 switch (event_type) {
3571 case eBroadcastBitAsyncContinue: {
3572 const EventDataBytes *continue_packet =
3573 EventDataBytes::GetEventDataFromEvent(event_sp.get());
3574
3575 if (continue_packet) {
3576 const char *continue_cstr =
3577 (const char *)continue_packet->GetBytes();
3578 const size_t continue_cstr_len = continue_packet->GetByteSize();
3579 if (log)
3580 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3581 ") got eBroadcastBitAsyncContinue: %s",
3582 __FUNCTION__, arg, process->GetID(), continue_cstr);
3583
3584 if (::strstr(continue_cstr, "vAttach") == NULL__null)
3585 process->SetPrivateState(eStateRunning);
3586 StringExtractorGDBRemote response;
3587
3588 // If in Non-Stop-Mode
3589 if (process->GetTarget().GetNonStopModeEnabled()) {
3590 // send the vCont packet
3591 if (!process->GetGDBRemote().SendvContPacket(
3592 llvm::StringRef(continue_cstr, continue_cstr_len),
3593 response)) {
3594 // Something went wrong
3595 done = true;
3596 break;
3597 }
3598 }
3599 // If in All-Stop-Mode
3600 else {
3601 StateType stop_state =
3602 process->GetGDBRemote().SendContinuePacketAndWaitForResponse(
3603 *process, *process->GetUnixSignals(),
3604 llvm::StringRef(continue_cstr, continue_cstr_len),
3605 response);
3606
3607 // We need to immediately clear the thread ID list so we are sure
3608 // to get a valid list of threads.
3609 // The thread ID list might be contained within the "response", or
3610 // the stop reply packet that
3611 // caused the stop. So clear it now before we give the stop reply
3612 // packet to the process
3613 // using the process->SetLastStopPacket()...
3614 process->ClearThreadIDList();
3615
3616 switch (stop_state) {
3617 case eStateStopped:
3618 case eStateCrashed:
3619 case eStateSuspended:
3620 process->SetLastStopPacket(response);
3621 process->SetPrivateState(stop_state);
3622 break;
3623
3624 case eStateExited: {
3625 process->SetLastStopPacket(response);
3626 process->ClearThreadIDList();
3627 response.SetFilePos(1);
3628
3629 int exit_status = response.GetHexU8();
3630 std::string desc_string;
3631 if (response.GetBytesLeft() > 0 &&
3632 response.GetChar('-') == ';') {
3633 llvm::StringRef desc_str;
3634 llvm::StringRef desc_token;
3635 while (response.GetNameColonValue(desc_token, desc_str)) {
3636 if (desc_token != "description")
3637 continue;
3638 StringExtractor extractor(desc_str);
3639 extractor.GetHexByteString(desc_string);
3640 }
3641 }
3642 process->SetExitStatus(exit_status, desc_string.c_str());
3643 done = true;
3644 break;
3645 }
3646 case eStateInvalid: {
3647 // Check to see if we were trying to attach and if we got back
3648 // the "E87" error code from debugserver -- this indicates that
3649 // the process is not debuggable. Return a slightly more
3650 // helpful
3651 // error message about why the attach failed.
3652 if (::strstr(continue_cstr, "vAttach") != NULL__null &&
3653 response.GetError() == 0x87) {
3654 process->SetExitStatus(-1, "cannot attach to process due to "
3655 "System Integrity Protection");
3656 }
3657 // E01 code from vAttach means that the attach failed
3658 if (::strstr(continue_cstr, "vAttach") != NULL__null &&
3659 response.GetError() == 0x1) {
3660 process->SetExitStatus(-1, "unable to attach");
3661 } else {
3662 process->SetExitStatus(-1, "lost connection");
3663 }
3664 break;
3665 }
3666
3667 default:
3668 process->SetPrivateState(stop_state);
3669 break;
3670 } // switch(stop_state)
3671 } // else // if in All-stop-mode
3672 } // if (continue_packet)
3673 } // case eBroadcastBitAysncContinue
3674 break;
3675
3676 case eBroadcastBitAsyncThreadShouldExit:
3677 if (log)
3678 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3679 ") got eBroadcastBitAsyncThreadShouldExit...",
3680 __FUNCTION__, arg, process->GetID());
3681 done = true;
3682 break;
3683
3684 default:
3685 if (log)
3686 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3687 ") got unknown event 0x%8.8x",
3688 __FUNCTION__, arg, process->GetID(), event_type);
3689 done = true;
3690 break;
3691 }
3692 } else if (event_sp->BroadcasterIs(&process->m_gdb_comm)) {
3693 switch (event_type) {
3694 case Communication::eBroadcastBitReadThreadDidExit:
3695 process->SetExitStatus(-1, "lost connection");
3696 done = true;
3697 break;
3698
3699 case GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify: {
3700 lldb_private::Event *event = event_sp.get();
3701 const EventDataBytes *continue_packet =
3702 EventDataBytes::GetEventDataFromEvent(event);
3703 StringExtractorGDBRemote notify(
3704 (const char *)continue_packet->GetBytes());
3705 // Hand this over to the process to handle
3706 process->HandleNotifyPacket(notify);
3707 break;
3708 }
3709
3710 default:
3711 if (log)
3712 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3713 ") got unknown event 0x%8.8x",
3714 __FUNCTION__, arg, process->GetID(), event_type);
3715 done = true;
3716 break;
3717 }
3718 }
3719 } else {
3720 if (log)
3721 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3722 ") listener.WaitForEvent (NULL, event_sp) => false",
3723 __FUNCTION__, arg, process->GetID());
3724 done = true;
3725 }
3726 }
3727
3728 if (log)
3729 log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64"l" "u"
3730 ") thread exiting...",
3731 __FUNCTION__, arg, process->GetID());
3732
3733 return NULL__null;
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//
3756bool ProcessGDBRemote::NewThreadNotifyBreakpointHit(
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(GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP(1u << 7)));
3763 if (log)
3764 log->Printf("Hit New Thread Notification breakpoint.");
3765 return false;
3766}
3767
3768Status ProcessGDBRemote::UpdateAutomaticSignalFiltering() {
3769 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
3770 LLDB_LOG(log, "Check if need to update ignored signals")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Check if need to update ignored signals"); }
while (0)
;
3771
3772 // QPassSignals package is not supported by the server,
3773 // there is no way we can ignore any signals on server side.
3774 if (!m_gdb_comm.GetQPassSignalsSupported())
3775 return Status();
3776
3777 // No signals, nothing to send.
3778 if (m_unix_signals_sp == nullptr)
3779 return Status();
3780
3781 // Signals' version hasn't changed, no need to send anything.
3782 uint64_t new_signals_version = m_unix_signals_sp->GetVersion();
3783 if (new_signals_version == m_last_signals_version) {
3784 LLDB_LOG(log, "Signals' version hasn't changed. version={0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version hasn't changed. version={0}"
, m_last_signals_version); } while (0)
3785 m_last_signals_version)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version hasn't changed. version={0}"
, m_last_signals_version); } while (0)
;
3786 return Status();
3787 }
3788
3789 auto signals_to_ignore =
3790 m_unix_signals_sp->GetFilteredSignals(false, false, false);
3791 Status error = m_gdb_comm.SendSignalsToIgnore(signals_to_ignore);
3792
3793 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version changed. old version={0}, new version={1}, "
"signals ignored={2}, update result={3}", m_last_signals_version
, new_signals_version, signals_to_ignore.size(), error); } while
(0)
3794 "Signals' version changed. old version={0}, new version={1}, "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version changed. old version={0}, new version={1}, "
"signals ignored={2}, update result={3}", m_last_signals_version
, new_signals_version, signals_to_ignore.size(), error); } while
(0)
3795 "signals ignored={2}, update result={3}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version changed. old version={0}, new version={1}, "
"signals ignored={2}, update result={3}", m_last_signals_version
, new_signals_version, signals_to_ignore.size(), error); } while
(0)
3796 m_last_signals_version, new_signals_version,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version changed. old version={0}, new version={1}, "
"signals ignored={2}, update result={3}", m_last_signals_version
, new_signals_version, signals_to_ignore.size(), error); } while
(0)
3797 signals_to_ignore.size(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, __FUNCTION__, "Signals' version changed. old version={0}, new version={1}, "
"signals ignored={2}, update result={3}", m_last_signals_version
, new_signals_version, signals_to_ignore.size(), error); } while
(0)
;
3798
3799 if (error.Success())
3800 m_last_signals_version = new_signals_version;
3801
3802 return error;
3803}
3804
3805bool ProcessGDBRemote::StartNoticingNewThreads() {
3806 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP(1u << 7)));
3807 if (m_thread_create_bp_sp) {
3808 if (log && log->GetVerbose())
3809 log->Printf("Enabled noticing new thread breakpoint.");
3810 m_thread_create_bp_sp->SetEnabled(true);
3811 } else {
3812 PlatformSP platform_sp(GetTarget().GetPlatform());
3813 if (platform_sp) {
3814 m_thread_create_bp_sp =
3815 platform_sp->SetThreadCreationBreakpoint(GetTarget());
3816 if (m_thread_create_bp_sp) {
3817 if (log && log->GetVerbose())
3818 log->Printf(
3819 "Successfully created new thread notification breakpoint %i",
3820 m_thread_create_bp_sp->GetID());
3821 m_thread_create_bp_sp->SetCallback(
3822 ProcessGDBRemote::NewThreadNotifyBreakpointHit, this, true);
3823 } else {
3824 if (log)
3825 log->Printf("Failed to create new thread notification breakpoint.");
3826 }
3827 }
3828 }
3829 return m_thread_create_bp_sp.get() != NULL__null;
3830}
3831
3832bool ProcessGDBRemote::StopNoticingNewThreads() {
3833 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP(1u << 7)));
3834 if (log && log->GetVerbose())
3835 log->Printf("Disabling new thread notification breakpoint.");
3836
3837 if (m_thread_create_bp_sp)
3838 m_thread_create_bp_sp->SetEnabled(false);
3839
3840 return true;
3841}
3842
3843DynamicLoader *ProcessGDBRemote::GetDynamicLoader() {
3844 if (m_dyld_ap.get() == NULL__null)
3845 m_dyld_ap.reset(DynamicLoader::FindPlugin(this, NULL__null));
3846 return m_dyld_ap.get();
3847}
3848
3849Status ProcessGDBRemote::SendEventData(const char *data) {
3850 int return_value;
3851 bool was_supported;
3852
3853 Status error;
3854
3855 return_value = m_gdb_comm.SendLaunchEventDataPacket(data, &was_supported);
3856 if (return_value != 0) {
3857 if (!was_supported)
3858 error.SetErrorString("Sending events is not supported for this process.");
3859 else
3860 error.SetErrorStringWithFormat("Error sending event data: %d.",
3861 return_value);
3862 }
3863 return error;
3864}
3865
3866const DataBufferSP ProcessGDBRemote::GetAuxvData() {
3867 DataBufferSP buf;
3868 if (m_gdb_comm.GetQXferAuxvReadSupported()) {
3869 std::string response_string;
3870 if (m_gdb_comm.SendPacketsAndConcatenateResponses("qXfer:auxv:read::",
3871 response_string) ==
3872 GDBRemoteCommunication::PacketResult::Success)
3873 buf.reset(new DataBufferHeap(response_string.c_str(),
3874 response_string.length()));
3875 }
3876 return buf;
3877}
3878
3879StructuredData::ObjectSP
3880ProcessGDBRemote::GetExtendedInfoForThread(lldb::tid_t tid) {
3881 StructuredData::ObjectSP object_sp;
3882
3883 if (m_gdb_comm.GetThreadExtendedInfoSupported()) {
3884 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
3885 SystemRuntime *runtime = GetSystemRuntime();
3886 if (runtime) {
3887 runtime->AddThreadExtendedInfoPacketHints(args_dict);
3888 }
3889 args_dict->GetAsDictionary()->AddIntegerItem("thread", tid);
3890
3891 StreamString packet;
3892 packet << "jThreadExtendedInfo:";
3893 args_dict->Dump(packet, false);
3894
3895 // FIXME the final character of a JSON dictionary, '}', is the escape
3896 // character in gdb-remote binary mode. lldb currently doesn't escape
3897 // these characters in its packet output -- so we add the quoted version
3898 // of the } character here manually in case we talk to a debugserver which
3899 // un-escapes the characters at packet read time.
3900 packet << (char)(0x7d ^ 0x20);
3901
3902 StringExtractorGDBRemote response;
3903 response.SetResponseValidatorToJSON();
3904 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
3905 false) ==
3906 GDBRemoteCommunication::PacketResult::Success) {
3907 StringExtractorGDBRemote::ResponseType response_type =
3908 response.GetResponseType();
3909 if (response_type == StringExtractorGDBRemote::eResponse) {
3910 if (!response.Empty()) {
3911 object_sp = StructuredData::ParseJSON(response.GetStringRef());
3912 }
3913 }
3914 }
3915 }
3916 return object_sp;
3917}
3918
3919StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos(
3920 lldb::addr_t image_list_address, lldb::addr_t image_count) {
3921
3922 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
3923 args_dict->GetAsDictionary()->AddIntegerItem("image_list_address",
3924 image_list_address);
3925 args_dict->GetAsDictionary()->AddIntegerItem("image_count", image_count);
3926
3927 return GetLoadedDynamicLibrariesInfos_sender(args_dict);
3928}
3929
3930StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos() {
3931 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
3932
3933 args_dict->GetAsDictionary()->AddBooleanItem("fetch_all_solibs", true);
3934
3935 return GetLoadedDynamicLibrariesInfos_sender(args_dict);
3936}
3937
3938StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos(
3939 const std::vector<lldb::addr_t> &load_addresses) {
3940 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
3941 StructuredData::ArraySP addresses(new StructuredData::Array);
3942
3943 for (auto addr : load_addresses) {
3944 StructuredData::ObjectSP addr_sp(new StructuredData::Integer(addr));
3945 addresses->AddItem(addr_sp);
3946 }
3947
3948 args_dict->GetAsDictionary()->AddItem("solib_addresses", addresses);
3949
3950 return GetLoadedDynamicLibrariesInfos_sender(args_dict);
3951}
3952
3953StructuredData::ObjectSP
3954ProcessGDBRemote::GetLoadedDynamicLibrariesInfos_sender(
3955 StructuredData::ObjectSP args_dict) {
3956 StructuredData::ObjectSP object_sp;
3957
3958 if (m_gdb_comm.GetLoadedDynamicLibrariesInfosSupported()) {
3959 // Scope for the scoped timeout object
3960 GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
3961 std::chrono::seconds(10));
3962
3963 StreamString packet;
3964 packet << "jGetLoadedDynamicLibrariesInfos:";
3965 args_dict->Dump(packet, false);
3966
3967 // FIXME the final character of a JSON dictionary, '}', is the escape
3968 // character in gdb-remote binary mode. lldb currently doesn't escape
3969 // these characters in its packet output -- so we add the quoted version
3970 // of the } character here manually in case we talk to a debugserver which
3971 // un-escapes the characters at packet read time.
3972 packet << (char)(0x7d ^ 0x20);
3973
3974 StringExtractorGDBRemote response;
3975 response.SetResponseValidatorToJSON();
3976 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
3977 false) ==
3978 GDBRemoteCommunication::PacketResult::Success) {
3979 StringExtractorGDBRemote::ResponseType response_type =
3980 response.GetResponseType();
3981 if (response_type == StringExtractorGDBRemote::eResponse) {
3982 if (!response.Empty()) {
3983 object_sp = StructuredData::ParseJSON(response.GetStringRef());
3984 }
3985 }
3986 }
3987 }
3988 return object_sp;
3989}
3990
3991StructuredData::ObjectSP ProcessGDBRemote::GetSharedCacheInfo() {
3992 StructuredData::ObjectSP object_sp;
3993 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
3994
3995 if (m_gdb_comm.GetSharedCacheInfoSupported()) {
3996 StreamString packet;
3997 packet << "jGetSharedCacheInfo:";
3998 args_dict->Dump(packet, false);
3999
4000 // FIXME the final character of a JSON dictionary, '}', is the escape
4001 // character in gdb-remote binary mode. lldb currently doesn't escape
4002 // these characters in its packet output -- so we add the quoted version
4003 // of the } character here manually in case we talk to a debugserver which
4004 // un-escapes the characters at packet read time.
4005 packet << (char)(0x7d ^ 0x20);
4006
4007 StringExtractorGDBRemote response;
4008 response.SetResponseValidatorToJSON();
4009 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
4010 false) ==
4011 GDBRemoteCommunication::PacketResult::Success) {
4012 StringExtractorGDBRemote::ResponseType response_type =
4013 response.GetResponseType();
4014 if (response_type == StringExtractorGDBRemote::eResponse) {
4015 if (!response.Empty()) {
4016 object_sp = StructuredData::ParseJSON(response.GetStringRef());
4017 }
4018 }
4019 }
4020 }
4021 return object_sp;
4022}
4023
4024Status ProcessGDBRemote::ConfigureStructuredData(
4025 const ConstString &type_name, const StructuredData::ObjectSP &config_sp) {
4026 return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
4027}
4028
4029// Establish the largest memory read/write payloads we should use.
4030// If the remote stub has a max packet size, stay under that size.
4031//
4032// If the remote stub's max packet size is crazy large, use a
4033// reasonable largeish default.
4034//
4035// If the remote stub doesn't advertise a max packet size, use a
4036// conservative default.
4037
4038void ProcessGDBRemote::GetMaxMemorySize() {
4039 const uint64_t reasonable_largeish_default = 128 * 1024;
4040 const uint64_t conservative_default = 512;
4041
4042 if (m_max_memory_size == 0) {
4043 uint64_t stub_max_size = m_gdb_comm.GetRemoteMaxPacketSize();
4044 if (stub_max_size != UINT64_MAX(18446744073709551615UL) && stub_max_size != 0) {
4045 // Save the stub's claimed maximum packet size
4046 m_remote_stub_max_memory_size = stub_max_size;
4047
4048 // Even if the stub says it can support ginormous packets,
4049 // don't exceed our reasonable largeish default packet size.
4050 if (stub_max_size > reasonable_largeish_default) {
4051 stub_max_size = reasonable_largeish_default;
4052 }
4053
4054 // Memory packet have other overheads too like Maddr,size:#NN
4055 // Instead of calculating the bytes taken by size and addr every
4056 // time, we take a maximum guess here.
4057 if (stub_max_size > 70)
4058 stub_max_size -= 32 + 32 + 6;
4059 else {
4060 // In unlikely scenario that max packet size is less then 70, we will
4061 // hope that data being written is small enough to fit.
4062 Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
4063 GDBR_LOG_COMM(1u << 10) | GDBR_LOG_MEMORY(1u << 4)));
4064 if (log)
4065 log->Warning("Packet size is too small. "
4066 "LLDB may face problems while writing memory");
4067 }
4068
4069 m_max_memory_size = stub_max_size;
4070 } else {
4071 m_max_memory_size = conservative_default;
4072 }
4073 }
4074}
4075
4076void ProcessGDBRemote::SetUserSpecifiedMaxMemoryTransferSize(
4077 uint64_t user_specified_max) {
4078 if (user_specified_max != 0) {
4079 GetMaxMemorySize();
4080
4081 if (m_remote_stub_max_memory_size != 0) {
4082 if (m_remote_stub_max_memory_size < user_specified_max) {
4083 m_max_memory_size = m_remote_stub_max_memory_size; // user specified a
4084 // packet size too
4085 // big, go as big
4086 // as the remote stub says we can go.
4087 } else {
4088 m_max_memory_size = user_specified_max; // user's packet size is good
4089 }
4090 } else {
4091 m_max_memory_size =
4092 user_specified_max; // user's packet size is probably fine
4093 }
4094 }
4095}
4096
4097bool ProcessGDBRemote::GetModuleSpec(const FileSpec &module_file_spec,
4098 const ArchSpec &arch,
4099 ModuleSpec &module_spec) {
4100 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM(1u << 25));
4101
4102 const ModuleCacheKey key(module_file_spec.GetPath(),
4103 arch.GetTriple().getTriple());
4104 auto cached = m_cached_module_specs.find(key);
4105 if (cached != m_cached_module_specs.end()) {
4106 module_spec = cached->second;
4107 return bool(module_spec);
4108 }
4109
4110 if (!m_gdb_comm.GetModuleInfo(module_file_spec, arch, module_spec)) {
4111 if (log)
4112 log->Printf("ProcessGDBRemote::%s - failed to get module info for %s:%s",
4113 __FUNCTION__, module_file_spec.GetPath().c_str(),
4114 arch.GetTriple().getTriple().c_str());
4115 return false;
4116 }
4117
4118 if (log) {
4119 StreamString stream;
4120 module_spec.Dump(stream);
4121 log->Printf("ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
4122 __FUNCTION__, module_file_spec.GetPath().c_str(),
4123 arch.GetTriple().getTriple().c_str(), stream.GetData());
4124 }
4125
4126 m_cached_module_specs[key] = module_spec;
4127 return true;
4128}
4129
4130void ProcessGDBRemote::PrefetchModuleSpecs(
4131 llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
4132 auto module_specs = m_gdb_comm.GetModulesInfo(module_file_specs, triple);
4133 if (module_specs) {
4134 for (const FileSpec &spec : module_file_specs)
4135 m_cached_module_specs[ModuleCacheKey(spec.GetPath(),
4136 triple.getTriple())] = ModuleSpec();
4137 for (const ModuleSpec &spec : *module_specs)
4138 m_cached_module_specs[ModuleCacheKey(spec.GetFileSpec().GetPath(),
4139 triple.getTriple())] = spec;
4140 }
4141}
4142
4143bool ProcessGDBRemote::GetHostOSVersion(uint32_t &major, uint32_t &minor,
4144 uint32_t &update) {
4145 if (m_gdb_comm.GetOSVersion(major, minor, update))
4146 return true;
4147 // We failed to get the host OS version, defer to the base
4148 // implementation to correctly invalidate the arguments.
4149 return Process::GetHostOSVersion(major, minor, update);
4150}
4151
4152namespace {
4153
4154typedef std::vector<std::string> stringVec;
4155
4156typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
4157struct RegisterSetInfo {
4158 ConstString name;
4159};
4160
4161typedef std::map<uint32_t, RegisterSetInfo> RegisterSetMap;
4162
4163struct GdbServerTargetInfo {
4164 std::string arch;
4165 std::string osabi;
4166 stringVec includes;
4167 RegisterSetMap reg_set_map;
4168 XMLNode feature_node;
4169};
4170
4171bool ParseRegisters(XMLNode feature_node, GdbServerTargetInfo &target_info,
4172 GDBRemoteDynamicRegisterInfo &dyn_reg_info, ABISP abi_sp,
4173 uint32_t &cur_reg_num, uint32_t &reg_offset) {
4174 if (!feature_node)
4175 return false;
4176
4177 feature_node.ForEachChildElementWithName(
4178 "reg", [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset,
4179 &abi_sp](const XMLNode &reg_node) -> bool {
4180 std::string gdb_group;
4181 std::string gdb_type;
4182 ConstString reg_name;
4183 ConstString alt_name;
4184 ConstString set_name;
4185 std::vector<uint32_t> value_regs;
4186 std::vector<uint32_t> invalidate_regs;
4187 std::vector<uint8_t> dwarf_opcode_bytes;
4188 bool encoding_set = false;
4189 bool format_set = false;
4190 RegisterInfo reg_info = {
4191 NULL__null, // Name
4192 NULL__null, // Alt name
4193 0, // byte size
4194 reg_offset, // offset
4195 eEncodingUint, // encoding
4196 eFormatHex, // format
4197 {
4198 LLDB_INVALID_REGNUM(4294967295U), // eh_frame reg num
4199 LLDB_INVALID_REGNUM(4294967295U), // DWARF reg num
4200 LLDB_INVALID_REGNUM(4294967295U), // generic reg num
4201 cur_reg_num, // process plugin reg num
4202 cur_reg_num // native register number
4203 },
4204 NULL__null,
4205 NULL__null,
4206 NULL__null, // Dwarf Expression opcode bytes pointer
4207 0 // Dwarf Expression opcode bytes length
4208 };
4209
4210 reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type,
4211 &reg_name, &alt_name, &set_name, &value_regs,
4212 &invalidate_regs, &encoding_set, &format_set,
4213 &reg_info, &reg_offset, &dwarf_opcode_bytes](
4214 const llvm::StringRef &name,
4215 const llvm::StringRef &value) -> bool {
4216 if (name == "name") {
4217 reg_name.SetString(value);
4218 } else if (name == "bitsize") {
4219 reg_info.byte_size =
4220 StringConvert::ToUInt32(value.data(), 0, 0) / CHAR_BIT8;
4221 } else if (name == "type") {
4222 gdb_type = value.str();
4223 } else if (name == "group") {
4224 gdb_group = value.str();
4225 } else if (name == "regnum") {
4226 const uint32_t regnum =
4227 StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM(4294967295U), 0);
4228 if (regnum != LLDB_INVALID_REGNUM(4294967295U)) {
4229 reg_info.kinds[eRegisterKindProcessPlugin] = regnum;
4230 }
4231 } else if (name == "offset") {
4232 reg_offset = StringConvert::ToUInt32(value.data(), UINT32_MAX(4294967295U), 0);
4233 } else if (name == "altname") {
4234 alt_name.SetString(value);
4235 } else if (name == "encoding") {
4236 encoding_set = true;
4237 reg_info.encoding = Args::StringToEncoding(value, eEncodingUint);
4238 } else if (name == "format") {
4239 format_set = true;
4240 Format format = eFormatInvalid;
4241 if (Args::StringToFormat(value.data(), format, NULL__null).Success())
4242 reg_info.format = format;
4243 else if (value == "vector-sint8")
4244 reg_info.format = eFormatVectorOfSInt8;
4245 else if (value == "vector-uint8")
4246 reg_info.format = eFormatVectorOfUInt8;
4247 else if (value == "vector-sint16")
4248 reg_info.format = eFormatVectorOfSInt16;
4249 else if (value == "vector-uint16")
4250 reg_info.format = eFormatVectorOfUInt16;
4251 else if (value == "vector-sint32")
4252 reg_info.format = eFormatVectorOfSInt32;
4253 else if (value == "vector-uint32")
4254 reg_info.format = eFormatVectorOfUInt32;
4255 else if (value == "vector-float32")
4256 reg_info.format = eFormatVectorOfFloat32;
4257 else if (value == "vector-uint64")
4258 reg_info.format = eFormatVectorOfUInt64;
4259 else if (value == "vector-uint128")
4260 reg_info.format = eFormatVectorOfUInt128;
4261 } else if (name == "group_id") {
4262 const uint32_t set_id =
4263 StringConvert::ToUInt32(value.data(), UINT32_MAX(4294967295U), 0);
4264 RegisterSetMap::const_iterator pos =
4265 target_info.reg_set_map.find(set_id);
4266 if (pos != target_info.reg_set_map.end())
4267 set_name = pos->second.name;
4268 } else if (name == "gcc_regnum" || name == "ehframe_regnum") {
4269 reg_info.kinds[eRegisterKindEHFrame] =
4270 StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM(4294967295U), 0);
4271 } else if (name == "dwarf_regnum") {
4272 reg_info.kinds[eRegisterKindDWARF] =
4273 StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM(4294967295U), 0);
4274 } else if (name == "generic") {
4275 reg_info.kinds[eRegisterKindGeneric] =
4276 Args::StringToGenericRegister(value);
4277 } else if (name == "value_regnums") {
4278 SplitCommaSeparatedRegisterNumberString(value, value_regs, 0);
4279 } else if (name == "invalidate_regnums") {
4280 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0);
4281 } else if (name == "dynamic_size_dwarf_expr_bytes") {
4282 StringExtractor opcode_extractor;
4283 std::string opcode_string = value.str();
4284 size_t dwarf_opcode_len = opcode_string.length() / 2;
4285 assert(dwarf_opcode_len > 0)((dwarf_opcode_len > 0) ? static_cast<void> (0) : __assert_fail
("dwarf_opcode_len > 0", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 4285, __PRETTY_FUNCTION__))
;
4286
4287 dwarf_opcode_bytes.resize(dwarf_opcode_len);
4288 reg_info.dynamic_size_dwarf_len = dwarf_opcode_len;
4289 opcode_extractor.GetStringRef().swap(opcode_string);
4290 uint32_t ret_val =
4291 opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
4292 assert(dwarf_opcode_len == ret_val)((dwarf_opcode_len == ret_val) ? static_cast<void> (0) :
__assert_fail ("dwarf_opcode_len == ret_val", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 4292, __PRETTY_FUNCTION__))
;
4293 UNUSED_IF_ASSERT_DISABLED(ret_val)((void)(ret_val));
4294 reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data();
4295 } else {
4296 printf("unhandled attribute %s = %s\n", name.data(), value.data());
4297 }
4298 return true; // Keep iterating through all attributes
4299 });
4300
4301 if (!gdb_type.empty() && !(encoding_set || format_set)) {
4302 if (gdb_type.find("int") == 0) {
4303 reg_info.format = eFormatHex;
4304 reg_info.encoding = eEncodingUint;
4305 } else if (gdb_type == "data_ptr" || gdb_type == "code_ptr") {
4306 reg_info.format = eFormatAddressInfo;
4307 reg_info.encoding = eEncodingUint;
4308 } else if (gdb_type == "i387_ext" || gdb_type == "float") {
4309 reg_info.format = eFormatFloat;
4310 reg_info.encoding = eEncodingIEEE754;
4311 }
4312 }
4313
4314 // Only update the register set name if we didn't get a "reg_set"
4315 // attribute.
4316 // "set_name" will be empty if we didn't have a "reg_set" attribute.
4317 if (!set_name && !gdb_group.empty())
4318 set_name.SetCString(gdb_group.c_str());
4319
4320 reg_info.byte_offset = reg_offset;
4321 assert(reg_info.byte_size != 0)((reg_info.byte_size != 0) ? static_cast<void> (0) : __assert_fail
("reg_info.byte_size != 0", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn306458/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp"
, 4321, __PRETTY_FUNCTION__))
;
4322 reg_offset += reg_info.byte_size;
4323 if (!value_regs.empty()) {
4324 value_regs.push_back(LLDB_INVALID_REGNUM(4294967295U));
4325 reg_info.value_regs = value_regs.data();
4326 }
4327 if (!invalidate_regs.empty()) {
4328 invalidate_regs.push_back(LLDB_INVALID_REGNUM(4294967295U));
4329 reg_info.invalidate_regs = invalidate_regs.data();
4330 }
4331
4332 ++cur_reg_num;
4333 AugmentRegisterInfoViaABI(reg_info, reg_name, abi_sp);
4334 dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name);
4335
4336 return true; // Keep iterating through all "reg" elements
4337 });
4338 return true;
4339}
4340
4341} // namespace {}
4342
4343// query the target of gdb-remote for extended target information
4344// return: 'true' on success
4345// 'false' on failure
4346bool ProcessGDBRemote::GetGDBServerRegisterInfo(ArchSpec &arch_to_use) {
4347 // Make sure LLDB has an XML parser it can use first
4348 if (!XMLDocument::XMLEnabled())
4349 return false;
4350
4351 // redirect libxml2's error handler since the default prints to stdout
4352
4353 GDBRemoteCommunicationClient &comm = m_gdb_comm;
4354
4355 // check that we have extended feature read support
4356 if (!comm.GetQXferFeaturesReadSupported())
4357 return false;
4358
4359 // request the target xml file
4360 std::string raw;
4361 lldb_private::Status lldberr;
4362 if (!comm.ReadExtFeature(ConstString("features"), ConstString("target.xml"),
4363 raw, lldberr)) {
4364 return false;
4365 }
4366
4367 XMLDocument xml_document;
4368
4369 if (xml_document.ParseMemory(raw.c_str(), raw.size(), "target.xml")) {
4370 GdbServerTargetInfo target_info;
4371
4372 XMLNode target_node = xml_document.GetRootElement("target");
4373 if (target_node) {
4374 XMLNode feature_node;
4375 target_node.ForEachChildElement([&target_info, &feature_node](
4376 const XMLNode &node) -> bool {
4377 llvm::StringRef name = node.GetName();
4378 if (name == "architecture") {
4379 node.GetElementText(target_info.arch);
4380 } else if (name == "osabi") {
4381 node.GetElementText(target_info.osabi);
4382 } else if (name == "xi:include" || name == "include") {
4383 llvm::StringRef href = node.GetAttributeValue("href");
4384 if (!href.empty())
4385 target_info.includes.push_back(href.str());
4386 } else if (name == "feature") {
4387 feature_node = node;
4388 } else if (name == "groups") {
4389 node.ForEachChildElementWithName(
4390 "group", [&target_info](const XMLNode &node) -> bool {
4391 uint32_t set_id = UINT32_MAX(4294967295U);
4392 RegisterSetInfo set_info;
4393
4394 node.ForEachAttribute(
4395 [&set_id, &set_info](const llvm::StringRef &name,
4396 const llvm::StringRef &value) -> bool {
4397 if (name == "id")
4398 set_id = StringConvert::ToUInt32(value.data(),
4399 UINT32_MAX(4294967295U), 0);
4400 if (name == "name")
4401 set_info.name = ConstString(value);
4402 return true; // Keep iterating through all attributes
4403 });
4404
4405 if (set_id != UINT32_MAX(4294967295U))
4406 target_info.reg_set_map[set_id] = set_info;
4407 return true; // Keep iterating through all "group" elements
4408 });
4409 }
4410 return true; // Keep iterating through all children of the target_node
4411 });
4412
4413 // Initialize these outside of ParseRegisters, since they should not be
4414 // reset inside each include feature
4415 uint32_t cur_reg_num = 0;
4416 uint32_t reg_offset = 0;
4417
4418 // Don't use Process::GetABI, this code gets called from DidAttach, and in
4419 // that context we haven't
4420 // set the Target's architecture yet, so the ABI is also potentially
4421 // incorrect.
4422 ABISP abi_to_use_sp = ABI::FindPlugin(arch_to_use);
4423 if (feature_node) {
4424 ParseRegisters(feature_node, target_info, this->m_register_info,
4425 abi_to_use_sp, cur_reg_num, reg_offset);
4426 }
4427
4428 for (const auto &include : target_info.includes) {
4429 // request register file
4430 std::string xml_data;
4431 if (!comm.ReadExtFeature(ConstString("features"), ConstString(include),
4432 xml_data, lldberr))
4433 continue;
4434
4435 XMLDocument include_xml_document;
4436 include_xml_document.ParseMemory(xml_data.data(), xml_data.size(),
4437 include.c_str());
4438 XMLNode include_feature_node =
4439 include_xml_document.GetRootElement("feature");
4440 if (include_feature_node) {
4441 ParseRegisters(include_feature_node, target_info,
4442 this->m_register_info, abi_to_use_sp, cur_reg_num,
4443 reg_offset);
4444 }
4445 }
4446 this->m_register_info.Finalize(arch_to_use);
4447 }
4448 }
4449
4450 return m_register_info.GetNumRegisters() > 0;
4451}
4452
4453Status ProcessGDBRemote::GetLoadedModuleList(LoadedModuleInfoList &list) {
4454 // Make sure LLDB has an XML parser it can use first
4455 if (!XMLDocument::XMLEnabled())
4456 return Status(0, ErrorType::eErrorTypeGeneric);
4457
4458 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1));
4459 if (log)
4460 log->Printf("ProcessGDBRemote::%s", __FUNCTION__);
4461
4462 GDBRemoteCommunicationClient &comm = m_gdb_comm;
4463
4464 // check that we have extended feature read support
4465 if (comm.GetQXferLibrariesSVR4ReadSupported()) {
4466 list.clear();
4467
4468 // request the loaded library list
4469 std::string raw;
4470 lldb_private::Status lldberr;
4471
4472 if (!comm.ReadExtFeature(ConstString("libraries-svr4"), ConstString(""),
4473 raw, lldberr))
4474 return Status(0, ErrorType::eErrorTypeGeneric);
4475
4476 // parse the xml file in memory
4477 if (log)
4478 log->Printf("parsing: %s", raw.c_str());
4479 XMLDocument doc;
4480
4481 if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
4482 return Status(0, ErrorType::eErrorTypeGeneric);
4483
4484 XMLNode root_element = doc.GetRootElement("library-list-svr4");
4485 if (!root_element)
4486 return Status();
4487
4488 // main link map structure
4489 llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
4490 if (!main_lm.empty()) {
4491 list.m_link_map =
4492 StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0);
4493 }
4494
4495 root_element.ForEachChildElementWithName(
4496 "library", [log, &list](const XMLNode &library) -> bool {
4497
4498 LoadedModuleInfoList::LoadedModuleInfo module;
4499
4500 library.ForEachAttribute(
4501 [&module](const llvm::StringRef &name,
4502 const llvm::StringRef &value) -> bool {
4503
4504 if (name == "name")
4505 module.set_name(value.str());
4506 else if (name == "lm") {
4507 // the address of the link_map struct.
4508 module.set_link_map(StringConvert::ToUInt64(
4509 value.data(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0));
4510 } else if (name == "l_addr") {
4511 // the displacement as read from the field 'l_addr' of the
4512 // link_map struct.
4513 module.set_base(StringConvert::ToUInt64(
4514 value.data(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0));
4515 // base address is always a displacement, not an absolute
4516 // value.
4517 module.set_base_is_offset(true);
4518 } else if (name == "l_ld") {
4519 // the memory address of the libraries PT_DYAMIC section.
4520 module.set_dynamic(StringConvert::ToUInt64(
4521 value.data(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0));
4522 }
4523
4524 return true; // Keep iterating over all properties of "library"
4525 });
4526
4527 if (log) {
4528 std::string name;
4529 lldb::addr_t lm = 0, base = 0, ld = 0;
4530 bool base_is_offset;
4531
4532 module.get_name(name);
4533 module.get_link_map(lm);
4534 module.get_base(base);
4535 module.get_base_is_offset(base_is_offset);
4536 module.get_dynamic(ld);
4537
4538 log->Printf("found (link_map:0x%08" PRIx64"l" "x" ", base:0x%08" PRIx64"l" "x"
4539 "[%s], ld:0x%08" PRIx64"l" "x" ", name:'%s')",
4540 lm, base, (base_is_offset ? "offset" : "absolute"), ld,
4541 name.c_str());
4542 }
4543
4544 list.add(module);
4545 return true; // Keep iterating over all "library" elements in the root
4546 // node
4547 });
4548
4549 if (log)
4550 log->Printf("found %" PRId32"d" " modules in total",
4551 (int)list.m_list.size());
4552 } else if (comm.GetQXferLibrariesReadSupported()) {
4553 list.clear();
4554
4555 // request the loaded library list
4556 std::string raw;
4557 lldb_private::Status lldberr;
4558
4559 if (!comm.ReadExtFeature(ConstString("libraries"), ConstString(""), raw,
4560 lldberr))
4561 return Status(0, ErrorType::eErrorTypeGeneric);
4562
4563 if (log)
4564 log->Printf("parsing: %s", raw.c_str());
4565 XMLDocument doc;
4566
4567 if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
4568 return Status(0, ErrorType::eErrorTypeGeneric);
4569
4570 XMLNode root_element = doc.GetRootElement("library-list");
4571 if (!root_element)
4572 return Status();
4573
4574 root_element.ForEachChildElementWithName(
4575 "library", [log, &list](const XMLNode &library) -> bool {
4576 LoadedModuleInfoList::LoadedModuleInfo module;
4577
4578 llvm::StringRef name = library.GetAttributeValue("name");
4579 module.set_name(name.str());
4580
4581 // The base address of a given library will be the address of its
4582 // first section. Most remotes send only one section for Windows
4583 // targets for example.
4584 const XMLNode &section =
4585 library.FindFirstChildElementWithName("section");
4586 llvm::StringRef address = section.GetAttributeValue("address");
4587 module.set_base(
4588 StringConvert::ToUInt64(address.data(), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0));
4589 // These addresses are absolute values.
4590 module.set_base_is_offset(false);
4591
4592 if (log) {
4593 std::string name;
4594 lldb::addr_t base = 0;
4595 bool base_is_offset;
4596 module.get_name(name);
4597 module.get_base(base);
4598 module.get_base_is_offset(base_is_offset);
4599
4600 log->Printf("found (base:0x%08" PRIx64"l" "x" "[%s], name:'%s')", base,
4601 (base_is_offset ? "offset" : "absolute"), name.c_str());
4602 }
4603
4604 list.add(module);
4605 return true; // Keep iterating over all "library" elements in the root
4606 // node
4607 });
4608
4609 if (log)
4610 log->Printf("found %" PRId32"d" " modules in total",
4611 (int)list.m_list.size());
4612 } else {
4613 return Status(0, ErrorType::eErrorTypeGeneric);
4614 }
4615
4616 return Status();
4617}
4618
4619lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
4620 lldb::addr_t link_map,
4621 lldb::addr_t base_addr,
4622 bool value_is_offset) {
4623 DynamicLoader *loader = GetDynamicLoader();
4624 if (!loader)
4625 return nullptr;
4626
4627 return loader->LoadModuleAtAddress(file, link_map, base_addr,
4628 value_is_offset);
4629}
4630
4631size_t ProcessGDBRemote::LoadModules(LoadedModuleInfoList &module_list) {
4632 using lldb_private::process_gdb_remote::ProcessGDBRemote;
4633
4634 // request a list of loaded libraries from GDBServer
4635 if (GetLoadedModuleList(module_list).Fail())
4636 return 0;
4637
4638 // get a list of all the modules
4639 ModuleList new_modules;
4640
4641 for (LoadedModuleInfoList::LoadedModuleInfo &modInfo : module_list.m_list) {
4642 std::string mod_name;
4643 lldb::addr_t mod_base;
4644 lldb::addr_t link_map;
4645 bool mod_base_is_offset;
4646
4647 bool valid = true;
4648 valid &= modInfo.get_name(mod_name);
4649 valid &= modInfo.get_base(mod_base);
4650 valid &= modInfo.get_base_is_offset(mod_base_is_offset);
4651 if (!valid)
4652 continue;
4653
4654 if (!modInfo.get_link_map(link_map))
4655 link_map = LLDB_INVALID_ADDRESS(18446744073709551615UL);
4656
4657 FileSpec file(mod_name, true);
4658 lldb::ModuleSP module_sp =
4659 LoadModuleAtAddress(file, link_map, mod_base, mod_base_is_offset);
4660
4661 if (module_sp.get())
4662 new_modules.Append(module_sp);
4663 }
4664
4665 if (new_modules.GetSize() > 0) {
4666 ModuleList removed_modules;
4667 Target &target = GetTarget();
4668 ModuleList &loaded_modules = m_process->GetTarget().GetImages();
4669
4670 for (size_t i = 0; i < loaded_modules.GetSize(); ++i) {
4671 const lldb::ModuleSP loaded_module = loaded_modules.GetModuleAtIndex(i);
4672
4673 bool found = false;
4674 for (size_t j = 0; j < new_modules.GetSize(); ++j) {
4675 if (new_modules.GetModuleAtIndex(j).get() == loaded_module.get())
4676 found = true;
4677 }
4678
4679 // The main executable will never be included in libraries-svr4, don't
4680 // remove it
4681 if (!found &&
4682 loaded_module.get() != target.GetExecutableModulePointer()) {
4683 removed_modules.Append(loaded_module);
4684 }
4685 }
4686
4687 loaded_modules.Remove(removed_modules);
4688 m_process->GetTarget().ModulesDidUnload(removed_modules, false);
4689
4690 new_modules.ForEach([&target](const lldb::ModuleSP module_sp) -> bool {
4691 lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
4692 if (!obj)
4693 return true;
4694
4695 if (obj->GetType() != ObjectFile::Type::eTypeExecutable)
4696 return true;
4697
4698 lldb::ModuleSP module_copy_sp = module_sp;
4699 target.SetExecutableModule(module_copy_sp, false);
4700 return false;
4701 });
4702
4703 loaded_modules.AppendIfNeeded(new_modules);
4704 m_process->GetTarget().ModulesDidLoad(new_modules);
4705 }
4706
4707 return new_modules.GetSize();
4708}
4709
4710size_t ProcessGDBRemote::LoadModules() {
4711 LoadedModuleInfoList module_list;
4712 return LoadModules(module_list);
4713}
4714
4715Status ProcessGDBRemote::GetFileLoadAddress(const FileSpec &file,
4716 bool &is_loaded,
4717 lldb::addr_t &load_addr) {
4718 is_loaded = false;
4719 load_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
4720
4721 std::string file_path = file.GetPath(false);
4722 if (file_path.empty())
4723 return Status("Empty file name specified");
4724
4725 StreamString packet;
4726 packet.PutCString("qFileLoadAddress:");
4727 packet.PutCStringAsRawHex8(file_path.c_str());
4728
4729 StringExtractorGDBRemote response;
4730 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
4731 false) !=
4732 GDBRemoteCommunication::PacketResult::Success)
4733 return Status("Sending qFileLoadAddress packet failed");
4734
4735 if (response.IsErrorResponse()) {
4736 if (response.GetError() == 1) {
4737 // The file is not loaded into the inferior
4738 is_loaded = false;
4739 load_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
4740 return Status();
4741 }
4742
4743 return Status(
4744 "Fetching file load address from remote server returned an error");
4745 }
4746
4747 if (response.IsNormalResponse()) {
4748 is_loaded = true;
4749 load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS(18446744073709551615UL));
4750 return Status();
4751 }
4752
4753 return Status(
4754 "Unknown error happened during sending the load address packet");
4755}
4756
4757void ProcessGDBRemote::ModulesDidLoad(ModuleList &module_list) {
4758 // We must call the lldb_private::Process::ModulesDidLoad () first before we
4759 // do anything
4760 Process::ModulesDidLoad(module_list);
4761
4762 // After loading shared libraries, we can ask our remote GDB server if
4763 // it needs any symbols.
4764 m_gdb_comm.ServeSymbolLookups(this);
4765}
4766
4767void ProcessGDBRemote::HandleAsyncStdout(llvm::StringRef out) {
4768 AppendSTDOUT(out.data(), out.size());
4769}
4770
4771static const char *end_delimiter = "--end--;";
4772static const int end_delimiter_len = 8;
4773
4774void ProcessGDBRemote::HandleAsyncMisc(llvm::StringRef data) {
4775 std::string input = data.str(); // '1' to move beyond 'A'
4776 if (m_partial_profile_data.length() > 0) {
4777 m_partial_profile_data.append(input);
4778 input = m_partial_profile_data;
4779 m_partial_profile_data.clear();
4780 }
4781
4782 size_t found, pos = 0, len = input.length();
4783 while ((found = input.find(end_delimiter, pos)) != std::string::npos) {
4784 StringExtractorGDBRemote profileDataExtractor(
4785 input.substr(pos, found).c_str());
4786 std::string profile_data =
4787 HarmonizeThreadIdsForProfileData(profileDataExtractor);
4788 BroadcastAsyncProfileData(profile_data);
4789
4790 pos = found + end_delimiter_len;
4791 }
4792
4793 if (pos < len) {
4794 // Last incomplete chunk.
4795 m_partial_profile_data = input.substr(pos);
4796 }
4797}
4798
4799std::string ProcessGDBRemote::HarmonizeThreadIdsForProfileData(
4800 StringExtractorGDBRemote &profileDataExtractor) {
4801 std::map<uint64_t, uint32_t> new_thread_id_to_used_usec_map;
4802 std::string output;
4803 llvm::raw_string_ostream output_stream(output);
4804 llvm::StringRef name, value;
4805
4806 // Going to assuming thread_used_usec comes first, else bail out.
4807 while (profileDataExtractor.GetNameColonValue(name, value)) {
4808 if (name.compare("thread_used_id") == 0) {
4809 StringExtractor threadIDHexExtractor(value);
4810 uint64_t thread_id = threadIDHexExtractor.GetHexMaxU64(false, 0);
4811
4812 bool has_used_usec = false;
4813 uint32_t curr_used_usec = 0;
4814 llvm::StringRef usec_name, usec_value;
4815 uint32_t input_file_pos = profileDataExtractor.GetFilePos();
4816 if (profileDataExtractor.GetNameColonValue(usec_name, usec_value)) {
4817 if (usec_name.equals("thread_used_usec")) {
4818 has_used_usec = true;
4819 usec_value.getAsInteger(0, curr_used_usec);
4820 } else {
4821 // We didn't find what we want, it is probably
4822 // an older version. Bail out.
4823 profileDataExtractor.SetFilePos(input_file_pos);
4824 }
4825 }
4826
4827 if (has_used_usec) {
4828 uint32_t prev_used_usec = 0;
4829 std::map<uint64_t, uint32_t>::iterator iterator =
4830 m_thread_id_to_used_usec_map.find(thread_id);
4831 if (iterator != m_thread_id_to_used_usec_map.end()) {
4832 prev_used_usec = m_thread_id_to_used_usec_map[thread_id];
4833 }
4834
4835 uint32_t real_used_usec = curr_used_usec - prev_used_usec;
4836 // A good first time record is one that runs for at least 0.25 sec
4837 bool good_first_time =
4838 (prev_used_usec == 0) && (real_used_usec > 250000);
4839 bool good_subsequent_time =
4840 (prev_used_usec > 0) &&
4841 ((real_used_usec > 0) || (HasAssignedIndexIDToThread(thread_id)));
4842
4843 if (good_first_time || good_subsequent_time) {
4844 // We try to avoid doing too many index id reservation,
4845 // resulting in fast increase of index ids.
4846
4847 output_stream << name << ":";
4848 int32_t index_id = AssignIndexIDToThread(thread_id);
4849 output_stream << index_id << ";";
4850
4851 output_stream << usec_name << ":" << usec_value << ";";
4852 } else {
4853 // Skip past 'thread_used_name'.
4854 llvm::StringRef local_name, local_value;
4855 profileDataExtractor.GetNameColonValue(local_name, local_value);
4856 }
4857
4858 // Store current time as previous time so that they can be compared
4859 // later.
4860 new_thread_id_to_used_usec_map[thread_id] = curr_used_usec;
4861 } else {
4862 // Bail out and use old string.
4863 output_stream << name << ":" << value << ";";
4864 }
4865 } else {
4866 output_stream << name << ":" << value << ";";
4867 }
4868 }
4869 output_stream << end_delimiter;
4870 m_thread_id_to_used_usec_map = new_thread_id_to_used_usec_map;
4871
4872 return output_stream.str();
4873}
4874
4875void ProcessGDBRemote::HandleStopReply() {
4876 if (GetStopID() != 0)
4877 return;
4878
4879 if (GetID() == LLDB_INVALID_PROCESS_ID0) {
4880 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID();
4881 if (pid != LLDB_INVALID_PROCESS_ID0)
4882 SetID(pid);
4883 }
4884 BuildDynamicRegisterInfo(true);
4885}
4886
4887static const char *const s_async_json_packet_prefix = "JSON-async:";
4888
4889static StructuredData::ObjectSP
4890ParseStructuredDataPacket(llvm::StringRef packet) {
4891 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS(1u << 1)));
4892
4893 if (!packet.consume_front(s_async_json_packet_prefix)) {
4894 if (log) {
4895 log->Printf(
4896 "GDBRemoteCommmunicationClientBase::%s() received $J packet "
4897 "but was not a StructuredData packet: packet starts with "
4898 "%s",
4899 __FUNCTION__,
4900 packet.slice(0, strlen(s_async_json_packet_prefix)).str().c_str());
4901 }
4902 return StructuredData::ObjectSP();
4903 }
4904
4905 // This is an asynchronous JSON packet, destined for a
4906 // StructuredDataPlugin.
4907 StructuredData::ObjectSP json_sp = StructuredData::ParseJSON(packet);
4908 if (log) {
4909 if (json_sp) {
4910 StreamString json_str;
4911 json_sp->Dump(json_str);
4912 json_str.Flush();
4913 log->Printf("ProcessGDBRemote::%s() "
4914 "received Async StructuredData packet: %s",
4915 __FUNCTION__, json_str.GetData());
4916 } else {
4917 log->Printf("ProcessGDBRemote::%s"
4918 "() received StructuredData packet:"
4919 " parse failure",
4920 __FUNCTION__);
4921 }
4922 }
4923 return json_sp;
4924}
4925
4926void ProcessGDBRemote::HandleAsyncStructuredDataPacket(llvm::StringRef data) {
4927 auto structured_data_sp = ParseStructuredDataPacket(data);
4928 if (structured_data_sp)
4929 RouteAsyncStructuredData(structured_data_sp);
4930}
4931
4932class CommandObjectProcessGDBRemoteSpeedTest : public CommandObjectParsed {
4933public:
4934 CommandObjectProcessGDBRemoteSpeedTest(CommandInterpreter &interpreter)
4935 : CommandObjectParsed(interpreter, "process plugin packet speed-test",
4936 "Tests packet speeds of various sizes to determine "
4937 "the performance characteristics of the GDB remote "
4938 "connection. ",
4939 NULL__null),
4940 m_option_group(),
4941 m_num_packets(LLDB_OPT_SET_1(1U << 0), false, "count", 'c', 0, eArgTypeCount,
4942 "The number of packets to send of each varying size "
4943 "(default is 1000).",
4944 1000),
4945 m_max_send(LLDB_OPT_SET_1(1U << 0), false, "max-send", 's', 0, eArgTypeCount,
4946 "The maximum number of bytes to send in a packet. Sizes "
4947 "increase in powers of 2 while the size is less than or "
4948 "equal to this option value. (default 1024).",
4949 1024),
4950 m_max_recv(LLDB_OPT_SET_1(1U << 0), false, "max-receive", 'r', 0, eArgTypeCount,
4951 "The maximum number of bytes to receive in a packet. Sizes "
4952 "increase in powers of 2 while the size is less than or "
4953 "equal to this option value. (default 1024).",
4954 1024),
4955 m_json(LLDB_OPT_SET_1(1U << 0), false, "json", 'j',
4956 "Print the output as JSON data for easy parsing.", false, true) {
4957 m_option_group.Append(&m_num_packets, LLDB_OPT_SET_ALL0xFFFFFFFFU, LLDB_OPT_SET_1(1U << 0));
4958 m_option_group.Append(&m_max_send, LLDB_OPT_SET_ALL0xFFFFFFFFU, LLDB_OPT_SET_1(1U << 0));
4959 m_option_group.Append(&m_max_recv, LLDB_OPT_SET_ALL0xFFFFFFFFU, LLDB_OPT_SET_1(1U << 0));
4960 m_option_group.Append(&m_json, LLDB_OPT_SET_ALL0xFFFFFFFFU, LLDB_OPT_SET_1(1U << 0));
4961 m_option_group.Finalize();
4962 }
4963
4964 ~CommandObjectProcessGDBRemoteSpeedTest() {}
4965
4966 Options *GetOptions() override { return &m_option_group; }
4967
4968 bool DoExecute(Args &command, CommandReturnObject &result) override {
4969 const size_t argc = command.GetArgumentCount();
4970 if (argc == 0) {
4971 ProcessGDBRemote *process =
4972 (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
4973 .GetProcessPtr();
4974 if (process) {
4975 StreamSP output_stream_sp(
4976 m_interpreter.GetDebugger().GetAsyncOutputStream());
4977 result.SetImmediateOutputStream(output_stream_sp);
4978
4979 const uint32_t num_packets =
4980 (uint32_t)m_num_packets.GetOptionValue().GetCurrentValue();
4981 const uint64_t max_send = m_max_send.GetOptionValue().GetCurrentValue();
4982 const uint64_t max_recv = m_max_recv.GetOptionValue().GetCurrentValue();
4983 const bool json = m_json.GetOptionValue().GetCurrentValue();
4984 const uint64_t k_recv_amount =
4985 4 * 1024 * 1024; // Receive amount in bytes
4986 process->GetGDBRemote().TestPacketSpeed(
4987 num_packets, max_send, max_recv, k_recv_amount, json,
4988 output_stream_sp ? *output_stream_sp : result.GetOutputStream());
4989 result.SetStatus(eReturnStatusSuccessFinishResult);
4990 return true;
4991 }
4992 } else {
4993 result.AppendErrorWithFormat("'%s' takes no arguments",
4994 m_cmd_name.c_str());
4995 }
4996 result.SetStatus(eReturnStatusFailed);
4997 return false;
4998 }
4999
5000protected:
5001 OptionGroupOptions m_option_group;
5002 OptionGroupUInt64 m_num_packets;
5003 OptionGroupUInt64 m_max_send;
5004 OptionGroupUInt64 m_max_recv;
5005 OptionGroupBoolean m_json;
5006};
5007
5008class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed {
5009private:
5010public:
5011 CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter)
5012 : CommandObjectParsed(interpreter, "process plugin packet history",
5013 "Dumps the packet history buffer. ", NULL__null) {}
5014
5015 ~CommandObjectProcessGDBRemotePacketHistory() {}
5016
5017 bool DoExecute(Args &command, CommandReturnObject &result) override {
5018 const size_t argc = command.GetArgumentCount();
5019 if (argc == 0) {
5020 ProcessGDBRemote *process =
5021 (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
5022 .GetProcessPtr();
5023 if (process) {
5024 process->GetGDBRemote().DumpHistory(result.GetOutputStream());
5025 result.SetStatus(eReturnStatusSuccessFinishResult);
5026 return true;
5027 }
5028 } else {
5029 result.AppendErrorWithFormat("'%s' takes no arguments",
5030 m_cmd_name.c_str());
5031 }
5032 result.SetStatus(eReturnStatusFailed);
5033 return false;
5034 }
5035};
5036
5037class CommandObjectProcessGDBRemotePacketXferSize : public CommandObjectParsed {
5038private:
5039public:
5040 CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter)
5041 : CommandObjectParsed(
5042 interpreter, "process plugin packet xfer-size",
5043 "Maximum size that lldb will try to read/write one one chunk.",
5044 NULL__null) {}
5045
5046 ~CommandObjectProcessGDBRemotePacketXferSize() {}
5047
5048 bool DoExecute(Args &command, CommandReturnObject &result) override {
5049 const size_t argc = command.GetArgumentCount();
5050 if (argc == 0) {
5051 result.AppendErrorWithFormat("'%s' takes an argument to specify the max "
5052 "amount to be transferred when "
5053 "reading/writing",
5054 m_cmd_name.c_str());
5055 result.SetStatus(eReturnStatusFailed);
5056 return false;
5057 }
5058
5059 ProcessGDBRemote *process =
5060 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5061 if (process) {
5062 const char *packet_size = command.GetArgumentAtIndex(0);
5063 errno(*__errno_location ()) = 0;
5064 uint64_t user_specified_max = strtoul(packet_size, NULL__null, 10);
5065 if (errno(*__errno_location ()) == 0 && user_specified_max != 0) {
5066 process->SetUserSpecifiedMaxMemoryTransferSize(user_specified_max);
5067 result.SetStatus(eReturnStatusSuccessFinishResult);
5068 return true;
5069 }
5070 }
5071 result.SetStatus(eReturnStatusFailed);
5072 return false;
5073 }
5074};
5075
5076class CommandObjectProcessGDBRemotePacketSend : public CommandObjectParsed {
5077private:
5078public:
5079 CommandObjectProcessGDBRemotePacketSend(CommandInterpreter &interpreter)
5080 : CommandObjectParsed(interpreter, "process plugin packet send",
5081 "Send a custom packet through the GDB remote "
5082 "protocol and print the answer. "
5083 "The packet header and footer will automatically "
5084 "be added to the packet prior to sending and "
5085 "stripped from the result.",
5086 NULL__null) {}
5087
5088 ~CommandObjectProcessGDBRemotePacketSend() {}
5089
5090 bool DoExecute(Args &command, CommandReturnObject &result) override {
5091 const size_t argc = command.GetArgumentCount();
5092 if (argc == 0) {
5093 result.AppendErrorWithFormat(
5094 "'%s' takes a one or more packet content arguments",
5095 m_cmd_name.c_str());
5096 result.SetStatus(eReturnStatusFailed);
5097 return false;
5098 }
5099
5100 ProcessGDBRemote *process =
5101 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5102 if (process) {
5103 for (size_t i = 0; i < argc; ++i) {
5104 const char *packet_cstr = command.GetArgumentAtIndex(0);
5105 bool send_async = true;
5106 StringExtractorGDBRemote response;
5107 process->GetGDBRemote().SendPacketAndWaitForResponse(
5108 packet_cstr, response, send_async);
5109 result.SetStatus(eReturnStatusSuccessFinishResult);
5110 Stream &output_strm = result.GetOutputStream();
5111 output_strm.Printf(" packet: %s\n", packet_cstr);
5112 std::string &response_str = response.GetStringRef();
5113
5114 if (strstr(packet_cstr, "qGetProfileData") != NULL__null) {
5115 response_str = process->HarmonizeThreadIdsForProfileData(response);
5116 }
5117
5118 if (response_str.empty())
5119 output_strm.PutCString("response: \nerror: UNIMPLEMENTED\n");
5120 else
5121 output_strm.Printf("response: %s\n", response.GetStringRef().c_str());
5122 }
5123 }
5124 return true;
5125 }
5126};
5127
5128class CommandObjectProcessGDBRemotePacketMonitor : public CommandObjectRaw {
5129private:
5130public:
5131 CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter)
5132 : CommandObjectRaw(interpreter, "process plugin packet monitor",
5133 "Send a qRcmd packet through the GDB remote protocol "
5134 "and print the response."
5135 "The argument passed to this command will be hex "
5136 "encoded into a valid 'qRcmd' packet, sent and the "
5137 "response will be printed.") {}
5138
5139 ~CommandObjectProcessGDBRemotePacketMonitor() {}
5140
5141 bool DoExecute(const char *command, CommandReturnObject &result) override {
5142 if (command == NULL__null || command[0] == '\0') {
5143 result.AppendErrorWithFormat("'%s' takes a command string argument",
5144 m_cmd_name.c_str());
5145 result.SetStatus(eReturnStatusFailed);
5146 return false;
5147 }
5148
5149 ProcessGDBRemote *process =
5150 (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
5151 if (process) {
5152 StreamString packet;
5153 packet.PutCString("qRcmd,");
5154 packet.PutBytesAsRawHex8(command, strlen(command));
5155
5156 bool send_async = true;
5157 StringExtractorGDBRemote response;
5158 process->GetGDBRemote().SendPacketAndWaitForResponse(
5159 packet.GetString(), response, send_async);
5160 result.SetStatus(eReturnStatusSuccessFinishResult);
5161 Stream &output_strm = result.GetOutputStream();
5162 output_strm.Printf(" packet: %s\n", packet.GetData());
5163 const std::string &response_str = response.GetStringRef();
5164
5165 if (response_str.empty())
5166 output_strm.PutCString("response: \nerror: UNIMPLEMENTED\n");
5167 else
5168 output_strm.Printf("response: %s\n", response.GetStringRef().c_str());
5169 }
5170 return true;
5171 }
5172};
5173
5174class CommandObjectProcessGDBRemotePacket : public CommandObjectMultiword {
5175private:
5176public:
5177 CommandObjectProcessGDBRemotePacket(CommandInterpreter &interpreter)
5178 : CommandObjectMultiword(interpreter, "process plugin packet",
5179 "Commands that deal with GDB remote packets.",
5180 NULL__null) {
5181 LoadSubCommand(
5182 "history",
5183 CommandObjectSP(
5184 new CommandObjectProcessGDBRemotePacketHistory(interpreter)));
5185 LoadSubCommand(
5186 "send", CommandObjectSP(
5187 new CommandObjectProcessGDBRemotePacketSend(interpreter)));
5188 LoadSubCommand(
5189 "monitor",
5190 CommandObjectSP(
5191 new CommandObjectProcessGDBRemotePacketMonitor(interpreter)));
5192 LoadSubCommand(
5193 "xfer-size",
5194 CommandObjectSP(
5195 new CommandObjectProcessGDBRemotePacketXferSize(interpreter)));
5196 LoadSubCommand("speed-test",
5197 CommandObjectSP(new CommandObjectProcessGDBRemoteSpeedTest(
5198 interpreter)));
5199 }
5200
5201 ~CommandObjectProcessGDBRemotePacket() {}
5202};
5203
5204class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword {
5205public:
5206 CommandObjectMultiwordProcessGDBRemote(CommandInterpreter &interpreter)
5207 : CommandObjectMultiword(
5208 interpreter, "process plugin",
5209 "Commands for operating on a ProcessGDBRemote process.",
5210 "process plugin <subcommand> [<subcommand-options>]") {
5211 LoadSubCommand(
5212 "packet",
5213 CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter)));
5214 }
5215
5216 ~CommandObjectMultiwordProcessGDBRemote() {}
5217};
5218
5219CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
5220 if (!m_command_sp)
5221 m_command_sp.reset(new CommandObjectMultiwordProcessGDBRemote(
5222 GetTarget().GetDebugger().GetCommandInterpreter()));
5223 return m_command_sp.get();
5224}