1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
//===-- TraceIntelPTBundleLoader.h ----------------------------*- C++ //-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLELOADER_H
#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLELOADER_H
#include "../common/ThreadPostMortemTrace.h"
#include "TraceIntelPTJSONStructs.h"
namespace lldb_private {
namespace trace_intel_pt {
class TraceIntelPT;
class TraceIntelPTBundleLoader {
public:
/// Helper struct holding the objects created when parsing a process
struct ParsedProcess {
lldb::TargetSP target_sp;
std::vector<lldb::ThreadPostMortemTraceSP> threads;
};
/// \param[in] debugger
/// The debugger that will own the targets to create.
///
/// \param[in] bundle_description
/// The JSON description of a trace bundle that follows the schema of the
/// intel pt trace plug-in.
///
/// \param[in] bundle_dir
/// The folder where the trace bundle is located.
TraceIntelPTBundleLoader(Debugger &debugger,
const llvm::json::Value &bundle_description,
llvm::StringRef bundle_dir)
: m_debugger(debugger), m_bundle_description(bundle_description),
m_bundle_dir(bundle_dir) {}
/// \return
/// The JSON schema for the bundle description.
static llvm::StringRef GetSchema();
/// Parse the trace bundle description and create the corresponding \a
/// Target objects. In case of an error, no targets are created.
///
/// \return
/// A \a lldb::TraceSP instance created according to the trace bundle
/// information. In case of errors, return a null pointer.
llvm::Expected<lldb::TraceSP> Load();
private:
/// Resolve non-absolute paths relative to the bundle folder.
FileSpec NormalizePath(const std::string &path);
/// Create a post-mortem thread associated with the given \p process
/// using the definition from \p thread.
lldb::ThreadPostMortemTraceSP ParseThread(Process &process,
const JSONThread &thread);
/// Given a bundle description and a list of fully parsed processes,
/// create an actual Trace instance that "traces" these processes.
llvm::Expected<lldb::TraceSP>
CreateTraceIntelPTInstance(JSONTraceBundleDescription &bundle_description,
std::vector<ParsedProcess> &parsed_processes);
/// Create an empty Process object with given pid and target.
llvm::Expected<ParsedProcess> CreateEmptyProcess(lldb::pid_t pid,
llvm::StringRef triple);
/// Create the corresponding Threads and Process objects given the JSON
/// process definition.
///
/// \param[in] process
/// The JSON process definition
llvm::Expected<ParsedProcess> ParseProcess(const JSONProcess &process);
/// Create a module associated with the given \p target using the definition
/// from \p module.
llvm::Error ParseModule(Target &target, const JSONModule &module);
/// Create a kernel process and cpu threads given the JSON kernel definition.
llvm::Expected<ParsedProcess>
ParseKernel(const JSONTraceBundleDescription &bundle_description);
/// Create a user-friendly error message upon a JSON-parsing failure using the
/// \a json::ObjectMapper functionality.
///
/// \param[in] root
/// The \a llvm::json::Path::Root used to parse the JSON \a value.
///
/// \param[in] value
/// The json value that failed to parse.
///
/// \return
/// An \a llvm::Error containing the user-friendly error message.
llvm::Error CreateJSONError(llvm::json::Path::Root &root,
const llvm::json::Value &value);
/// Create the corresponding Process, Thread and Module objects given this
/// bundle description.
llvm::Expected<std::vector<ParsedProcess>>
LoadBundle(const JSONTraceBundleDescription &bundle_description);
/// When applicable, augment the list of threads in the trace bundle by
/// inspecting the context switch trace. This only applies for threads of
/// processes already specified in this bundle description.
///
/// \return
/// An \a llvm::Error in case if failures, or \a llvm::Error::success
/// otherwise.
llvm::Error AugmentThreadsFromContextSwitches(
JSONTraceBundleDescription &bundle_description);
/// Modifiy the bundle description by normalizing all the paths relative to
/// the session file directory.
void NormalizeAllPaths(JSONTraceBundleDescription &bundle_description);
Debugger &m_debugger;
const llvm::json::Value &m_bundle_description;
const std::string m_bundle_dir;
};
} // namespace trace_intel_pt
} // namespace lldb_private
#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLELOADER_H
|
