LLDB  mainline
Trace.cpp
Go to the documentation of this file.
1 //===-- Trace.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/Target/Trace.h"
10 
11 #include "llvm/Support/Format.h"
12 
13 #include "lldb/Core/Module.h"
15 #include "lldb/Symbol/Function.h"
17 #include "lldb/Target/Process.h"
19 #include "lldb/Target/Thread.h"
20 #include "lldb/Utility/LLDBLog.h"
21 #include "lldb/Utility/Stream.h"
22 #include <optional>
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 using namespace llvm;
27 
28 // Helper structs used to extract the type of a JSON trace bundle description
29 // object without having to parse the entire object.
30 
33 };
34 
35 namespace llvm {
36 namespace json {
37 
38 bool fromJSON(const Value &value, JSONSimpleTraceBundleDescription &bundle,
39  Path path) {
40  json::ObjectMapper o(value, path);
41  return o && o.map("type", bundle.type);
42 }
43 
44 } // namespace json
45 } // namespace llvm
46 
47 /// Helper functions for fetching data in maps and returning Optionals or
48 /// pointers instead of iterators for simplicity. It's worth mentioning that the
49 /// Optionals version can't return the inner data by reference because of
50 /// limitations in move constructors.
51 /// \{
52 template <typename K, typename V>
53 static std::optional<V> Lookup(DenseMap<K, V> &map, K k) {
54  auto it = map.find(k);
55  if (it == map.end())
56  return std::nullopt;
57  return it->second;
58 }
59 
60 template <typename K, typename V>
61 static V *LookupAsPtr(DenseMap<K, V> &map, K k) {
62  auto it = map.find(k);
63  if (it == map.end())
64  return nullptr;
65  return &it->second;
66 }
67 
68 /// Similar to the methods above but it looks for an item in a map of maps.
69 template <typename K1, typename K2, typename V>
70 static std::optional<V> Lookup(DenseMap<K1, DenseMap<K2, V>> &map, K1 k1,
71  K2 k2) {
72  auto it = map.find(k1);
73  if (it == map.end())
74  return std::nullopt;
75  return Lookup(it->second, k2);
76 }
77 
78 /// Similar to the methods above but it looks for an item in a map of maps.
79 template <typename K1, typename K2, typename V>
80 static V *LookupAsPtr(DenseMap<K1, DenseMap<K2, V>> &map, K1 k1, K2 k2) {
81  auto it = map.find(k1);
82  if (it == map.end())
83  return nullptr;
84  return LookupAsPtr(it->second, k2);
85 }
86 /// \}
87 
88 static Error createInvalidPlugInError(StringRef plugin_name) {
89  return createStringError(
90  std::errc::invalid_argument,
91  "no trace plug-in matches the specified type: \"%s\"",
92  plugin_name.data());
93 }
94 
95 Expected<lldb::TraceSP>
96 Trace::LoadPostMortemTraceFromFile(Debugger &debugger,
97  const FileSpec &trace_description_file) {
98 
99  auto buffer_or_error =
100  MemoryBuffer::getFile(trace_description_file.GetPath());
101  if (!buffer_or_error) {
102  return createStringError(std::errc::invalid_argument,
103  "could not open input file: %s - %s.",
104  trace_description_file.GetPath().c_str(),
105  buffer_or_error.getError().message().c_str());
106  }
107 
108  Expected<json::Value> session_file =
109  json::parse(buffer_or_error.get()->getBuffer().str());
110  if (!session_file) {
111  return session_file.takeError();
112  }
113 
114  return Trace::FindPluginForPostMortemProcess(
115  debugger, *session_file,
116  trace_description_file.GetDirectory().AsCString());
117 }
118 
119 Expected<lldb::TraceSP> Trace::FindPluginForPostMortemProcess(
120  Debugger &debugger, const json::Value &trace_bundle_description,
121  StringRef bundle_dir) {
123  json::Path::Root root("traceBundle");
124  if (!json::fromJSON(trace_bundle_description, json_bundle, root))
125  return root.getError();
126 
127  if (auto create_callback =
128  PluginManager::GetTraceCreateCallback(json_bundle.type))
129  return create_callback(trace_bundle_description, bundle_dir, debugger);
130 
131  return createInvalidPlugInError(json_bundle.type);
132 }
133 
134 Expected<lldb::TraceSP> Trace::FindPluginForLiveProcess(llvm::StringRef name,
135  Process &process) {
136  if (!process.IsLiveDebugSession())
137  return createStringError(inconvertibleErrorCode(),
138  "Can't trace non-live processes");
139 
140  if (auto create_callback =
141  PluginManager::GetTraceCreateCallbackForLiveProcess(name))
142  return create_callback(process);
143 
144  return createInvalidPlugInError(name);
145 }
146 
147 Expected<StringRef> Trace::FindPluginSchema(StringRef name) {
148  StringRef schema = PluginManager::GetTraceSchema(name);
149  if (!schema.empty())
150  return schema;
151 
152  return createInvalidPlugInError(name);
153 }
154 
155 Error Trace::Start(const llvm::json::Value &request) {
156  if (!m_live_process)
157  return createStringError(
158  inconvertibleErrorCode(),
159  "Attempted to start tracing without a live process.");
160  return m_live_process->TraceStart(request);
161 }
162 
163 Error Trace::Stop() {
164  if (!m_live_process)
165  return createStringError(
166  inconvertibleErrorCode(),
167  "Attempted to stop tracing without a live process.");
168  return m_live_process->TraceStop(TraceStopRequest(GetPluginName()));
169 }
170 
171 Error Trace::Stop(llvm::ArrayRef<lldb::tid_t> tids) {
172  if (!m_live_process)
173  return createStringError(
174  inconvertibleErrorCode(),
175  "Attempted to stop tracing without a live process.");
176  return m_live_process->TraceStop(TraceStopRequest(GetPluginName(), tids));
177 }
178 
179 Expected<std::string> Trace::GetLiveProcessState() {
180  if (!m_live_process)
181  return createStringError(
182  inconvertibleErrorCode(),
183  "Attempted to fetch live trace information without a live process.");
184  return m_live_process->TraceGetState(GetPluginName());
185 }
186 
187 std::optional<uint64_t>
188 Trace::GetLiveThreadBinaryDataSize(lldb::tid_t tid, llvm::StringRef kind) {
189  Storage &storage = GetUpdatedStorage();
190  return Lookup(storage.live_thread_data, tid, ConstString(kind));
191 }
192 
193 std::optional<uint64_t> Trace::GetLiveCpuBinaryDataSize(lldb::cpu_id_t cpu_id,
194  llvm::StringRef kind) {
195  Storage &storage = GetUpdatedStorage();
196  return Lookup(storage.live_cpu_data_sizes, cpu_id, ConstString(kind));
197 }
198 
199 std::optional<uint64_t>
200 Trace::GetLiveProcessBinaryDataSize(llvm::StringRef kind) {
201  Storage &storage = GetUpdatedStorage();
202  return Lookup(storage.live_process_data, ConstString(kind));
203 }
204 
205 Expected<std::vector<uint8_t>>
206 Trace::GetLiveTraceBinaryData(const TraceGetBinaryDataRequest &request,
207  uint64_t expected_size) {
208  if (!m_live_process)
209  return createStringError(
210  inconvertibleErrorCode(),
211  formatv("Attempted to fetch live trace data without a live process. "
212  "Data kind = {0}, tid = {1}, cpu id = {2}.",
213  request.kind, request.tid, request.cpu_id));
214 
215  Expected<std::vector<uint8_t>> data =
216  m_live_process->TraceGetBinaryData(request);
217 
218  if (!data)
219  return data.takeError();
220 
221  if (data->size() != expected_size)
222  return createStringError(
223  inconvertibleErrorCode(),
224  formatv("Got incomplete live trace data. Data kind = {0}, expected "
225  "size = {1}, actual size = {2}, tid = {3}, cpu id = {4}",
226  request.kind, expected_size, data->size(), request.tid,
227  request.cpu_id));
228 
229  return data;
230 }
231 
232 Expected<std::vector<uint8_t>>
233 Trace::GetLiveThreadBinaryData(lldb::tid_t tid, llvm::StringRef kind) {
234  std::optional<uint64_t> size = GetLiveThreadBinaryDataSize(tid, kind);
235  if (!size)
236  return createStringError(
237  inconvertibleErrorCode(),
238  "Tracing data \"%s\" is not available for thread %" PRIu64 ".",
239  kind.data(), tid);
240 
241  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(), tid,
242  /*cpu_id=*/std::nullopt};
243  return GetLiveTraceBinaryData(request, *size);
244 }
245 
246 Expected<std::vector<uint8_t>>
247 Trace::GetLiveCpuBinaryData(lldb::cpu_id_t cpu_id, llvm::StringRef kind) {
248  if (!m_live_process)
249  return createStringError(
250  inconvertibleErrorCode(),
251  "Attempted to fetch live cpu data without a live process.");
252  std::optional<uint64_t> size = GetLiveCpuBinaryDataSize(cpu_id, kind);
253  if (!size)
254  return createStringError(
255  inconvertibleErrorCode(),
256  "Tracing data \"%s\" is not available for cpu_id %" PRIu64 ".",
257  kind.data(), cpu_id);
258 
259  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(),
260  /*tid=*/std::nullopt, cpu_id};
261  return m_live_process->TraceGetBinaryData(request);
262 }
263 
264 Expected<std::vector<uint8_t>>
265 Trace::GetLiveProcessBinaryData(llvm::StringRef kind) {
266  std::optional<uint64_t> size = GetLiveProcessBinaryDataSize(kind);
267  if (!size)
268  return createStringError(
269  inconvertibleErrorCode(),
270  "Tracing data \"%s\" is not available for the process.", kind.data());
271 
272  TraceGetBinaryDataRequest request{GetPluginName().str(), kind.str(),
273  /*tid=*/std::nullopt,
274  /*cpu_id*/ std::nullopt};
275  return GetLiveTraceBinaryData(request, *size);
276 }
277 
278 Trace::Storage &Trace::GetUpdatedStorage() {
279  RefreshLiveProcessState();
280  return m_storage;
281 }
282 
283 const char *Trace::RefreshLiveProcessState() {
284  if (!m_live_process)
285  return nullptr;
286 
287  uint32_t new_stop_id = m_live_process->GetStopID();
288  if (new_stop_id == m_stop_id)
289  return nullptr;
290 
291  Log *log = GetLog(LLDBLog::Target);
292  LLDB_LOG(log, "Trace::RefreshLiveProcessState invoked");
293 
294  m_stop_id = new_stop_id;
295  m_storage = Trace::Storage();
296 
297  auto do_refresh = [&]() -> Error {
298  Expected<std::string> json_string = GetLiveProcessState();
299  if (!json_string)
300  return json_string.takeError();
301 
302  Expected<TraceGetStateResponse> live_process_state =
303  json::parse<TraceGetStateResponse>(*json_string,
304  "TraceGetStateResponse");
305  if (!live_process_state)
306  return live_process_state.takeError();
307 
308  if (live_process_state->warnings) {
309  for (std::string &warning : *live_process_state->warnings)
310  LLDB_LOG(log, "== Warning when fetching the trace state: {0}", warning);
311  }
312 
313  for (const TraceThreadState &thread_state :
314  live_process_state->traced_threads) {
315  for (const TraceBinaryData &item : thread_state.binary_data)
316  m_storage.live_thread_data[thread_state.tid].insert(
317  {ConstString(item.kind), item.size});
318  }
319 
320  LLDB_LOG(log, "== Found {0} threads being traced",
321  live_process_state->traced_threads.size());
322 
323  if (live_process_state->cpus) {
324  m_storage.cpus.emplace();
325  for (const TraceCpuState &cpu_state : *live_process_state->cpus) {
326  m_storage.cpus->push_back(cpu_state.id);
327  for (const TraceBinaryData &item : cpu_state.binary_data)
328  m_storage.live_cpu_data_sizes[cpu_state.id].insert(
329  {ConstString(item.kind), item.size});
330  }
331  LLDB_LOG(log, "== Found {0} cpu cpus being traced",
332  live_process_state->cpus->size());
333  }
334 
335  for (const TraceBinaryData &item : live_process_state->process_binary_data)
336  m_storage.live_process_data.insert({ConstString(item.kind), item.size});
337 
338  return DoRefreshLiveProcessState(std::move(*live_process_state),
339  *json_string);
340  };
341 
342  if (Error err = do_refresh()) {
343  m_storage.live_refresh_error = toString(std::move(err));
344  return m_storage.live_refresh_error->c_str();
345  }
346 
347  return nullptr;
348 }
349 
350 Trace::Trace(ArrayRef<ProcessSP> postmortem_processes,
351  std::optional<std::vector<lldb::cpu_id_t>> postmortem_cpus) {
352  for (ProcessSP process_sp : postmortem_processes)
353  m_storage.postmortem_processes.push_back(process_sp.get());
354  m_storage.cpus = postmortem_cpus;
355 }
356 
357 Process *Trace::GetLiveProcess() { return m_live_process; }
358 
359 ArrayRef<Process *> Trace::GetPostMortemProcesses() {
360  return m_storage.postmortem_processes;
361 }
362 
363 std::vector<Process *> Trace::GetAllProcesses() {
364  if (Process *proc = GetLiveProcess())
365  return {proc};
366  return GetPostMortemProcesses();
367 }
368 
369 uint32_t Trace::GetStopID() {
370  RefreshLiveProcessState();
371  return m_stop_id;
372 }
373 
374 llvm::Expected<FileSpec>
375 Trace::GetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind) {
376  Storage &storage = GetUpdatedStorage();
377  if (std::optional<FileSpec> file =
378  Lookup(storage.postmortem_thread_data, tid, ConstString(kind)))
379  return *file;
380  else
381  return createStringError(
382  inconvertibleErrorCode(),
383  formatv("The thread with tid={0} doesn't have the tracing data {1}",
384  tid, kind));
385 }
386 
387 llvm::Expected<FileSpec> Trace::GetPostMortemCpuDataFile(lldb::cpu_id_t cpu_id,
388  llvm::StringRef kind) {
389  Storage &storage = GetUpdatedStorage();
390  if (std::optional<FileSpec> file =
391  Lookup(storage.postmortem_cpu_data, cpu_id, ConstString(kind)))
392  return *file;
393  else
394  return createStringError(
395  inconvertibleErrorCode(),
396  formatv("The cpu with id={0} doesn't have the tracing data {1}", cpu_id,
397  kind));
398 }
399 
400 void Trace::SetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind,
401  FileSpec file_spec) {
402  Storage &storage = GetUpdatedStorage();
403  storage.postmortem_thread_data[tid].insert({ConstString(kind), file_spec});
404 }
405 
406 void Trace::SetPostMortemCpuDataFile(lldb::cpu_id_t cpu_id,
407  llvm::StringRef kind, FileSpec file_spec) {
408  Storage &storage = GetUpdatedStorage();
409  storage.postmortem_cpu_data[cpu_id].insert({ConstString(kind), file_spec});
410 }
411 
413 Trace::OnLiveThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
414  OnBinaryDataReadCallback callback) {
415  Expected<std::vector<uint8_t>> data = GetLiveThreadBinaryData(tid, kind);
416  if (!data)
417  return data.takeError();
418  return callback(*data);
419 }
420 
421 llvm::Error Trace::OnLiveCpuBinaryDataRead(lldb::cpu_id_t cpu_id,
422  llvm::StringRef kind,
423  OnBinaryDataReadCallback callback) {
424  Storage &storage = GetUpdatedStorage();
425  if (std::vector<uint8_t> *cpu_data =
426  LookupAsPtr(storage.live_cpu_data, cpu_id, ConstString(kind)))
427  return callback(*cpu_data);
428 
429  Expected<std::vector<uint8_t>> data = GetLiveCpuBinaryData(cpu_id, kind);
430  if (!data)
431  return data.takeError();
432  auto it = storage.live_cpu_data[cpu_id].insert(
433  {ConstString(kind), std::move(*data)});
434  return callback(it.first->second);
435 }
436 
437 llvm::Error Trace::OnDataFileRead(FileSpec file,
438  OnBinaryDataReadCallback callback) {
439  ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
440  MemoryBuffer::getFile(file.GetPath());
441  if (std::error_code err = trace_or_error.getError())
442  return createStringError(
443  inconvertibleErrorCode(), "Failed fetching trace-related file %s. %s",
444  file.GetPath().c_str(), toString(errorCodeToError(err)).c_str());
445 
446  MemoryBuffer &data = **trace_or_error;
447  ArrayRef<uint8_t> array_ref(
448  reinterpret_cast<const uint8_t *>(data.getBufferStart()),
449  data.getBufferSize());
450  return callback(array_ref);
451 }
452 
454 Trace::OnPostMortemThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
455  OnBinaryDataReadCallback callback) {
456  if (Expected<FileSpec> file = GetPostMortemThreadDataFile(tid, kind))
457  return OnDataFileRead(*file, callback);
458  else
459  return file.takeError();
460 }
461 
463 Trace::OnPostMortemCpuBinaryDataRead(lldb::cpu_id_t cpu_id,
464  llvm::StringRef kind,
465  OnBinaryDataReadCallback callback) {
466  if (Expected<FileSpec> file = GetPostMortemCpuDataFile(cpu_id, kind))
467  return OnDataFileRead(*file, callback);
468  else
469  return file.takeError();
470 }
471 
472 llvm::Error Trace::OnThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
473  OnBinaryDataReadCallback callback) {
474  if (m_live_process)
475  return OnLiveThreadBinaryDataRead(tid, kind, callback);
476  else
477  return OnPostMortemThreadBinaryDataRead(tid, kind, callback);
478 }
479 
481 Trace::OnAllCpusBinaryDataRead(llvm::StringRef kind,
482  OnCpusBinaryDataReadCallback callback) {
483  DenseMap<cpu_id_t, ArrayRef<uint8_t>> buffers;
484  Storage &storage = GetUpdatedStorage();
485  if (!storage.cpus)
486  return Error::success();
487 
488  std::function<Error(std::vector<cpu_id_t>::iterator)> process_cpu =
489  [&](std::vector<cpu_id_t>::iterator cpu_id) -> Error {
490  if (cpu_id == storage.cpus->end())
491  return callback(buffers);
492 
493  return OnCpuBinaryDataRead(*cpu_id, kind,
494  [&](ArrayRef<uint8_t> data) -> Error {
495  buffers.try_emplace(*cpu_id, data);
496  auto next_id = cpu_id;
497  next_id++;
498  return process_cpu(next_id);
499  });
500  };
501  return process_cpu(storage.cpus->begin());
502 }
503 
504 llvm::Error Trace::OnCpuBinaryDataRead(lldb::cpu_id_t cpu_id,
505  llvm::StringRef kind,
506  OnBinaryDataReadCallback callback) {
507  if (m_live_process)
508  return OnLiveCpuBinaryDataRead(cpu_id, kind, callback);
509  else
510  return OnPostMortemCpuBinaryDataRead(cpu_id, kind, callback);
511 }
512 
513 ArrayRef<lldb::cpu_id_t> Trace::GetTracedCpus() {
514  Storage &storage = GetUpdatedStorage();
515  if (storage.cpus)
516  return *storage.cpus;
517  return {};
518 }
519 
520 std::vector<Process *> Trace::GetTracedProcesses() {
521  std::vector<Process *> processes;
522  Storage &storage = GetUpdatedStorage();
523 
524  for (Process *proc : storage.postmortem_processes)
525  processes.push_back(proc);
526 
527  if (m_live_process)
528  processes.push_back(m_live_process);
529  return processes;
530 }
lldb_private::toString
const char * toString(AppleArm64ExceptionClass EC)
Definition: AppleArm64ExceptionClass.h:38
lldb_private::TraceCpuState
Definition: TraceGDBRemotePackets.h:121
lldb_private::TraceGetBinaryDataRequest::kind
std::string kind
Identifier for the data.
Definition: TraceGDBRemotePackets.h:153
llvm
Definition: Debugger.h:51
JSONSimpleTraceBundleDescription::type
std::string type
Definition: Trace.cpp:32
lldb_private::TraceGetBinaryDataRequest
jLLDBTraceGetBinaryData gdb-remote packet
Definition: TraceGDBRemotePackets.h:149
lldb_private::Trace::OnBinaryDataReadCallback
std::function< llvm::Error(llvm::ArrayRef< uint8_t > data)> OnBinaryDataReadCallback
Definition: Trace.h:261
lldb_private::Value
Definition: Value.h:38
lldb_private::Process
Definition: Process.h:338
Module.h
lldb_private::TraceCpuState::id
lldb::cpu_id_t id
Definition: TraceGDBRemotePackets.h:122
SectionLoadList.h
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:192
LookupAsPtr
static V * LookupAsPtr(DenseMap< K, V > &map, K k)
Definition: Trace.cpp:61
Trace.h
lldb_private::Trace::Storage::cpus
std::optional< std::vector< lldb::cpu_id_t > > cpus
The list of cpus being traced.
Definition: Trace.h:575
Process.h
lldb_private::Trace::Storage
We package all the data that can change upon process stops to make sure this contract is very visible...
Definition: Trace.h:547
lldb_private::Trace::OnCpusBinaryDataReadCallback
std::function< llvm::Error(const llvm::DenseMap< lldb::cpu_id_t, llvm::ArrayRef< uint8_t > > &cpu_to_data)> OnCpusBinaryDataReadCallback
Definition: Trace.h:264
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::TraceThreadState::tid
lldb::tid_t tid
Definition: TraceGDBRemotePackets.h:111
lldb_private::Process::IsLiveDebugSession
virtual bool IsLiveDebugSession() const
Definition: Process.h:1425
JSONSimpleTraceBundleDescription
Definition: Trace.cpp:31
lldb_private::TraceBinaryData::kind
std::string kind
Identifier of data to fetch with jLLDBTraceGetBinaryData.
Definition: TraceGDBRemotePackets.h:100
lldb_private::TraceGetBinaryDataRequest::tid
std::optional< lldb::tid_t > tid
Optional tid if the data is related to a thread.
Definition: TraceGDBRemotePackets.h:155
lldb_private::ConstString
Definition: ConstString.h:39
Lookup
static std::optional< V > Lookup(DenseMap< K, V > &map, K k)
Helper functions for fetching data in maps and returning Optionals or pointers instead of iterators f...
Definition: Trace.cpp:53
lldb_private::Debugger
Definition: Debugger.h:75
lldb_private::Trace::Storage::live_cpu_data
llvm::DenseMap< lldb::cpu_id_t, llvm::DenseMap< ConstString, std::vector< uint8_t > > > live_cpu_data
cpu id -> data kind -> bytes
Definition: Trace.h:567
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
Thread.h
lldb_private::TraceGetBinaryDataRequest::cpu_id
std::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::Trace::Storage::postmortem_thread_data
llvm::DenseMap< lldb::tid_t, llvm::DenseMap< ConstString, FileSpec > > postmortem_thread_data
Postmortem traces can specific additional data files, which are represented in this variable using a ...
Definition: Trace.h:583
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::Trace::Storage::postmortem_cpu_data
llvm::DenseMap< lldb::cpu_id_t, llvm::DenseMap< ConstString, FileSpec > > postmortem_cpu_data
cpu id -> data kind -> file
Definition: Trace.h:587
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::FileSpec::GetDirectory
const ConstString & GetDirectory() const
Directory string const get accessor.
Definition: FileSpec.h:223
lldb_private::Trace::Storage::live_process_data
llvm::DenseMap< ConstString, uint64_t > live_process_data
data kind -> size
Definition: Trace.h:570
lldb_private::Trace::Storage::live_thread_data
llvm::DenseMap< lldb::tid_t, llvm::DenseMap< ConstString, uint64_t > > live_thread_data
These data kinds are returned by lldb-server when fetching the state of the tracing session.
Definition: Trace.h:559
lldb_private::Trace::Storage::live_cpu_data_sizes
llvm::DenseMap< lldb::cpu_id_t, llvm::DenseMap< ConstString, uint64_t > > live_cpu_data_sizes
cpu id -> data kind -> size
Definition: Trace.h:563
PluginManager.h
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:337
Function.h
lldb_private::TraceCpuState::binary_data
std::vector< TraceBinaryData > binary_data
List of binary data objects for this core.
Definition: TraceGDBRemotePackets.h:124
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::TraceBinaryData
Definition: TraceGDBRemotePackets.h:98
Error
llvm::Error Error
Definition: UdtRecordCompleter.cpp:35
createInvalidPlugInError
static Error createInvalidPlugInError(StringRef plugin_name)
Definition: Trace.cpp:88
llvm::json::fromJSON
bool fromJSON(const Value &value, JSONSimpleTraceBundleDescription &bundle, Path path)
Definition: Trace.cpp:38
Stream.h
lldb_private::Trace::Storage::postmortem_processes
std::vector< Process * > postmortem_processes
Portmortem processes traced by this object if doing non-live tracing.
Definition: Trace.h:550
lldb_private::Log
Definition: Log.h:115
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:366
lldb
Definition: SBAddress.h:15
LLDBLog.h
ExecutionContext.h
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::TraceThreadState
Definition: TraceGDBRemotePackets.h:110