1 //===-- GDBRemote.cpp -----------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Utility/GDBRemote.h"
10 
11 #include "lldb/Utility/Flags.h"
12 #include "lldb/Utility/Stream.h"
13 
14 #include <stdio.h>
15 
16 using namespace lldb;
17 using namespace lldb_private::repro;
18 using namespace lldb_private;
19 using namespace llvm;
20 
21 StreamGDBRemote::StreamGDBRemote() : StreamString() {}
22 
23 StreamGDBRemote::StreamGDBRemote(uint32_t flags, uint32_t addr_size,
24                                  ByteOrder byte_order)
25     : StreamString(flags, addr_size, byte_order) {}
26 
27 StreamGDBRemote::~StreamGDBRemote() {}
28 
29 int StreamGDBRemote::PutEscapedBytes(const void *s, size_t src_len) {
30   int bytes_written = 0;
31   const uint8_t *src = static_cast<const uint8_t *>(s);
32   bool binary_is_set = m_flags.Test(eBinary);
33   m_flags.Clear(eBinary);
34   while (src_len) {
35     uint8_t byte = *src;
36     src++;
37     src_len--;
38     if (byte == 0x23 || byte == 0x24 || byte == 0x7d || byte == 0x2a) {
39       bytes_written += PutChar(0x7d);
40       byte ^= 0x20;
41     }
42     bytes_written += PutChar(byte);
43   };
44   if (binary_is_set)
45     m_flags.Set(eBinary);
46   return bytes_written;
47 }
48 
49 llvm::StringRef GDBRemotePacket::GetTypeStr() const {
50   switch (type) {
51   case GDBRemotePacket::ePacketTypeSend:
52     return "send";
53   case GDBRemotePacket::ePacketTypeRecv:
54     return "read";
55   case GDBRemotePacket::ePacketTypeInvalid:
56     return "invalid";
57   }
58   llvm_unreachable("All enum cases should be handled");
59 }
60 
61 void GDBRemotePacket::Dump(Stream &strm) const {
62   strm.Printf("tid=0x%4.4" PRIx64 " <%4u> %s packet: %s\n", tid,
63               bytes_transmitted, GetTypeStr().data(), packet.data.c_str());
64 }
65 
66 void yaml::ScalarEnumerationTraits<GDBRemotePacket::Type>::enumeration(
67     IO &io, GDBRemotePacket::Type &value) {
68   io.enumCase(value, "Invalid", GDBRemotePacket::ePacketTypeInvalid);
69   io.enumCase(value, "Send", GDBRemotePacket::ePacketTypeSend);
70   io.enumCase(value, "Recv", GDBRemotePacket::ePacketTypeRecv);
71 }
72 
73 void yaml::ScalarTraits<GDBRemotePacket::BinaryData>::output(
74     const GDBRemotePacket::BinaryData &Val, void *, raw_ostream &Out) {
75   Out << toHex(Val.data);
76 }
77 
78 StringRef yaml::ScalarTraits<GDBRemotePacket::BinaryData>::input(
79     StringRef Scalar, void *, GDBRemotePacket::BinaryData &Val) {
80   Val.data = fromHex(Scalar);
81   return {};
82 }
83 
84 void yaml::MappingTraits<GDBRemotePacket>::mapping(IO &io,
85                                                    GDBRemotePacket &Packet) {
86   io.mapRequired("packet", Packet.packet);
87   io.mapRequired("type", Packet.type);
88   io.mapRequired("bytes", Packet.bytes_transmitted);
89   io.mapRequired("index", Packet.packet_idx);
90   io.mapRequired("tid", Packet.tid);
91 }
92 
93 StringRef
94 yaml::MappingTraits<GDBRemotePacket>::validate(IO &io,
95                                                GDBRemotePacket &Packet) {
96   if (Packet.bytes_transmitted != Packet.packet.data.size())
97     return "BinaryData size doesn't match bytes transmitted";
98 
99   return {};
100 }
101 
102 void GDBRemoteProvider::Keep() {
103   std::vector<std::string> files;
104   for (auto &recorder : m_packet_recorders) {
105     files.push_back(recorder->GetFilename().GetPath());
106   }
107 
108   FileSpec file = GetRoot().CopyByAppendingPathComponent(Info::file);
109   std::error_code ec;
110   llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
111   if (ec)
112     return;
113   yaml::Output yout(os);
114   yout << files;
115 }
116 
117 void GDBRemoteProvider::Discard() { m_packet_recorders.clear(); }
118 
119 llvm::Expected<std::unique_ptr<PacketRecorder>>
120 PacketRecorder::Create(const FileSpec &filename) {
121   std::error_code ec;
122   auto recorder = std::make_unique<PacketRecorder>(std::move(filename), ec);
123   if (ec)
124     return llvm::errorCodeToError(ec);
125   return std::move(recorder);
126 }
127 
128 PacketRecorder *GDBRemoteProvider::GetNewPacketRecorder() {
129   std::size_t i = m_packet_recorders.size() + 1;
130   std::string filename = (llvm::Twine(Info::name) + llvm::Twine("-") +
131                           llvm::Twine(i) + llvm::Twine(".yaml"))
132                              .str();
133   auto recorder_or_error =
134       PacketRecorder::Create(GetRoot().CopyByAppendingPathComponent(filename));
135   if (!recorder_or_error) {
136     llvm::consumeError(recorder_or_error.takeError());
137     return nullptr;
138   }
139 
140   m_packet_recorders.push_back(std::move(*recorder_or_error));
141   return m_packet_recorders.back().get();
142 }
143 
144 void PacketRecorder::Record(const GDBRemotePacket &packet) {
145   if (!m_record)
146     return;
147   yaml::Output yout(m_os);
148   yout << const_cast<GDBRemotePacket &>(packet);
149   m_os.flush();
150 }
151 
152 llvm::raw_ostream *GDBRemoteProvider::GetHistoryStream() {
153   FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file);
154 
155   std::error_code EC;
156   m_stream_up = std::make_unique<raw_fd_ostream>(history_file.GetPath(), EC,
157                                                  sys::fs::OpenFlags::OF_Text);
158   return m_stream_up.get();
159 }
160 
161 char GDBRemoteProvider::ID = 0;
162 const char *GDBRemoteProvider::Info::file = "gdb-remote.yaml";
163 const char *GDBRemoteProvider::Info::name = "gdb-remote";
164