131 lines
4.9 KiB
C++
131 lines
4.9 KiB
C++
//===-- 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
|