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 
11 using namespace llvm;
12 using namespace llvm::json;
13 
14 namespace lldb_private {
15 /// jLLDBTraceSupported
16 /// \{
17 bool 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 
24 json::Value toJSON(const TraceSupportedResponse &packet) {
25  return json::Value(
26  Object{{"description", packet.description}, {"name", packet.name}});
27 }
28 /// \}
29 
30 /// jLLDBTraceStart
31 /// \{
32 bool TraceStartRequest::IsProcessTracing() const { return !(bool)tids; }
33 
34 bool 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 
39 json::Value toJSON(const TraceStartRequest &packet) {
40  return json::Value(Object{{"tids", packet.tids}, {"type", packet.type}});
41 }
42 /// \}
43 
44 /// jLLDBTraceStop
45 /// \{
46 TraceStopRequest::TraceStopRequest(llvm::StringRef type,
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 
54 bool TraceStopRequest::IsProcessTracing() const { return !(bool)tids; }
55 
56 bool 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 
61 json::Value toJSON(const TraceStopRequest &packet) {
62  return json::Value(Object{{"type", packet.type}, {"tids", packet.tids}});
63 }
64 /// \}
65 
66 /// jLLDBTraceGetState
67 /// \{
68 bool 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 
74 json::Value toJSON(const TraceGetStateRequest &packet) {
75  return json::Value(Object{{"type", packet.type}});
76 }
77 
78 bool 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 
83 json::Value toJSON(const TraceBinaryData &packet) {
84  return json::Value(Object{{"kind", packet.kind}, {"size", packet.size}});
85 }
86 
87 bool 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 
93 json::Value toJSON(const TraceThreadState &packet) {
94  return json::Value(
95  Object{{"tid", packet.tid}, {"binaryData", packet.binary_data}});
96 }
97 
98 bool 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 
106 json::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 
119 bool 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 
129 json::Value toJSON(const TraceCpuState &packet) {
130  return json::Value(
131  Object{{"id", packet.id}, {"binaryData", packet.binary_data}});
132 }
133 /// \}
134 
135 /// jLLDBTraceGetBinaryData
136 /// \{
137 json::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 
144 bool fromJSON(const json::Value &value, TraceGetBinaryDataRequest &packet,
145  Path path) {
146  ObjectMapper o(value, path);
147  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
lldb_private::toJSON
llvm::json::Value toJSON(const TraceSupportedResponse &packet)
Definition: TraceGDBRemotePackets.cpp:24
lldb_private::TraceStopRequest::IsProcessTracing
bool IsProcessTracing() const
Definition: TraceGDBRemotePackets.cpp:54
lldb_private::TraceCpuState
Definition: TraceGDBRemotePackets.h:121
lldb_private::TraceGetStateResponse::traced_threads
std::vector< TraceThreadState > traced_threads
Definition: TraceGDBRemotePackets.h:133
lldb_private::TraceGetBinaryDataRequest::kind
std::string kind
Identifier for the data.
Definition: TraceGDBRemotePackets.h:153
llvm
Definition: Debugger.h:50
lldb_private::TraceGetBinaryDataRequest
jLLDBTraceGetBinaryData gdb-remote packet
Definition: TraceGDBRemotePackets.h:149
lldb_private::TraceGetStateResponse
Definition: TraceGDBRemotePackets.h:132
lldb_private::TraceStartRequest::type
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
Definition: TraceGDBRemotePackets.h:45
lldb_private::TraceSupportedResponse::description
std::string description
The description for the technology.
Definition: TraceGDBRemotePackets.h:32
lldb_private::TraceSupportedResponse
jLLDBTraceSupported gdb-remote packet
Definition: TraceGDBRemotePackets.h:24
lldb_private::TraceStopRequest::tids
llvm::Optional< std::vector< lldb::tid_t > > tids
If llvm::None, then this stops tracing the whole process.
Definition: TraceGDBRemotePackets.h:77
lldb_private::TraceSupportedResponse::name
std::string name
The name of the technology, e.g.
Definition: TraceGDBRemotePackets.h:30
lldb_private::TraceCpuState::id
lldb::cpu_id_t id
Definition: TraceGDBRemotePackets.h:122
lldb_private::TraceGetStateRequest
}
Definition: TraceGDBRemotePackets.h:88
lldb_private::TraceGetStateResponse::process_binary_data
std::vector< TraceBinaryData > process_binary_data
Definition: TraceGDBRemotePackets.h:134
lldb_private::TraceStartRequest::tids
llvm::Optional< std::vector< lldb::tid_t > > tids
If llvm::None, then this starts tracing the whole process.
Definition: TraceGDBRemotePackets.h:49
lldb_private::TraceGetStateResponse::cpus
llvm::Optional< std::vector< TraceCpuState > > cpus
Definition: TraceGDBRemotePackets.h:135
llvm::json
Definition: Trace.cpp:35
lldb_private::TraceThreadState::tid
lldb::tid_t tid
Definition: TraceGDBRemotePackets.h:111
lldb_private::TraceBinaryData::kind
std::string kind
Identifier of data to fetch with jLLDBTraceGetBinaryData.
Definition: TraceGDBRemotePackets.h:100
lldb_private::TraceGetStateResponse::AddWarning
void AddWarning(llvm::StringRef warning)
Definition: TraceGDBRemotePackets.cpp:113
lldb_private::fromJSON
bool fromJSON(const llvm::json::Value &value, TraceSupportedResponse &info, llvm::json::Path path)
lldb_private::TraceBinaryData::size
uint64_t size
Size in bytes for this data.
Definition: TraceGDBRemotePackets.h:102
lldb_private::TraceStopRequest
jLLDBTraceStop gdb-remote packet
Definition: TraceGDBRemotePackets.h:64
lldb_private::TraceStartRequest
jLLDBTraceStart gdb-remote packet
Definition: TraceGDBRemotePackets.h:43
warning
static llvm::raw_ostream & warning(Stream &strm)
Definition: CommandReturnObject.cpp:23
lldb_private::TraceThreadState::binary_data
std::vector< TraceBinaryData > binary_data
List of binary data objects for this thread.
Definition: TraceGDBRemotePackets.h:113
uint32_t
lldb_private::LLDBLog::Object
@ Object
lldb_private::TraceGetStateRequest::type
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
Definition: TraceGDBRemotePackets.h:90
lldb_private::TraceGetBinaryDataRequest::tid
llvm::Optional< lldb::tid_t > tid
Optional tid if the data is related to a thread.
Definition: TraceGDBRemotePackets.h:155
lldb_private::TraceGetBinaryDataRequest::type
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
Definition: TraceGDBRemotePackets.h:151
lldb_private::TraceCpuState::binary_data
std::vector< TraceBinaryData > binary_data
List of binary data objects for this core.
Definition: TraceGDBRemotePackets.h:124
lldb_private::TraceGetBinaryDataRequest::cpu_id
llvm::Optional< lldb::cpu_id_t > cpu_id
Optional core id if the data is related to a cpu core.
Definition: TraceGDBRemotePackets.h:157
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::TraceBinaryData
Definition: TraceGDBRemotePackets.h:98
llvm::json::fromJSON
bool fromJSON(const Value &value, JSONSimpleTraceBundleDescription &bundle, Path path)
Definition: Trace.cpp:37
lldb_private::TraceGetStateResponse::warnings
llvm::Optional< std::vector< std::string > > warnings
Definition: TraceGDBRemotePackets.h:136
lldb_private::TraceStopRequest::type
std::string type
Tracing technology name, e.g. intel-pt, arm-coresight.
Definition: TraceGDBRemotePackets.h:74
TraceGDBRemotePackets.h
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::TraceThreadState
Definition: TraceGDBRemotePackets.h:110