caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
adda256a7dafe9bd34ec388ee625abfa94de1bc0
clang-p2996/lldb/tools/intel-features/intel-pt/cli-wrapper-pt.cpp
Chandler Carruth 2946cd7010 Update the file headers across all of the LLVM projects in the monorepo 
to reflect the new license.

We understand that people may be surprised that we're moving the header
entirely to discuss the new license. We checked this carefully with the
Foundation's lawyer and we believe this is the correct approach.

Essentially, all code in the project is now made available by the LLVM
project under our new license, so you will see that the license headers
include that license only. Some of our contributors have contributed
code under our old license, and accordingly, we have retained a copy of
our old license notice in the top-level files in each project and
repository.

llvm-svn: 351636
2019-01-19 08:50:56 +00:00

583 lines
21 KiB
C++
Raw Blame History

//===-- cli-wrapper-pt.cpp -------------------------------------*- 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
//
// CLI Wrapper of PTDecoder Tool to enable it to be used through LLDB's CLI. The
// wrapper provides a new command called processor-trace with 4 child
// subcommands as follows:
// processor-trace start
// processor-trace stop
// processor-trace show-trace-options
// processor-trace show-instr-log
//
//===----------------------------------------------------------------------===//
#include <cerrno>
#include <cinttypes>
#include <cstring>
#include <string>
#include <vector>
#include "PTDecoder.h"
#include "cli-wrapper-pt.h"
#include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBTarget.h"
#include "lldb/API/SBThread.h"
static bool GetProcess(lldb::SBDebugger &debugger,
lldb::SBCommandReturnObject &result,
lldb::SBProcess &process) {
if (!debugger.IsValid()) {
result.Printf("error: invalid debugger\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
lldb::SBTarget target = debugger.GetSelectedTarget();
if (!target.IsValid()) {
result.Printf("error: invalid target inside debugger\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
process = target.GetProcess();
if (!process.IsValid() ||
(process.GetState() == lldb::StateType::eStateDetached) ||
(process.GetState() == lldb::StateType::eStateExited) ||
(process.GetState() == lldb::StateType::eStateInvalid)) {
result.Printf("error: invalid process inside debugger's target\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
return true;
}
static bool ParseCommandOption(char **command,
lldb::SBCommandReturnObject &result,
uint32_t &index, const std::string &arg,
uint32_t &parsed_result) {
char *endptr;
if (!command[++index]) {
result.Printf("error: option \"%s\" requires an argument\n", arg.c_str());
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
errno = 0;
unsigned long output = strtoul(command[index], &endptr, 0);
if ((errno != 0) || (*endptr != '\0')) {
result.Printf("error: invalid value \"%s\" provided for option \"%s\"\n",
command[index], arg.c_str());
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
if (output > UINT32_MAX) {
result.Printf("error: value \"%s\" for option \"%s\" exceeds UINT32_MAX\n",
command[index], arg.c_str());
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
parsed_result = (uint32_t)output;
return true;
}
static bool ParseCommandArgThread(char **command,
lldb::SBCommandReturnObject &result,
lldb::SBProcess &process, uint32_t &index,
lldb::tid_t &thread_id) {
char *endptr;
if (!strcmp(command[index], "all"))
thread_id = LLDB_INVALID_THREAD_ID;
else {
uint32_t thread_index_id;
errno = 0;
unsigned long output = strtoul(command[index], &endptr, 0);
if ((errno != 0) || (*endptr != '\0') || (output > UINT32_MAX)) {
result.Printf("error: invalid thread specification: \"%s\"\n",
command[index]);
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
thread_index_id = (uint32_t)output;
lldb::SBThread thread = process.GetThreadByIndexID(thread_index_id);
if (!thread.IsValid()) {
result.Printf(
"error: process has no thread with thread specification: \"%s\"\n",
command[index]);
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
thread_id = thread.GetThreadID();
}
return true;
}
class ProcessorTraceStart : public lldb::SBCommandPluginInterface {
public:
ProcessorTraceStart(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
: SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
~ProcessorTraceStart() {}
virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
lldb::SBCommandReturnObject &result) {
lldb::SBProcess process;
lldb::SBThread thread;
if (!GetProcess(debugger, result, process))
return false;
// Default initialize API's arguments
lldb::SBTraceOptions lldb_SBTraceOptions;
uint32_t trace_buffer_size = m_default_trace_buff_size;
lldb::tid_t thread_id;
// Parse Command line options
bool thread_argument_provided = false;
if (command) {
for (uint32_t i = 0; command[i]; i++) {
if (!strcmp(command[i], "-b")) {
if (!ParseCommandOption(command, result, i, "-b", trace_buffer_size))
return false;
} else {
thread_argument_provided = true;
if (!ParseCommandArgThread(command, result, process, i, thread_id))
return false;
}
}
}
if (!thread_argument_provided) {
thread = process.GetSelectedThread();
if (!thread.IsValid()) {
result.Printf("error: invalid current selected thread\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
thread_id = thread.GetThreadID();
}
if (trace_buffer_size > m_max_trace_buff_size)
trace_buffer_size = m_max_trace_buff_size;
// Set API's arguments with parsed values
lldb_SBTraceOptions.setType(lldb::TraceType::eTraceTypeProcessorTrace);
lldb_SBTraceOptions.setTraceBufferSize(trace_buffer_size);
lldb_SBTraceOptions.setMetaDataBufferSize(0);
lldb_SBTraceOptions.setThreadID(thread_id);
lldb::SBStream sb_stream;
sb_stream.Printf("{\"trace-tech\":\"intel-pt\"}");
lldb::SBStructuredData custom_params;
lldb::SBError error = custom_params.SetFromJSON(sb_stream);
if (!error.Success()) {
result.Printf("error: %s\n", error.GetCString());
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
lldb_SBTraceOptions.setTraceParams(custom_params);
// Start trace
pt_decoder_sp->StartProcessorTrace(process, lldb_SBTraceOptions, error);
if (!error.Success()) {
result.Printf("error: %s\n", error.GetCString());
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
return true;
}
private:
std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
const uint32_t m_max_trace_buff_size = 0x3fff;
const uint32_t m_default_trace_buff_size = 4096;
};
class ProcessorTraceInfo : public lldb::SBCommandPluginInterface {
public:
ProcessorTraceInfo(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
: SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
~ProcessorTraceInfo() {}
virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
lldb::SBCommandReturnObject &result) {
lldb::SBProcess process;
lldb::SBThread thread;
if (!GetProcess(debugger, result, process))
return false;
lldb::tid_t thread_id;
// Parse command line options
bool thread_argument_provided = false;
if (command) {
for (uint32_t i = 0; command[i]; i++) {
thread_argument_provided = true;
if (!ParseCommandArgThread(command, result, process, i, thread_id))
return false;
}
}
if (!thread_argument_provided) {
thread = process.GetSelectedThread();
if (!thread.IsValid()) {
result.Printf("error: invalid current selected thread\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
thread_id = thread.GetThreadID();
}
size_t loop_count = 1;
bool entire_process_tracing = false;
if (thread_id == LLDB_INVALID_THREAD_ID) {
entire_process_tracing = true;
loop_count = process.GetNumThreads();
}
// Get trace information
lldb::SBError error;
lldb::SBCommandReturnObject res;
for (size_t i = 0; i < loop_count; i++) {
error.Clear();
res.Clear();
if (entire_process_tracing)
thread = process.GetThreadAtIndex(i);
else
thread = process.GetThreadByID(thread_id);
thread_id = thread.GetThreadID();
ptdecoder::PTTraceOptions options;
pt_decoder_sp->GetProcessorTraceInfo(process, thread_id, options, error);
if (!error.Success()) {
res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
thread.GetIndexID(), thread_id, error.GetCString());
result.AppendMessage(res.GetOutput());
continue;
}
lldb::SBStructuredData data = options.GetTraceParams(error);
if (!error.Success()) {
res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
thread.GetIndexID(), thread_id, error.GetCString());
result.AppendMessage(res.GetOutput());
continue;
}
lldb::SBStream s;
error = data.GetAsJSON(s);
if (!error.Success()) {
res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
thread.GetIndexID(), thread_id, error.GetCString());
result.AppendMessage(res.GetOutput());
continue;
}
res.Printf("thread #%" PRIu32 ": tid=%" PRIu64
", trace buffer size=%" PRIu64 ", meta buffer size=%" PRIu64
", trace type=%" PRIu32 ", custom trace params=%s",
thread.GetIndexID(), thread_id, options.GetTraceBufferSize(),
options.GetMetaDataBufferSize(), options.GetType(),
s.GetData());
result.AppendMessage(res.GetOutput());
}
return true;
}
private:
std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
};
class ProcessorTraceShowInstrLog : public lldb::SBCommandPluginInterface {
public:
ProcessorTraceShowInstrLog(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
: SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
~ProcessorTraceShowInstrLog() {}
virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
lldb::SBCommandReturnObject &result) {
lldb::SBProcess process;
lldb::SBThread thread;
if (!GetProcess(debugger, result, process))
return false;
// Default initialize API's arguments
uint32_t offset;
bool offset_provided = false;
uint32_t count = m_default_count;
lldb::tid_t thread_id;
// Parse command line options
bool thread_argument_provided = false;
if (command) {
for (uint32_t i = 0; command[i]; i++) {
if (!strcmp(command[i], "-o")) {
if (!ParseCommandOption(command, result, i, "-o", offset))
return false;
offset_provided = true;
} else if (!strcmp(command[i], "-c")) {
if (!ParseCommandOption(command, result, i, "-c", count))
return false;
} else {
thread_argument_provided = true;
if (!ParseCommandArgThread(command, result, process, i, thread_id))
return false;
}
}
}
if (!thread_argument_provided) {
thread = process.GetSelectedThread();
if (!thread.IsValid()) {
result.Printf("error: invalid current selected thread\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
thread_id = thread.GetThreadID();
}
size_t loop_count = 1;
bool entire_process_tracing = false;
if (thread_id == LLDB_INVALID_THREAD_ID) {
entire_process_tracing = true;
loop_count = process.GetNumThreads();
}
// Get instruction log and disassemble it
lldb::SBError error;
lldb::SBCommandReturnObject res;
for (size_t i = 0; i < loop_count; i++) {
error.Clear();
res.Clear();
if (entire_process_tracing)
thread = process.GetThreadAtIndex(i);
else
thread = process.GetThreadByID(thread_id);
thread_id = thread.GetThreadID();
// If offset is not provided then calculate a default offset (to display
// last 'count' number of instructions)
if (!offset_provided)
offset = count - 1;
// Get the instruction log
ptdecoder::PTInstructionList insn_list;
pt_decoder_sp->GetInstructionLogAtOffset(process, thread_id, offset,
count, insn_list, error);
if (!error.Success()) {
res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
thread.GetIndexID(), thread_id, error.GetCString());
result.AppendMessage(res.GetOutput());
continue;
}
// Disassemble the instruction log
std::string disassembler_command("dis -c 1 -s ");
res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 "\n", thread.GetIndexID(),
thread_id);
lldb::SBCommandInterpreter sb_cmnd_interpreter(
debugger.GetCommandInterpreter());
lldb::SBCommandReturnObject result_obj;
for (size_t i = 0; i < insn_list.GetSize(); i++) {
ptdecoder::PTInstruction insn = insn_list.GetInstructionAtIndex(i);
uint64_t addr = insn.GetInsnAddress();
std::string error = insn.GetError();
if (!error.empty()) {
res.AppendMessage(error.c_str());
continue;
}
result_obj.Clear();
std::string complete_disassembler_command =
disassembler_command + std::to_string(addr);
sb_cmnd_interpreter.HandleCommand(complete_disassembler_command.c_str(),
result_obj, false);
std::string result_str(result_obj.GetOutput());
if (result_str.empty()) {
lldb::SBCommandReturnObject output;
output.Printf(" Disassembly not found for address: %" PRIu64, addr);
res.AppendMessage(output.GetOutput());
continue;
}
// LLDB's disassemble command displays assembly instructions along with
// the names of the functions they belong to. Parse this result to
// display only the assembly instructions and not the function names
// in an instruction log
std::size_t first_new_line_index = result_str.find_first_of('\n');
std::size_t last_new_line_index = result_str.find_last_of('\n');
if (first_new_line_index != last_new_line_index)
res.AppendMessage((result_str.substr(first_new_line_index + 1,
last_new_line_index -
first_new_line_index - 1))
.c_str());
else
res.AppendMessage(
(result_str.substr(0, result_str.length() - 1)).c_str());
}
result.AppendMessage(res.GetOutput());
}
return true;
}
private:
std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
const uint32_t m_default_count = 10;
};
class ProcessorTraceStop : public lldb::SBCommandPluginInterface {
public:
ProcessorTraceStop(std::shared_ptr<ptdecoder::PTDecoder> &pt_decoder)
: SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
~ProcessorTraceStop() {}
virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
lldb::SBCommandReturnObject &result) {
lldb::SBProcess process;
lldb::SBThread thread;
if (!GetProcess(debugger, result, process))
return false;
lldb::tid_t thread_id;
// Parse command line options
bool thread_argument_provided = false;
if (command) {
for (uint32_t i = 0; command[i]; i++) {
thread_argument_provided = true;
if (!ParseCommandArgThread(command, result, process, i, thread_id))
return false;
}
}
if (!thread_argument_provided) {
thread = process.GetSelectedThread();
if (!thread.IsValid()) {
result.Printf("error: invalid current selected thread\n");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
thread_id = thread.GetThreadID();
}
// Stop trace
lldb::SBError error;
pt_decoder_sp->StopProcessorTrace(process, error, thread_id);
if (!error.Success()) {
result.Printf("error: %s\n", error.GetCString());
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
return true;
}
private:
std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
};
bool PTPluginInitialize(lldb::SBDebugger &debugger) {
lldb::SBCommandInterpreter interpreter = debugger.GetCommandInterpreter();
lldb::SBCommand proc_trace = interpreter.AddMultiwordCommand(
"processor-trace", "Intel(R) Processor Trace for thread/process");
std::shared_ptr<ptdecoder::PTDecoder> PTDecoderSP(
new ptdecoder::PTDecoder(debugger));
lldb::SBCommandPluginInterface *proc_trace_start =
new ProcessorTraceStart(PTDecoderSP);
const char *help_proc_trace_start = "start Intel(R) Processor Trace on a "
"specific thread or on the whole process";
const char *syntax_proc_trace_start =
"processor-trace start <cmd-options>\n\n"
"\rcmd-options Usage:\n"
"\r processor-trace start [-b <buffer-size>] [<thread-index>]\n\n"
"\t\b-b <buffer-size>\n"
"\t size of the trace buffer to store the trace data. If not "
"specified then a default value will be taken\n\n"
"\t\b<thread-index>\n"
"\t thread index of the thread. If no threads are specified, "
"currently selected thread is taken.\n"
"\t Use the thread-index 'all' to start tracing the whole process\n";
proc_trace.AddCommand("start", proc_trace_start, help_proc_trace_start,
syntax_proc_trace_start);
lldb::SBCommandPluginInterface *proc_trace_stop =
new ProcessorTraceStop(PTDecoderSP);
const char *help_proc_trace_stop =
"stop Intel(R) Processor Trace on a specific thread or on whole process";
const char *syntax_proc_trace_stop =
"processor-trace stop <cmd-options>\n\n"
"\rcmd-options Usage:\n"
"\r processor-trace stop [<thread-index>]\n\n"
"\t\b<thread-index>\n"
"\t thread index of the thread. If no threads are specified, "
"currently selected thread is taken.\n"
"\t Use the thread-index 'all' to stop tracing the whole process\n";
proc_trace.AddCommand("stop", proc_trace_stop, help_proc_trace_stop,
syntax_proc_trace_stop);
lldb::SBCommandPluginInterface *proc_trace_show_instr_log =
new ProcessorTraceShowInstrLog(PTDecoderSP);
const char *help_proc_trace_show_instr_log =
"display a log of assembly instructions executed for a specific thread "
"or for the whole process.\n"
"The length of the log to be displayed and the offset in the whole "
"instruction log from where the log needs to be displayed can also be "
"provided. The offset is counted from the end of this whole "
"instruction log which means the last executed instruction is at offset "
"0 (zero)";
const char *syntax_proc_trace_show_instr_log =
"processor-trace show-instr-log <cmd-options>\n\n"
"\rcmd-options Usage:\n"
"\r processor-trace show-instr-log [-o <offset>] [-c <count>] "
"[<thread-index>]\n\n"
"\t\b-o <offset>\n"
"\t offset in the whole instruction log from where the log will be "
"displayed. If not specified then a default value will be taken\n\n"
"\t\b-c <count>\n"
"\t number of instructions to be displayed. If not specified then a "
"default value will be taken\n\n"
"\t\b<thread-index>\n"
"\t thread index of the thread. If no threads are specified, "
"currently selected thread is taken.\n"
"\t Use the thread-index 'all' to show instruction log for all the "
"threads of the process\n";
proc_trace.AddCommand("show-instr-log", proc_trace_show_instr_log,
help_proc_trace_show_instr_log,
syntax_proc_trace_show_instr_log);
lldb::SBCommandPluginInterface *proc_trace_options =
new ProcessorTraceInfo(PTDecoderSP);
const char *help_proc_trace_show_options =
"display all the information regarding Intel(R) Processor Trace for a "
"specific thread or for the whole process.\n"
"The information contains trace buffer size and configuration options"
" of Intel(R) Processor Trace.";
const char *syntax_proc_trace_show_options =
"processor-trace show-options <cmd-options>\n\n"
"\rcmd-options Usage:\n"
"\r processor-trace show-options [<thread-index>]\n\n"
"\t\b<thread-index>\n"
"\t thread index of the thread. If no threads are specified, "
"currently selected thread is taken.\n"
"\t Use the thread-index 'all' to display information for all threads "
"of the process\n";
proc_trace.AddCommand("show-trace-options", proc_trace_options,
help_proc_trace_show_options,
syntax_proc_trace_show_options);
return true;
}
Reference in New Issue View Git Blame Copy Permalink