6a9c3e6115
This patch should allow the user to set specific auto-completion type for their custom commands. To do so, we had to hoist the `CompletionType` enum so the user can access it and add a new completion type flag to the CommandScriptAdd Command Object. So now, the user can specify which completion type will be used with their custom command, when they register it. This also makes the `crashlog` custom commands use disk-file completion type, to browse through the user file system and load the report. Differential Revision: https://reviews.llvm.org/D152011 Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
414 lines
16 KiB
C++
414 lines
16 KiB
C++
//===-- CommandObjectRegister.cpp -----------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CommandObjectRegister.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/DumpRegisterValue.h"
|
|
#include "lldb/Host/OptionParser.h"
|
|
#include "lldb/Interpreter/CommandOptionArgumentTable.h"
|
|
#include "lldb/Interpreter/CommandReturnObject.h"
|
|
#include "lldb/Interpreter/OptionGroupFormat.h"
|
|
#include "lldb/Interpreter/OptionValueArray.h"
|
|
#include "lldb/Interpreter/OptionValueBoolean.h"
|
|
#include "lldb/Interpreter/OptionValueUInt64.h"
|
|
#include "lldb/Interpreter/Options.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/SectionLoadList.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Utility/Args.h"
|
|
#include "lldb/Utility/DataExtractor.h"
|
|
#include "lldb/Utility/RegisterValue.h"
|
|
#include "llvm/Support/Errno.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
// "register read"
|
|
#define LLDB_OPTIONS_register_read
|
|
#include "CommandOptions.inc"
|
|
|
|
class CommandObjectRegisterRead : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectRegisterRead(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(
|
|
interpreter, "register read",
|
|
"Dump the contents of one or more register values from the current "
|
|
"frame. If no register is specified, dumps them all.",
|
|
nullptr,
|
|
eCommandRequiresFrame | eCommandRequiresRegContext |
|
|
eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
|
|
m_format_options(eFormatDefault, UINT64_MAX, UINT64_MAX,
|
|
{{CommandArgumentType::eArgTypeFormat,
|
|
"Specify a format to be used for display. If this "
|
|
"is set, register fields will not be displayed."}}) {
|
|
CommandArgumentEntry arg;
|
|
CommandArgumentData register_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
register_arg.arg_type = eArgTypeRegisterName;
|
|
register_arg.arg_repetition = eArgRepeatStar;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg.push_back(register_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg);
|
|
|
|
// Add the "--format"
|
|
m_option_group.Append(&m_format_options,
|
|
OptionGroupFormat::OPTION_GROUP_FORMAT |
|
|
OptionGroupFormat::OPTION_GROUP_GDB_FMT,
|
|
LLDB_OPT_SET_ALL);
|
|
m_option_group.Append(&m_command_options);
|
|
m_option_group.Finalize();
|
|
}
|
|
|
|
~CommandObjectRegisterRead() override = default;
|
|
|
|
void
|
|
HandleArgumentCompletion(CompletionRequest &request,
|
|
OptionElementVector &opt_element_vector) override {
|
|
if (!m_exe_ctx.HasProcessScope())
|
|
return;
|
|
|
|
lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks(
|
|
GetCommandInterpreter(), lldb::eRegisterCompletion, request, nullptr);
|
|
}
|
|
|
|
Options *GetOptions() override { return &m_option_group; }
|
|
|
|
bool DumpRegister(const ExecutionContext &exe_ctx, Stream &strm,
|
|
RegisterContext ®_ctx, const RegisterInfo ®_info,
|
|
bool print_flags) {
|
|
RegisterValue reg_value;
|
|
if (!reg_ctx.ReadRegister(®_info, reg_value))
|
|
return false;
|
|
|
|
strm.Indent();
|
|
|
|
bool prefix_with_altname = (bool)m_command_options.alternate_name;
|
|
bool prefix_with_name = !prefix_with_altname;
|
|
DumpRegisterValue(reg_value, strm, reg_info, prefix_with_name,
|
|
prefix_with_altname, m_format_options.GetFormat(), 8,
|
|
exe_ctx.GetBestExecutionContextScope(), print_flags,
|
|
exe_ctx.GetTargetSP());
|
|
if ((reg_info.encoding == eEncodingUint) ||
|
|
(reg_info.encoding == eEncodingSint)) {
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
if (process && reg_info.byte_size == process->GetAddressByteSize()) {
|
|
addr_t reg_addr = reg_value.GetAsUInt64(LLDB_INVALID_ADDRESS);
|
|
if (reg_addr != LLDB_INVALID_ADDRESS) {
|
|
Address so_reg_addr;
|
|
if (exe_ctx.GetTargetRef().GetSectionLoadList().ResolveLoadAddress(
|
|
reg_addr, so_reg_addr)) {
|
|
strm.PutCString(" ");
|
|
so_reg_addr.Dump(&strm, exe_ctx.GetBestExecutionContextScope(),
|
|
Address::DumpStyleResolvedDescription);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
strm.EOL();
|
|
return true;
|
|
}
|
|
|
|
bool DumpRegisterSet(const ExecutionContext &exe_ctx, Stream &strm,
|
|
RegisterContext *reg_ctx, size_t set_idx,
|
|
bool primitive_only = false) {
|
|
uint32_t unavailable_count = 0;
|
|
uint32_t available_count = 0;
|
|
|
|
if (!reg_ctx)
|
|
return false; // thread has no registers (i.e. core files are corrupt,
|
|
// incomplete crash logs...)
|
|
|
|
const RegisterSet *const reg_set = reg_ctx->GetRegisterSet(set_idx);
|
|
if (reg_set) {
|
|
strm.Printf("%s:\n", (reg_set->name ? reg_set->name : "unknown"));
|
|
strm.IndentMore();
|
|
const size_t num_registers = reg_set->num_registers;
|
|
for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
|
|
const uint32_t reg = reg_set->registers[reg_idx];
|
|
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg);
|
|
// Skip the dumping of derived register if primitive_only is true.
|
|
if (primitive_only && reg_info && reg_info->value_regs)
|
|
continue;
|
|
|
|
if (reg_info && DumpRegister(exe_ctx, strm, *reg_ctx, *reg_info,
|
|
/*print_flags=*/false))
|
|
++available_count;
|
|
else
|
|
++unavailable_count;
|
|
}
|
|
strm.IndentLess();
|
|
if (unavailable_count) {
|
|
strm.Indent();
|
|
strm.Printf("%u registers were unavailable.\n", unavailable_count);
|
|
}
|
|
strm.EOL();
|
|
}
|
|
return available_count > 0;
|
|
}
|
|
|
|
protected:
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
Stream &strm = result.GetOutputStream();
|
|
RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
|
|
|
|
if (command.GetArgumentCount() == 0) {
|
|
size_t set_idx;
|
|
|
|
size_t num_register_sets = 1;
|
|
const size_t set_array_size = m_command_options.set_indexes.GetSize();
|
|
if (set_array_size > 0) {
|
|
for (size_t i = 0; i < set_array_size; ++i) {
|
|
set_idx =
|
|
m_command_options.set_indexes[i]->GetValueAs<uint64_t>().value_or(
|
|
UINT32_MAX);
|
|
if (set_idx < reg_ctx->GetRegisterSetCount()) {
|
|
if (!DumpRegisterSet(m_exe_ctx, strm, reg_ctx, set_idx)) {
|
|
if (errno)
|
|
result.AppendErrorWithFormatv("register read failed: {0}\n",
|
|
llvm::sys::StrError());
|
|
else
|
|
result.AppendError("unknown error while reading registers.\n");
|
|
break;
|
|
}
|
|
} else {
|
|
result.AppendErrorWithFormat(
|
|
"invalid register set index: %" PRIu64 "\n", (uint64_t)set_idx);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
if (m_command_options.dump_all_sets)
|
|
num_register_sets = reg_ctx->GetRegisterSetCount();
|
|
|
|
for (set_idx = 0; set_idx < num_register_sets; ++set_idx) {
|
|
// When dump_all_sets option is set, dump primitive as well as
|
|
// derived registers.
|
|
DumpRegisterSet(m_exe_ctx, strm, reg_ctx, set_idx,
|
|
!m_command_options.dump_all_sets.GetCurrentValue());
|
|
}
|
|
}
|
|
} else {
|
|
if (m_command_options.dump_all_sets) {
|
|
result.AppendError("the --all option can't be used when registers "
|
|
"names are supplied as arguments\n");
|
|
} else if (m_command_options.set_indexes.GetSize() > 0) {
|
|
result.AppendError("the --set <set> option can't be used when "
|
|
"registers names are supplied as arguments\n");
|
|
} else {
|
|
for (auto &entry : command) {
|
|
// in most LLDB commands we accept $rbx as the name for register RBX
|
|
// - and here we would reject it and non-existant. we should be more
|
|
// consistent towards the user and allow them to say reg read $rbx -
|
|
// internally, however, we should be strict and not allow ourselves
|
|
// to call our registers $rbx in our own API
|
|
auto arg_str = entry.ref();
|
|
arg_str.consume_front("$");
|
|
|
|
if (const RegisterInfo *reg_info =
|
|
reg_ctx->GetRegisterInfoByName(arg_str)) {
|
|
// If they have asked for a specific format don't obscure that by
|
|
// printing flags afterwards.
|
|
bool print_flags =
|
|
!m_format_options.GetFormatValue().OptionWasSet();
|
|
if (!DumpRegister(m_exe_ctx, strm, *reg_ctx, *reg_info,
|
|
print_flags))
|
|
strm.Printf("%-12s = error: unavailable\n", reg_info->name);
|
|
} else {
|
|
result.AppendErrorWithFormat("Invalid register name '%s'.\n",
|
|
arg_str.str().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result.Succeeded();
|
|
}
|
|
|
|
class CommandOptions : public OptionGroup {
|
|
public:
|
|
CommandOptions()
|
|
: set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)),
|
|
dump_all_sets(false, false), // Initial and default values are false
|
|
alternate_name(false, false) {}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::ArrayRef(g_register_read_options);
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
set_indexes.Clear();
|
|
dump_all_sets.Clear();
|
|
alternate_name.Clear();
|
|
}
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
const int short_option = GetDefinitions()[option_idx].short_option;
|
|
switch (short_option) {
|
|
case 's': {
|
|
OptionValueSP value_sp(OptionValueUInt64::Create(option_value, error));
|
|
if (value_sp)
|
|
set_indexes.AppendValue(value_sp);
|
|
} break;
|
|
|
|
case 'a':
|
|
// When we don't use OptionValue::SetValueFromCString(const char *) to
|
|
// set an option value, it won't be marked as being set in the options
|
|
// so we make a call to let users know the value was set via option
|
|
dump_all_sets.SetCurrentValue(true);
|
|
dump_all_sets.SetOptionWasSet();
|
|
break;
|
|
|
|
case 'A':
|
|
// When we don't use OptionValue::SetValueFromCString(const char *) to
|
|
// set an option value, it won't be marked as being set in the options
|
|
// so we make a call to let users know the value was set via option
|
|
alternate_name.SetCurrentValue(true);
|
|
dump_all_sets.SetOptionWasSet();
|
|
break;
|
|
|
|
default:
|
|
llvm_unreachable("Unimplemented option");
|
|
}
|
|
return error;
|
|
}
|
|
|
|
// Instance variables to hold the values for command options.
|
|
OptionValueArray set_indexes;
|
|
OptionValueBoolean dump_all_sets;
|
|
OptionValueBoolean alternate_name;
|
|
};
|
|
|
|
OptionGroupOptions m_option_group;
|
|
OptionGroupFormat m_format_options;
|
|
CommandOptions m_command_options;
|
|
};
|
|
|
|
// "register write"
|
|
class CommandObjectRegisterWrite : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectRegisterWrite(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "register write",
|
|
"Modify a single register value.", nullptr,
|
|
eCommandRequiresFrame | eCommandRequiresRegContext |
|
|
eCommandProcessMustBeLaunched |
|
|
eCommandProcessMustBePaused) {
|
|
CommandArgumentEntry arg1;
|
|
CommandArgumentEntry arg2;
|
|
CommandArgumentData register_arg;
|
|
CommandArgumentData value_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
register_arg.arg_type = eArgTypeRegisterName;
|
|
register_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg1.push_back(register_arg);
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
value_arg.arg_type = eArgTypeValue;
|
|
value_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg2.push_back(value_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg1);
|
|
m_arguments.push_back(arg2);
|
|
}
|
|
|
|
~CommandObjectRegisterWrite() override = default;
|
|
|
|
void
|
|
HandleArgumentCompletion(CompletionRequest &request,
|
|
OptionElementVector &opt_element_vector) override {
|
|
if (!m_exe_ctx.HasProcessScope() || request.GetCursorIndex() != 0)
|
|
return;
|
|
|
|
lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks(
|
|
GetCommandInterpreter(), lldb::eRegisterCompletion, request, nullptr);
|
|
}
|
|
|
|
protected:
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
DataExtractor reg_data;
|
|
RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
|
|
|
|
if (command.GetArgumentCount() != 2) {
|
|
result.AppendError(
|
|
"register write takes exactly 2 arguments: <reg-name> <value>");
|
|
} else {
|
|
auto reg_name = command[0].ref();
|
|
auto value_str = command[1].ref();
|
|
|
|
// in most LLDB commands we accept $rbx as the name for register RBX -
|
|
// and here we would reject it and non-existant. we should be more
|
|
// consistent towards the user and allow them to say reg write $rbx -
|
|
// internally, however, we should be strict and not allow ourselves to
|
|
// call our registers $rbx in our own API
|
|
reg_name.consume_front("$");
|
|
|
|
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
|
|
|
|
if (reg_info) {
|
|
RegisterValue reg_value;
|
|
|
|
Status error(reg_value.SetValueFromString(reg_info, value_str));
|
|
if (error.Success()) {
|
|
if (reg_ctx->WriteRegister(reg_info, reg_value)) {
|
|
// Toss all frames and anything else in the thread after a register
|
|
// has been written.
|
|
m_exe_ctx.GetThreadRef().Flush();
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return true;
|
|
}
|
|
}
|
|
if (error.AsCString()) {
|
|
result.AppendErrorWithFormat(
|
|
"Failed to write register '%s' with value '%s': %s\n",
|
|
reg_name.str().c_str(), value_str.str().c_str(),
|
|
error.AsCString());
|
|
} else {
|
|
result.AppendErrorWithFormat(
|
|
"Failed to write register '%s' with value '%s'",
|
|
reg_name.str().c_str(), value_str.str().c_str());
|
|
}
|
|
} else {
|
|
result.AppendErrorWithFormat("Register not found for '%s'.\n",
|
|
reg_name.str().c_str());
|
|
}
|
|
}
|
|
return result.Succeeded();
|
|
}
|
|
};
|
|
|
|
// CommandObjectRegister constructor
|
|
CommandObjectRegister::CommandObjectRegister(CommandInterpreter &interpreter)
|
|
: CommandObjectMultiword(interpreter, "register",
|
|
"Commands to access registers for the current "
|
|
"thread and stack frame.",
|
|
"register [read|write] ...") {
|
|
LoadSubCommand("read",
|
|
CommandObjectSP(new CommandObjectRegisterRead(interpreter)));
|
|
LoadSubCommand("write",
|
|
CommandObjectSP(new CommandObjectRegisterWrite(interpreter)));
|
|
}
|
|
|
|
CommandObjectRegister::~CommandObjectRegister() = default;
|