LLDB mainline
TraceGDBRemotePackets.cpp
Go to the documentation of this file.
1//===-- TraceGDBRemotePackets.cpp -------------------------------*- C++ -*-===//
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
10
11using namespace llvm;
12using namespace llvm::json;
13
14namespace lldb_private {
15/// jLLDBTraceSupported
16/// \{
17bool fromJSON(const json::Value &value, TraceSupportedResponse &packet,
18 Path path) {
19 ObjectMapper o(value, path);
20 return o && o.map("description", packet.description) &&
21 o.map("name", packet.name);
22}
23
24json::Value toJSON(const TraceSupportedResponse &packet) {
25 return json::Value(
26 Object{{"description", packet.description}, {"name", packet.name}});
27}
28/// \}
29
30/// jLLDBTraceStart
31/// \{
32bool TraceStartRequest::IsProcessTracing() const { return !(bool)tids; }
33
34bool fromJSON(const json::Value &value, TraceStartRequest &packet, Path path) {
35 ObjectMapper o(value, path);
36 return o && o.map("type", packet.type) && o.map("tids", packet.tids);
37}
38
39json::Value toJSON(const TraceStartRequest &packet) {
40 return json::Value(Object{{"tids", packet.tids}, {"type", packet.type}});
41}
42/// \}
43
44/// jLLDBTraceStop
45/// \{
47 const std::vector<lldb::tid_t> &tids_)
48 : type(type) {
49 tids.emplace();
50 for (lldb::tid_t tid : tids_)
51 tids->push_back(tid);
52}
53
54bool TraceStopRequest::IsProcessTracing() const { return !(bool)tids; }
55
56bool fromJSON(const json::Value &value, TraceStopRequest &packet, Path path) {
57 ObjectMapper o(value, path);
58 return o && o.map("type", packet.type) && o.map("tids", packet.tids);
59}
60
61json::Value toJSON(const TraceStopRequest &packet) {
62 return json::Value(Object{{"type", packet.type}, {"tids", packet.tids}});
63}
64/// \}
65
66/// jLLDBTraceGetState
67/// \{
68bool fromJSON(const json::Value &value, TraceGetStateRequest &packet,
69 Path path) {
70 ObjectMapper o(value, path);
71 return o && o.map("type", packet.type);
72}
73
74json::Value toJSON(const TraceGetStateRequest &packet) {
75 return json::Value(Object{{"type", packet.type}});
76}
77
78bool fromJSON(const json::Value &value, TraceBinaryData &packet, Path path) {
79 ObjectMapper o(value, path);
80 return o && o.map("kind", packet.kind) && o.map("size", packet.size);
81}
82
83json::Value toJSON(const TraceBinaryData &packet) {
84 return json::Value(Object{{"kind", packet.kind}, {"size", packet.size}});
85}
86
87bool fromJSON(const json::Value &value, TraceThreadState &packet, Path path) {
88 ObjectMapper o(value, path);
89 return o && o.map("tid", packet.tid) &&
90 o.map("binaryData", packet.binary_data);
91}
92
93json::Value toJSON(const TraceThreadState &packet) {
94 return json::Value(
95 Object{{"tid", packet.tid}, {"binaryData", packet.binary_data}});
96}
97
98bool fromJSON(const json::Value &value, TraceGetStateResponse &packet,
99 Path path) {
100 ObjectMapper o(value, path);
101 return o && o.map("tracedThreads", packet.traced_threads) &&
102 o.map("processBinaryData", packet.process_binary_data) &&
103 o.map("cpus", packet.cpus) && o.map("warnings", packet.warnings);
104}
105
106json::Value toJSON(const TraceGetStateResponse &packet) {
107 return json::Value(Object{{"tracedThreads", packet.traced_threads},
108 {"processBinaryData", packet.process_binary_data},
109 {"cpus", packet.cpus},
110 {"warnings", packet.warnings}});
111}
112
114 if (!warnings)
115 warnings.emplace();
116 warnings->push_back(warning.data());
117}
118
119bool fromJSON(const json::Value &value, TraceCpuState &packet,
120 json::Path path) {
121 ObjectMapper o(value, path);
122 uint64_t cpu_id;
123 if (!(o && o.map("id", cpu_id) && o.map("binaryData", packet.binary_data)))
124 return false;
125 packet.id = static_cast<lldb::cpu_id_t>(cpu_id);
126 return true;
127}
128
129json::Value toJSON(const TraceCpuState &packet) {
130 return json::Value(
131 Object{{"id", packet.id}, {"binaryData", packet.binary_data}});
132}
133/// \}
134
135/// jLLDBTraceGetBinaryData
136/// \{
137json::Value toJSON(const TraceGetBinaryDataRequest &packet) {
138 return json::Value(Object{{"type", packet.type},
139 {"kind", packet.kind},
140 {"tid", packet.tid},
141 {"cpuId", packet.cpu_id}});
142}
143
144bool fromJSON(const json::Value &value, TraceGetBinaryDataRequest &packet,
145 Path path) {
146 ObjectMapper o(value, path);
147 std::optional<uint64_t> cpu_id;
148 if (!(o && o.map("type", packet.type) && o.map("kind", packet.kind) &&
149 o.map("tid", packet.tid) && o.map("cpuId", cpu_id)))
150 return false;
151
152 if (cpu_id)
153 packet.cpu_id = static_cast<lldb::cpu_id_t>(*cpu_id);
154 return true;
155}
156/// \}
157
158} // namespace lldb_private
static llvm::raw_ostream & warning(Stream &strm)
A class that represents a running process on the host machine.
bool fromJSON(const llvm::json::Value &value, TraceSupportedResponse &info, llvm::json::Path path)
llvm::json::Value toJSON(const TraceSupportedResponse &packet)
uint64_t tid_t
Definition: lldb-types.h:86
Definition: Debugger.h:51
std::string kind
Identifier of data to fetch with jLLDBTraceGetBinaryData.
uint64_t size
Size in bytes for this data.
std::vector< TraceBinaryData > binary_data
List of binary data objects for this core.
jLLDBTraceGetBinaryData gdb-remote packet
std::optional< lldb::cpu_id_t > cpu_id
Optional core id if the data is related to a cpu core.
std::optional< lldb::tid_t > tid
Optional tid if the data is related to a thread.
std::string kind
Identifier for the data.
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
std::optional< std::vector< std::string > > warnings
std::optional< std::vector< TraceCpuState > > cpus
std::vector< TraceThreadState > traced_threads
std::vector< TraceBinaryData > process_binary_data
void AddWarning(llvm::StringRef warning)
jLLDBTraceStart gdb-remote packet
bool IsProcessTracing() const
jLLDBTraceStart
std::optional< std::vector< lldb::tid_t > > tids
If std::nullopt, then this starts tracing the whole process.
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
jLLDBTraceStop gdb-remote packet
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
std::optional< std::vector< lldb::tid_t > > tids
If std::nullopt, then this stops tracing the whole process.
jLLDBTraceSupported gdb-remote packet
std::string name
The name of the technology, e.g.
std::string description
The description for the technology.
std::vector< TraceBinaryData > binary_data
List of binary data objects for this thread.